Clear staged shared content on panic recovery; prune orphaned share keys

The crash-recovery replay calls ChatViewModel.panicClearAllData directly,
bypassing AppChromeModel.onPanicWipe, so a share-extension envelope staged
in the app group could survive an interrupted wipe. Clear the
SharedContentStore in panicClearAllData too (idempotent app-group key
removal). Also prune three orphaned, code-unreferenced share-status keys
(shared_link, shared_text, failed_to_encode) from the share-extension
catalog.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.github/workflows/fetch_georelays.yml

@@ -1,42 +1,228 @@
-name: Fetch GeoRelays Data
+name: Propose GeoRelay Data Update
 
 on:
   schedule:
-    - cron: '0 6 * * 0'
+    - cron: "0 6 * * 0"
   workflow_dispatch:
 
+# Default to read-only. The publishing job receives only the scopes required
+# to push its branch and publish either a PR or a tracking issue.
 permissions:
-  contents: write
-  pull-requests: write
+  contents: read
+
+concurrency:
+  group: georelay-data-update
+  cancel-in-progress: false
+
+env:
+  SOURCE_REPOSITORY: https://github.com/permissionlesstech/georelays.git
+  UPDATE_BRANCH: automation/georelay-data
+  TRACKING_ISSUE_TITLE: GeoRelay update awaiting pull request
 
 jobs:
-  update-relay-data:
+  propose-relay-data:
+    name: Validate and propose relay data
     runs-on: ubuntu-latest
+    timeout-minutes: 10
+    permissions:
+      contents: write
+      pull-requests: write
+      issues: write
 
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
+      - name: Checkout reviewed base
+        # Pinned actions/checkout v5 so a mutable action tag cannot change the
+        # code that receives this job's write-capable token.
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
+          ref: main
           fetch-depth: 0
+          # Do not expose the write token to fetch/validation subprocesses.
+          persist-credentials: false
 
-      - name: Fetch GeoRelays
+      - name: Test GeoRelay validator
         run: |
-          wget -q https://raw.githubusercontent.com/permissionlesstech/georelays/refs/heads/main/nostr_relays.csv
-          mv nostr_relays.csv ./relays/online_relays_gps.csv
+          set -euo pipefail
+          python3 -m unittest discover -s scripts/tests -p "test_*.py" -v
 
-      - name: Check for changes
-        id: git-check
+      - name: Fetch candidate over pinned HTTPS policy
+        id: upstream
         run: |
-          git diff --exit-code || echo "changes=true" >> $GITHUB_OUTPUT
+          set -euo pipefail
+          source_commit=$(git ls-remote --refs "$SOURCE_REPOSITORY" refs/heads/main | awk 'NR == 1 { print $1 }')
+          if [[ ! "$source_commit" =~ ^[0-9a-f]{40}$ ]]; then
+            echo "::error::Could not resolve an immutable upstream commit"
+            exit 1
+          fi
+          source_url="https://raw.githubusercontent.com/permissionlesstech/georelays/$source_commit/nostr_relays.csv"
+          effective_url=$(curl --fail --show-error --silent --location --proto "=https" --proto-redir "=https" --tlsv1.2 --max-time 60 --retry 3 --retry-all-errors --output "$RUNNER_TEMP/georelays-candidate.csv" --write-out "%{url_effective}" "$source_url")
+          if [[ "$effective_url" != "$source_url" ]]; then
+            echo "::error::Unexpected GeoRelay redirect target: $effective_url"
+            exit 1
+          fi
+          echo "source_commit=$source_commit" >> "$GITHUB_OUTPUT"
+          echo "source_url=$source_url" >> "$GITHUB_OUTPUT"
 
-      - name: Commit and push changes
-        if: steps.git-check.outputs.changes == 'true'
+      - name: Validate candidate against reviewed baseline
+        id: validation
         run: |
-          git config --local user.email "action@github.com"
-          git config --local user.name "GitHub Action"
-          git add relays/online_relays_gps.csv
-          git commit -m "Automated update of relay data - $(date -u)"
-          git push
+          set -euo pipefail
+          python3 scripts/validate_georelays.py --input "$RUNNER_TEMP/georelays-candidate.csv" --baseline relays/online_relays_gps.csv --output relays/online_relays_gps.csv --github-output "$GITHUB_OUTPUT"
+
+      - name: Check for a reviewed-file change
+        id: changes
+        run: |
+          set -euo pipefail
+          if git diff --quiet -- relays/online_relays_gps.csv; then
+            echo "changed=false" >> "$GITHUB_OUTPUT"
+            echo "Upstream GeoRelay data already matches main." >> "$GITHUB_STEP_SUMMARY"
+          else
+            echo "changed=true" >> "$GITHUB_OUTPUT"
+            git diff --stat -- relays/online_relays_gps.csv
+          fi
+
+      - name: Push automation branch and publish review request
+        if: steps.changes.outputs.changed == 'true'
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GH_TOKEN: ${{ github.token }}
+          SOURCE_COMMIT: ${{ steps.upstream.outputs.source_commit }}
+          SOURCE_URL: ${{ steps.upstream.outputs.source_url }}
+          DATA_ROWS: ${{ steps.validation.outputs.data_rows }}
+          UNIQUE_RELAYS: ${{ steps.validation.outputs.unique_relays }}
+          DATA_SHA256: ${{ steps.validation.outputs.sha256 }}
+        run: |
+          set -euo pipefail
+
+          # Scope credential exposure to this final publishing step.
+          gh auth setup-git
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+
+          git switch -C "$UPDATE_BRANCH"
+          git add -- relays/online_relays_gps.csv
+          git diff --cached --quiet && {
+            echo "::error::Expected a staged GeoRelay data change"
+            exit 1
+          }
+          git commit -m "Update reviewed georelay directory" -m "Upstream-commit: $SOURCE_COMMIT"
+
+          remote_ref="refs/remotes/origin/$UPDATE_BRANCH"
+          if git fetch --no-tags origin "+refs/heads/$UPDATE_BRANCH:$remote_ref" 2>/dev/null; then
+            remote_sha=$(git rev-parse "$remote_ref")
+            git push --force-with-lease="refs/heads/$UPDATE_BRANCH:$remote_sha" origin "HEAD:refs/heads/$UPDATE_BRANCH"
+          else
+            git push origin "HEAD:refs/heads/$UPDATE_BRANCH"
+          fi
+
+          body_file="$RUNNER_TEMP/georelay-pr-body.md"
+          {
+            echo "## Automated GeoRelay data proposal"
+            echo
+            echo "- Source: $SOURCE_URL"
+            echo "- Upstream commit: $SOURCE_COMMIT"
+            echo "- Data rows: $DATA_ROWS"
+            echo "- Unique normalized relays: $UNIQUE_RELAYS"
+            echo "- SHA-256: $DATA_SHA256"
+            echo
+            echo "The candidate passed strict UTF-8, schema, size, row-count, secure-host, coordinate, duplicate-conflict, and baseline-delta validation."
+            echo
+            echo "This PR is intentionally not auto-merged. Review the relay additions/removals before merging."
+          } > "$body_file"
+
+          existing_pr=$(gh pr list --repo "$GITHUB_REPOSITORY" --state open --base main --head "$UPDATE_BRANCH" --json number --jq '.[0].number // empty')
+          pr_error="$RUNNER_TEMP/georelay-pr-error.txt"
+          pr_url=""
+          if [[ -n "$existing_pr" ]]; then
+            if gh pr edit "$existing_pr" --repo "$GITHUB_REPOSITORY" --title "Update reviewed GeoRelay directory" --body-file "$body_file" 2> "$pr_error"; then
+              pr_url=$(gh pr view "$existing_pr" --repo "$GITHUB_REPOSITORY" --json url --jq .url)
+            fi
+          else
+            if created_pr_url=$(gh pr create --repo "$GITHUB_REPOSITORY" --base main --head "$UPDATE_BRANCH" --title "Update reviewed GeoRelay directory" --body-file "$body_file" 2> "$pr_error"); then
+              pr_url="$created_pr_url"
+            fi
+          fi
+
+          tracking_issue_numbers=$(gh issue list --repo "$GITHUB_REPOSITORY" --state open --search "\"$TRACKING_ISSUE_TITLE\" in:title" --limit 100 --json number,title --jq ".[] | select(.title == \"$TRACKING_ISSUE_TITLE\") | .number")
+          tracking_issues=()
+          if [[ -n "$tracking_issue_numbers" ]]; then
+            mapfile -t tracking_issues <<< "$tracking_issue_numbers"
+          fi
+
+          if [[ -n "$pr_url" ]]; then
+            for issue_number in "${tracking_issues[@]}"; do
+              gh issue close "$issue_number" --repo "$GITHUB_REPOSITORY" --comment "A pull request is now available at $pr_url; closing this fallback tracking issue."
+            done
+            echo "Published GeoRelay review PR: $pr_url" >> "$GITHUB_STEP_SUMMARY"
+            exit 0
+          fi
+
+          echo "::warning::GITHUB_TOKEN could not create or update the GeoRelay pull request; publishing the issues-write fallback."
+          if [[ -s "$pr_error" ]]; then
+            cat "$pr_error" >&2
+          fi
+
+          compare_url="https://github.com/${GITHUB_REPOSITORY}/compare/main...${UPDATE_BRANCH}?expand=1"
+          issue_body_file="$RUNNER_TEMP/georelay-tracking-issue-body.md"
+          {
+            echo "## Validated GeoRelay update awaiting review"
+            echo
+            echo "The automation branch was updated, but this workflow token could not create or update the pull request. Use the compare link below to create it manually."
+            echo
+            echo "- Compare and create PR: $compare_url"
+            echo "- Automation branch: $UPDATE_BRANCH"
+            echo "- Source: $SOURCE_URL"
+            echo "- Upstream commit: $SOURCE_COMMIT"
+            echo "- Data rows: $DATA_ROWS"
+            echo "- Unique normalized relays: $UNIQUE_RELAYS"
+            echo "- SHA-256: $DATA_SHA256"
+            echo
+            echo "The snapshot passed the repository's strict validator before the branch was pushed."
+          } > "$issue_body_file"
+
+          if (( ${#tracking_issues[@]} > 0 )); then
+            primary_issue="${tracking_issues[0]}"
+            gh issue edit "$primary_issue" --repo "$GITHUB_REPOSITORY" --title "$TRACKING_ISSUE_TITLE" --body-file "$issue_body_file"
+            issue_url=$(gh issue view "$primary_issue" --repo "$GITHUB_REPOSITORY" --json url --jq .url)
+            for duplicate_issue in "${tracking_issues[@]:1}"; do
+              gh issue close "$duplicate_issue" --repo "$GITHUB_REPOSITORY" --comment "Closing duplicate GeoRelay automation tracking issue; #$primary_issue is canonical."
+            done
+          else
+            issue_url=$(gh issue create --repo "$GITHUB_REPOSITORY" --title "$TRACKING_ISSUE_TITLE" --body-file "$issue_body_file")
+          fi
+
+          # Do not claim success until the fallback issue was confirmed.
+          [[ -n "$issue_url" ]]
+          echo "Published GeoRelay tracking issue fallback: $issue_url" >> "$GITHUB_STEP_SUMMARY"
+
+      - name: Clean obsolete automation review state
+        if: steps.changes.outputs.changed == 'false'
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          set -euo pipefail
+          gh auth setup-git
+
+          existing_pr=$(gh pr list --repo "$GITHUB_REPOSITORY" --state open --base main --head "$UPDATE_BRANCH" --json number --jq '.[0].number // empty')
+          if [[ -n "$existing_pr" ]]; then
+            gh pr close "$existing_pr" --repo "$GITHUB_REPOSITORY" --comment "Upstream now matches the reviewed file on main; closing this obsolete automation proposal."
+            echo "Closed obsolete PR #$existing_pr." >> "$GITHUB_STEP_SUMMARY"
+          fi
+
+          tracking_issue_numbers=$(gh issue list --repo "$GITHUB_REPOSITORY" --state open --search "\"$TRACKING_ISSUE_TITLE\" in:title" --limit 100 --json number,title --jq ".[] | select(.title == \"$TRACKING_ISSUE_TITLE\") | .number")
+          if [[ -n "$tracking_issue_numbers" ]]; then
+            while IFS= read -r issue_number; do
+              gh issue close "$issue_number" --repo "$GITHUB_REPOSITORY" --comment "Upstream now matches the reviewed file on main; closing this obsolete automation tracker."
+              echo "Closed obsolete tracking issue #$issue_number." >> "$GITHUB_STEP_SUMMARY"
+            done <<< "$tracking_issue_numbers"
+          fi
+
+          if git ls-remote --exit-code --heads origin "refs/heads/$UPDATE_BRANCH" > /dev/null; then
+            git push origin --delete "$UPDATE_BRANCH"
+            echo "Deleted obsolete automation branch $UPDATE_BRANCH." >> "$GITHUB_STEP_SUMMARY"
+          else
+            ls_remote_status=$?
+            if (( ls_remote_status != 2 )); then
+              echo "::error::Could not inspect the obsolete automation branch"
+              exit "$ls_remote_status"
+            fi
+          fi

.github/workflows/swift-tests.yml

@@ -94,6 +94,24 @@ jobs:
           kill "$watchdog_pid" 2>/dev/null || true
           exit "$status"
 
+      # Read coverage before the serial benchmark command below rebuilds the
+      # test binary without instrumentation. Reporting against that newer
+      # binary makes llvm-cov reject the profile as out of date.
+      # Informational only: there is deliberately no percentage threshold, but
+      # a broken/missing report is a CI configuration error and must be visible.
+      - name: Coverage summary
+        run: |
+          BIN_PATH=$(swift build --show-bin-path --package-path ${{ matrix.path }})
+          PROF="$BIN_PATH/codecov/default.profdata"
+          XCTEST=$(find "$BIN_PATH" -maxdepth 1 -name '*.xctest' | head -1)
+          BINARY="$XCTEST/Contents/MacOS/$(basename "$XCTEST" .xctest)"
+          if [ ! -f "$PROF" ] || [ ! -f "$BINARY" ]; then
+            echo "::error::Coverage profile or test binary is missing"
+            exit 1
+          fi
+          xcrun llvm-cov report "$BINARY" -instr-profile "$PROF" \
+            -ignore-filename-regex='(Tests|\.build|checkouts|Mocks|_PreviewHelpers)'
+
       # Benchmarks run serially on an otherwise idle runner for stable
       # numbers; BITCHAT_PERF_LOG captures the PERF[...] lines for the gate.
       - name: Run performance benchmarks (serial)
@@ -115,22 +133,6 @@ jobs:
         timeout-minutes: 10
         run: ./scripts/check-perf-floors.sh perf-output.log
 
-      # Informational only: surfaces per-file and total line coverage in the
-      # job log so coverage trends are visible on every PR. No thresholds —
-      # this must never be the reason a build goes red.
-      - name: Coverage summary
-        run: |
-          BIN_PATH=$(swift build --show-bin-path --package-path ${{ matrix.path }})
-          PROF="$BIN_PATH/codecov/default.profdata"
-          XCTEST=$(find "$BIN_PATH" -maxdepth 1 -name '*.xctest' | head -1)
-          BINARY="$XCTEST/Contents/MacOS/$(basename "$XCTEST" .xctest)"
-          if [ -f "$PROF" ] && [ -f "$BINARY" ]; then
-            xcrun llvm-cov report "$BINARY" -instr-profile "$PROF" \
-              -ignore-filename-regex='(Tests|\.build|checkouts|Mocks|_PreviewHelpers)' || true
-          else
-            echo "No coverage data found; skipping summary."
-          fi
-
   # SPM tests do not link the shipping app targets. This job covers the
   # iOS-conditional paths and both universal Release link configurations.
   ios-build:
@@ -142,6 +144,9 @@ jobs:
       - name: Checkout code
         uses: actions/checkout@v5
 
+      - name: Check clean recipe safety
+        run: bash scripts/check-just-clean-safety.sh
+
       - name: Build iOS (simulator, no signing)
         # Build both simulator architectures so CI validates every vendored
         # Arti simulator slice and the configuration that ships.
@@ -169,6 +174,52 @@ jobs:
             CODE_SIGNING_ALLOWED=NO \
             build
 
+  # The SwiftPM matrix runs on macOS and cannot execute UIKit/CoreBluetooth
+  # conditional tests. Build the shared iOS test target and run it on the first
+  # available iPhone simulator from the runner image instead of hard-coding a
+  # model that changes when GitHub updates Xcode. The suite intentionally runs
+  # in one test runner: a number of integration tests exercise process-global
+  # stores and notification centers, so overlapping workers can corrupt each
+  # other's fixtures and turn sub-second tests into multi-minute timeouts.
+  ios-tests:
+    name: Run iOS simulator tests
+    runs-on: macos-latest
+    timeout-minutes: 20
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+
+      - name: Select available iPhone simulator
+        id: destination
+        run: |
+          destinations=$(xcodebuild -project bitchat.xcodeproj -scheme "bitchat (iOS)" -showdestinations)
+          destination_id=$(awk -F'id:' '
+            /platform:iOS Simulator/ && /name:iPhone/ && !found {
+              value=$2
+              sub(/,.*/, "", value)
+              gsub(/^[[:space:]]+|[[:space:]]+$/, "", value)
+              print value
+              found=1
+            }
+          ' <<< "$destinations")
+          if [ -z "$destination_id" ]; then
+            echo "::error::No available iPhone simulator destination found"
+            exit 1
+          fi
+          echo "id=$destination_id" >> "$GITHUB_OUTPUT"
+
+      - name: Run iOS tests
+        run: |
+          set -o pipefail
+          xcodebuild -project bitchat.xcodeproj \
+            -scheme "bitchat (iOS)" \
+            -sdk iphonesimulator \
+            -destination "platform=iOS Simulator,id=${{ steps.destination.outputs.id }}" \
+            -parallel-testing-enabled NO \
+            CODE_SIGNING_ALLOWED=NO \
+            test
+
   # Advisory only: SwiftLint reports style violations without ever failing the
   # build. Runs in a pinned container (no Xcode plugin, no pbxproj changes) so
   # it can never break the documented xcodebuild path or block a merge.

Configs/Local.xcconfig.example

@@ -3,3 +3,6 @@ DEVELOPMENT_TEAM = ABC123
 
 // Unique bundle id to be able to register and run locally
 PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat.$(DEVELOPMENT_TEAM)
+
+// App and share extension must use an App Group registered to your team.
+APP_GROUP_ID = group.chat.bitchat.$(DEVELOPMENT_TEAM)

Justfile

@@ -1,107 +1,66 @@
-# BitChat macOS Build Justfile
-# Handles temporary modifications needed to build and run on macOS
+# BitChat developer commands
+#
+# Builds use a repository-local, ignored DerivedData directory. No recipe
+# patches, restores, or removes tracked project/configuration files.
+
+project := "bitchat.xcodeproj"
+macos_scheme := "bitchat (macOS)"
+ios_scheme := "bitchat (iOS)"
+derived_data := ".DerivedData"
 
-# Default recipe - shows available commands
 default:
-    @echo "BitChat macOS Build Commands:"
-    @echo "  just run     - Build and run the macOS app"
-    @echo "  just build   - Build the macOS app only"
-    @echo "  just clean   - Clean build artifacts and restore original files"
-    @echo "  just check   - Check prerequisites"
-    @echo ""
-    @echo "Original files are preserved - modifications are temporary for builds only"
+    @echo "BitChat developer commands:"
+    @echo "  just run                Build and run the macOS app"
+    @echo "  just build              Build the macOS app without signing"
+    @echo "  just test               Run the SwiftPM test suite"
+    @echo "  just test-ios           Run tests on the iPhone 17 simulator"
+    @echo "  just clean              Remove repo-local build artifacts only"
+    @echo "  just nuke               Also remove nested package build caches"
+    @echo "  just check              Validate the development environment"
 
-# Check prerequisites
-check:
+# Static guard against reintroducing source-restoring or source-deleting clean
+# behavior. CI runs the same script directly.
+check-clean-safety:
+    @bash scripts/check-just-clean-safety.sh
+
+check: check-clean-safety
     @echo "Checking prerequisites..."
-    @command -v xcodebuild >/dev/null 2>&1 || (echo "❌ xcodebuild not found. Install Xcode from App Store" && exit 1)
-    @xcode-select -p | grep -q "Xcode.app" || (echo "❌ Full Xcode required, not just command line tools. Install from App Store and run:\n   sudo xcode-select -s /Applications/Xcode.app/Contents/Developer" && exit 1)
-    @test -d "/Applications/Xcode.app" || (echo "❌ Xcode.app not found in Applications folder. Install from App Store" && exit 1)
-    @xcodebuild -version >/dev/null 2>&1 || (echo "❌ Xcode not properly configured. Try:\n   sudo xcode-select -s /Applications/Xcode.app/Contents/Developer" && exit 1)
-    @security find-identity -v -p codesigning | grep -q "Apple Development\|Developer ID" || (echo "⚠️  No Developer ID found - code signing may fail" && exit 0)
-    @echo "✅ All prerequisites met"
+    @command -v xcodebuild >/dev/null 2>&1 || (echo "❌ xcodebuild not found. Install full Xcode." && exit 1)
+    @developer_dir="$$(xcode-select -p 2>/dev/null)"; case "$$developer_dir" in *.app/Contents/Developer) ;; *) echo "❌ Full Xcode is not selected. Run: sudo xcode-select -s /Applications/Xcode.app/Contents/Developer"; exit 1;; esac
+    @xcodebuild -version
+    @echo "✅ Development environment ready (a signing identity is not required for just build)"
 
-# Backup original files
-backup:
-    @echo "Backing up original project configuration..."
-    @if [ -f bitchat.xcodeproj/project.pbxproj ]; then cp bitchat.xcodeproj/project.pbxproj bitchat.xcodeproj/project.pbxproj.backup; fi
-    @if [ -f bitchat/Info.plist ]; then cp bitchat/Info.plist bitchat/Info.plist.backup; fi
-
-# Restore original files
-restore:
-    @echo "Restoring original project configuration..."
-    @if [ -f project.yml.backup ]; then mv project.yml.backup project.yml; fi
-    @# Restore iOS-specific files
-    @if [ -f bitchat/LaunchScreen.storyboard.ios ]; then mv bitchat/LaunchScreen.storyboard.ios bitchat/LaunchScreen.storyboard; fi
-    @# Use git to restore all modified files except Justfile
-    @git checkout -- project.yml bitchat.xcodeproj/project.pbxproj bitchat/Info.plist 2>/dev/null || echo "⚠️  Could not restore some files with git"
-    @# Remove any backup files
-    @rm -f bitchat.xcodeproj/project.pbxproj.backup bitchat/Info.plist.backup 2>/dev/null || true
-
-# Apply macOS-specific modifications
-patch-for-macos: backup
-    @echo "Temporarily hiding iOS-specific files for macOS build..."
-    @# Move iOS-specific files out of the way temporarily
-    @if [ -f bitchat/LaunchScreen.storyboard ]; then mv bitchat/LaunchScreen.storyboard bitchat/LaunchScreen.storyboard.ios; fi
-
-# Build the macOS app
-build: #check generate
+build: check
     @echo "Building BitChat for macOS..."
-    @xcodebuild -project bitchat.xcodeproj -scheme "bitchat (macOS)" -configuration Debug CODE_SIGN_IDENTITY="" CODE_SIGNING_REQUIRED=NO CODE_SIGN_ENTITLEMENTS="" build
+    @xcodebuild -project "{{project}}" -scheme "{{macos_scheme}}" -configuration Debug -derivedDataPath "{{derived_data}}" CODE_SIGNING_ALLOWED=NO build
 
-# Run the macOS app
 run: build
-    @echo "Launching BitChat..."
-    @find ~/Library/Developer/Xcode/DerivedData -name "bitchat.app" -path "*/Debug/*" -not -path "*/Index.noindex/*" | head -1 | xargs -I {} open "{}"
+    @app="{{derived_data}}/Build/Products/Debug/bitchat.app"; test -d "$$app" || (echo "❌ Built app not found at $$app" && exit 1); open "$$app"
 
-# Clean build artifacts and restore original files
-clean: restore
-    @echo "Cleaning build artifacts..."
-    @rm -rf ~/Library/Developer/Xcode/DerivedData/bitchat-* 2>/dev/null || true
-    @# Only remove the generated project if we have a backup, otherwise use git
-    @if [ -f bitchat.xcodeproj/project.pbxproj.backup ]; then \
-        rm -rf bitchat.xcodeproj; \
-    else \
-        git checkout -- bitchat.xcodeproj/project.pbxproj 2>/dev/null || echo "⚠️  Could not restore project.pbxproj"; \
-    fi
-    @rm -f project-macos.yml 2>/dev/null || true
-    @echo "✅ Cleaned and restored original files"
+# Backward-compatible alias for the old quick-run recipe.
+dev-run: run
 
-# Quick run without cleaning (for development)
-dev-run: check
-    @echo "Quick development build..."
-    @xcodebuild -project bitchat.xcodeproj -scheme "bitchat_macOS" -configuration Debug CODE_SIGN_IDENTITY="" CODE_SIGNING_REQUIRED=NO CODE_SIGN_ENTITLEMENTS="" build
-    @find ~/Library/Developer/Xcode/DerivedData -name "bitchat.app" -path "*/Debug/*" -not -path "*/Index.noindex/*" | head -1 | xargs -I {} open "{}"
+test:
+    @swift test
+
+test-ios: check
+    @xcodebuild -project "{{project}}" -scheme "{{ios_scheme}}" -sdk iphonesimulator -destination 'platform=iOS Simulator,name=iPhone 17' -derivedDataPath "{{derived_data}}" test
+
+# Artifact-only cleanup. In particular, this recipe never invokes Git and
+# never writes, moves, restores, or removes source/configuration files.
+clean:
+    @echo "Cleaning repo-local build artifacts..."
+    @rm -rf -- "{{derived_data}}" ".build"
+    @echo "✅ Cleaned {{derived_data}} and .build; tracked files were untouched"
+
+# Retain the familiar command, but keep it artifact-only as well.
+nuke: clean
+    @echo "Cleaning nested package build caches..."
+    @find localPackages -type d -name .build -prune -exec rm -rf -- {} +
+    @rm -rf -- ".cache"
+    @echo "✅ Removed repository build caches; tracked files were untouched"
 
-# Show app info
 info:
-    @echo "BitChat - Decentralized Mesh Messaging"
-    @echo "======================================"
-    @echo "• Native macOS SwiftUI app"
-    @echo "• Bluetooth LE mesh networking"
-    @echo "• End-to-end encryption"
-    @echo "• No internet required"
-    @echo "• Works offline with nearby devices"
-    @echo ""
-    @echo "Requirements:"
-    @echo "• macOS 13.0+ (Ventura)"
-    @echo "• Bluetooth LE capable Mac"
-    @echo "• Physical device (no simulator support)"
-    @echo ""
-    @echo "Usage:"
-    @echo "• Set nickname and start chatting"
-    @echo "• Use /join #channel for group chats"
-    @echo "• Use /msg @user for private messages"
-    @echo "• Triple-tap logo for emergency wipe"
-
-# Force clean everything (nuclear option)
-nuke:
-    @echo "🧨 Nuclear clean - removing all build artifacts and backups..."
-    @rm -rf ~/Library/Developer/Xcode/DerivedData/bitchat-* 2>/dev/null || true
-    @rm -rf bitchat.xcodeproj 2>/dev/null || true
-    @rm -f bitchat.xcodeproj/project.pbxproj.backup 2>/dev/null || true
-    @rm -f bitchat/Info.plist.backup 2>/dev/null || true
-    @# Restore iOS-specific files if they were moved
-    @if [ -f bitchat/LaunchScreen.storyboard.ios ]; then mv bitchat/LaunchScreen.storyboard.ios bitchat/LaunchScreen.storyboard; fi
-    @git checkout bitchat.xcodeproj/project.pbxproj bitchat/Info.plist 2>/dev/null || echo "⚠️  Not a git repo or no changes to restore"
-    @echo "✅ Nuclear clean complete"
+    @echo "BitChat - decentralized mesh messaging"
+    @echo "macOS 13+ and iOS 16+"
+    @echo "Bluetooth mesh behavior requires physical Bluetooth-capable devices"

PRIVACY_POLICY.md

@@ -22,7 +22,7 @@ bitchat is designed for private, account-free communication. This policy describ
 
 2. **Nickname, preferences, and relationships**
    - Your nickname, settings, favorites, petnames, read-receipt identifiers, and bounded operational metadata are stored locally.
-   - The share extension briefly places content you choose to share in the app-group preferences so the main app can import it.
+   - The share extension can retain one item you choose to share in the app-group preferences for up to 24 hours. The app shows the destination and a preview for review; it does not send the item automatically. The item is cleared when you add it to the composer, cancel, panic-wipe, or it expires.
 
 3. **Private group state**
    - Group names, rosters, creator identity, and key epoch are stored as protected files in Application Support.

README.md

@@ -93,30 +93,62 @@ For detailed protocol documentation, see the [Technical Whitepaper](WHITEPAPER.m
 
 ### Option 1: Using Xcode
 
-   ```bash
-   cd bitchat
-   open bitchat.xcodeproj
-   ```
+```bash
+open bitchat.xcodeproj
+```
 
-   To run on a device there're a few steps to prepare the code:
-   - Clone the local configs: `cp Configs/Local.xcconfig.example Configs/Local.xcconfig`
-   - Add your Developer Team ID into the newly created `Configs/Local.xcconfig`
-      - Bundle ID would be set to `chat.bitchat.<team_id>` (unless you set to something else)
-   - Entitlements need to be updated manually (TODO: Automate):
-      - Search and replace `group.chat.bitchat` with `group.<your_bundle_id>` (e.g. `group.chat.bitchat.ABC123`)
+For a signed device build, create your ignored local configuration and replace
+the example team ID with your Apple Developer Team ID:
+
+```bash
+cp Configs/Local.xcconfig.example Configs/Local.xcconfig
+```
+
+`Local.xcconfig.example` derives unique app and App Group identifiers from that
+team ID. The entitlement files already reference `$(APP_GROUP_ID)`, so tracked
+project or entitlement files do not need to be edited.
+
+Useful command-line checks from the repository root:
+
+```bash
+# macOS Debug build without signing
+xcodebuild -project bitchat.xcodeproj -scheme "bitchat (macOS)" \
+  -configuration Debug CODE_SIGNING_ALLOWED=NO build
+
+# Full SwiftPM test suite
+swift test
+
+# iOS simulator tests
+xcodebuild -project bitchat.xcodeproj -scheme "bitchat (iOS)" \
+  -sdk iphonesimulator \
+  -destination 'platform=iOS Simulator,name=iPhone 17' test
+```
+
+If `iPhone 17` is unavailable, choose an installed simulator from:
+
+```bash
+xcodebuild -showdestinations -project bitchat.xcodeproj -scheme "bitchat (iOS)"
+```
 
 ### Option 2: Using `just`
 
-   ```bash
-   brew install just
-   ```
+```bash
+brew install just
+just check
+just run
+```
 
-Want to try this on macos: `just run` will set it up and run from source.
-Run `just clean` afterwards to restore things to original state for mobile app building and development.
+`just build` and `just run` use the current `bitchat (macOS)` scheme and keep
+Xcode output in the ignored `.DerivedData/` directory. They never patch source,
+project, configuration, or entitlement files.
+
+`just clean` removes only `.DerivedData/` and `.build/`. It does not invoke Git
+or restore tracked files, so uncommitted work is preserved. `just test` runs the
+SwiftPM suite and `just test-ios` runs the iPhone 17 simulator suite.
 
 ## Localization
 
-- Base app resources live under `bitchat/Localization/Base.lproj/`. Add new copy to `Localizable.strings` and plural rules to `Localizable.stringsdict`.
-- Share extension strings are separate in `bitchatShareExtension/Localization/Base.lproj/Localizable.strings`.
+- App localizations live in `bitchat/Localizable.xcstrings`.
+- Share extension strings are separate in `bitchatShareExtension/Localization/Localizable.xcstrings`.
 - Prefer keys that describe intent (`app_info.features.offline.title`) and reuse existing ones where possible.
 - Run `xcodebuild -project bitchat.xcodeproj -scheme "bitchat (macOS)" -configuration Debug CODE_SIGNING_ALLOWED=NO build` to compile-check any localization updates.

bitchat.xcodeproj/project.pbxproj

@@ -70,6 +70,7 @@
 		A6E32D1B2E762EA70032EA8A /* Exceptions for "bitchat" folder in "bitchatShareExtension" target */ = {
 			isa = PBXFileSystemSynchronizedBuildFileExceptionSet;
 			membershipExceptions = (
+				Services/SharedContentHandoff.swift,
 				Services/TransportConfig.swift,
 			);
 			target = 57CA17A36A2532A6CFF367BB /* bitchatShareExtension */;

bitchat/App/AppArchitecture.swift

@@ -2,11 +2,6 @@ import BitFoundation
 import Combine
 import Foundation
 
-enum SharedContentKind: String, Sendable, Equatable {
-    case text
-    case url
-}
-
 enum RuntimeScenePhase: String, Sendable, Equatable {
     case active
     case inactive
@@ -25,7 +20,7 @@ enum AppEvent: Sendable, Equatable {
     case startupCompleted
     case scenePhaseChanged(RuntimeScenePhase)
     case openedURL(String)
-    case sharedContentAccepted(SharedContentKind)
+    case sharedContentReadyForReview(SharedContentKind)
     case notificationOpened(peerID: PeerID?)
     case deepLinkOpened(String)
     case torLifecycleChanged(TorLifecycleEvent)

bitchat/App/AppChromeModel.swift

@@ -20,6 +20,7 @@ final class AppChromeModel: ObservableObject {
     @Published var showScreenshotPrivacyWarning = false
 
     private let chatViewModel: ChatViewModel
+    private let onPanicWipe: () -> Void
     private var cancellables = Set<AnyCancellable>()
     /// The composer owns capture state above ChatViewModel. ContentView
     /// installs this hook so both panic entry points synchronously stop it.
@@ -28,8 +29,13 @@ final class AppChromeModel: ObservableObject {
     /// Bulletin-board coordinator, created on first use of the board sheet.
     private(set) lazy var boardManager = BoardManager(transport: chatViewModel.meshService)
 
-    init(chatViewModel: ChatViewModel, privateInboxModel: PrivateInboxModel) {
+    init(
+        chatViewModel: ChatViewModel,
+        privateInboxModel: PrivateInboxModel,
+        onPanicWipe: @escaping () -> Void = {}
+    ) {
         self.chatViewModel = chatViewModel
+        self.onPanicWipe = onPanicWipe
         self.nickname = chatViewModel.nickname
 
         bind(privateInboxModel: privateInboxModel)
@@ -106,6 +112,7 @@ final class AppChromeModel: ObservableObject {
 
     func panicClearAllData() {
         prepareForPanic?()
+        onPanicWipe()
         chatViewModel.panicClearAllData()
     }
 

bitchat/App/AppRuntime.swift

@@ -27,6 +27,7 @@ final class AppRuntime: ObservableObject {
     let peerListModel: PeerListModel
     let appChromeModel: AppChromeModel
     let boardAlertsModel: BoardAlertsModel
+    let sharedContentImportModel: SharedContentImportModel
 
     private let idBridge: NostrIdentityBridge
     private var cancellables = Set<AnyCancellable>()
@@ -41,7 +42,8 @@ final class AppRuntime: ObservableObject {
 
     init(
         keychain: KeychainManagerProtocol = KeychainManager.makeDefault(),
-        idBridge: NostrIdentityBridge = NostrIdentityBridge()
+        idBridge: NostrIdentityBridge = NostrIdentityBridge(),
+        sharedContentStore: SharedContentStore? = nil
     ) {
         self.idBridge = idBridge
         let conversations = ConversationStore()
@@ -84,9 +86,20 @@ final class AppRuntime: ObservableObject {
             peerIdentityStore: peerIdentityStore,
             locationPresenceStore: locationPresenceStore
         )
+        let resolvedSharedContentStore: SharedContentStore?
+        if let sharedContentStore {
+            resolvedSharedContentStore = sharedContentStore
+        } else if let sharedDefaults = UserDefaults(suiteName: BitchatApp.groupID) {
+            resolvedSharedContentStore = SharedContentStore(defaults: sharedDefaults)
+        } else {
+            resolvedSharedContentStore = nil
+        }
+        let sharedContentImportModel = SharedContentImportModel(store: resolvedSharedContentStore)
+        self.sharedContentImportModel = sharedContentImportModel
         self.appChromeModel = AppChromeModel(
             chatViewModel: self.chatViewModel,
-            privateInboxModel: self.privateInboxModel
+            privateInboxModel: self.privateInboxModel,
+            onPanicWipe: { sharedContentImportModel.discardAll() }
         )
         let chatViewModel = self.chatViewModel
         self.boardAlertsModel = BoardAlertsModel(
@@ -106,7 +119,6 @@ final class AppRuntime: ObservableObject {
                 }
             )
         )
-
         if chatViewModel.networkActivationAllowed {
             GeoRelayDirectory.shared.prefetchIfNeeded()
         }
@@ -328,45 +340,22 @@ private extension AppRuntime {
     }
 
     func checkForSharedContent() {
-        guard chatViewModel.networkActivationAllowed else { return }
-        guard let userDefaults = UserDefaults(suiteName: BitchatApp.groupID) else { return }
-        let clearSharedContent = {
-            userDefaults.removeObject(forKey: "sharedContent")
-            userDefaults.removeObject(forKey: "sharedContentType")
-            userDefaults.removeObject(forKey: "sharedContentDate")
+        let previousID = sharedContentImportModel.offer?.id
+        guard let payload = sharedContentImportModel.refresh(
+            destination: currentSharedContentDestination
+        ) else { return }
+
+        if previousID != payload.id {
+            record(.sharedContentReadyForReview(payload.kind))
         }
+    }
 
-        guard let sharedContent = userDefaults.string(forKey: "sharedContent"),
-              let sharedDate = userDefaults.object(forKey: "sharedContentDate") as? Date else {
-            // A partial or malformed handoff must not linger in the shared
-            // app-group container indefinitely.
-            clearSharedContent()
-            return
-        }
-
-        guard Date().timeIntervalSince(sharedDate) < TransportConfig.uiShareAcceptWindowSeconds else {
-            clearSharedContent()
-            return
-        }
-
-        let contentKind = SharedContentKind(rawValue: userDefaults.string(forKey: "sharedContentType") ?? "") ?? .text
-
-        clearSharedContent()
-
-        switch contentKind {
-        case .url:
-            if let data = sharedContent.data(using: .utf8),
-               let urlData = try? JSONSerialization.jsonObject(with: data) as? [String: String],
-               let url = urlData["url"] {
-                chatViewModel.sendMessage(url)
-            } else {
-                chatViewModel.sendMessage(sharedContent)
-            }
-        case .text:
-            chatViewModel.sendMessage(sharedContent)
-        }
-
-        record(.sharedContentAccepted(contentKind))
+    var currentSharedContentDestination: SharedContentDestination {
+        SharedContentDestination.resolve(
+            selectedPrivatePeerID: privateConversationModel.selectedPeerID,
+            privateDisplayName: privateConversationModel.selectedHeaderState?.displayName,
+            activeChannel: locationChannelsModel.selectedChannel
+        )
     }
 
     func handleNostrRelayConnectionChanged(_ isConnected: Bool) {

bitchat/App/ConversationStore.swift

@@ -39,15 +39,17 @@ final class Conversation: ObservableObject, Identifiable {
     @Published private(set) var messages: [BitchatMessage] = []
     @Published private(set) var isUnread: Bool = false
 
-    /// Incrementally-maintained message-ID → index map for O(1) dedup and
-    /// delivery-status lookup. Kept in sync on every mutation:
-    /// - tail append: single insert
-    /// - out-of-order insert: suffix reindex from the insertion point
-    /// - trim: full rebuild — `removeFirst(k)` is already O(n), so the
-    ///   rebuild does not change the asymptotics, and trim only happens once
-    ///   the cap (1337) is reached. Simple and correct beats the
-    ///   offset-tracking alternative here.
+    /// Incrementally-maintained message-ID → logical-index map for O(1)
+    /// dedup and delivery-status lookup. Logical indexes are physical array
+    /// indexes plus `indexOffset`; trimming from the head advances the offset
+    /// instead of rewriting every surviving dictionary entry. This matters
+    /// after the 1337-message cap is reached, when every steady-state tail
+    /// append evicts one old row.
+    ///
+    /// Out-of-order inserts and middle removals still reindex only the
+    /// affected suffix. Full filtering resets the offset while rebuilding.
     private var indexByMessageID: [String: Int] = [:]
+    private var indexOffset = 0
 
     fileprivate init(id: ConversationID, cap: Int) {
         self.id = id
@@ -61,7 +63,7 @@ final class Conversation: ObservableObject, Identifiable {
     }
 
     func message(withID messageID: String) -> BitchatMessage? {
-        guard let index = indexByMessageID[messageID] else { return nil }
+        guard let index = physicalIndex(forMessageID: messageID) else { return nil }
         return messages[index]
     }
 
@@ -101,7 +103,7 @@ final class Conversation: ObservableObject, Identifiable {
             reindex(from: index)
         } else {
             messages.append(message)
-            indexByMessageID[message.id] = messages.count - 1
+            indexByMessageID[message.id] = indexOffset + messages.count - 1
         }
 
         return InsertResult(inserted: true, trimmedMessageIDs: trimIfNeeded())
@@ -111,7 +113,7 @@ final class Conversation: ObservableObject, Identifiable {
     /// timeline position (in-place updates like media progress reuse the
     /// original timestamp); a new message goes through ordered insertion.
     fileprivate func upsert(_ message: BitchatMessage) -> UpsertOutcome {
-        if let index = indexByMessageID[message.id] {
+        if let index = physicalIndex(forMessageID: message.id) {
             messages[index] = message
             return .updated
         }
@@ -125,7 +127,7 @@ final class Conversation: ObservableObject, Identifiable {
     /// `.read` is never downgraded to `.delivered` or `.sent`.
     /// Returns `true` when the status was applied.
     fileprivate func applyDeliveryStatus(_ status: DeliveryStatus, forMessageID messageID: String) -> Bool {
-        guard let index = indexByMessageID[messageID] else { return false }
+        guard let index = physicalIndex(forMessageID: messageID) else { return false }
         let message = messages[index]
         guard !Self.shouldSkipStatusUpdate(current: message.deliveryStatus, new: status) else { return false }
 
@@ -142,7 +144,7 @@ final class Conversation: ObservableObject, Identifiable {
     /// observers still need an @Published emission to re-render.
     @discardableResult
     fileprivate func republishMessage(withID messageID: String) -> Bool {
-        guard let index = indexByMessageID[messageID] else { return false }
+        guard let index = physicalIndex(forMessageID: messageID) else { return false }
         messages[index] = messages[index]
         return true
     }
@@ -157,10 +159,14 @@ final class Conversation: ObservableObject, Identifiable {
     /// Removes a single message by ID. Returns the removed message, or
     /// `nil` when no message with that ID exists.
     fileprivate func remove(messageID: String) -> BitchatMessage? {
-        guard let index = indexByMessageID[messageID] else { return nil }
+        guard let index = physicalIndex(forMessageID: messageID) else { return nil }
         let removed = messages.remove(at: index)
         indexByMessageID.removeValue(forKey: messageID)
-        reindex(from: index)
+        if index == 0 {
+            indexOffset += 1
+        } else {
+            reindex(from: index)
+        }
         return removed
     }
 
@@ -177,6 +183,7 @@ final class Conversation: ObservableObject, Identifiable {
         for id in removedIDs {
             indexByMessageID.removeValue(forKey: id)
         }
+        indexOffset = 0
         reindex(from: 0)
         return removedIDs
     }
@@ -184,6 +191,7 @@ final class Conversation: ObservableObject, Identifiable {
     fileprivate func clearMessages() {
         messages.removeAll()
         indexByMessageID.removeAll()
+        indexOffset = 0
     }
 
     // MARK: Diagnostics
@@ -205,9 +213,10 @@ final class Conversation: ObservableObject, Identifiable {
             let message = messages[position]
             // Count equality + every message resolving to its own position
             // proves the index is exactly the inverse map (no stale extras).
-            if let index = indexByMessageID[message.id] {
-                if index != position {
-                    violations.append("\(label): message \(message.id.prefix(8))… at \(position) indexed at \(index)")
+            if let logicalIndex = indexByMessageID[message.id] {
+                let expectedIndex = indexOffset + position
+                if logicalIndex != expectedIndex {
+                    violations.append("\(label): message \(message.id.prefix(8))… at \(position) indexed at \(logicalIndex - indexOffset)")
                 }
             } else {
                 violations.append("\(label): message \(message.id.prefix(8))… at \(position) missing from index")
@@ -269,10 +278,17 @@ final class Conversation: ObservableObject, Identifiable {
 
     private func reindex(from start: Int) {
         for index in start..<messages.count {
-            indexByMessageID[messages[index].id] = index
+            indexByMessageID[messages[index].id] = indexOffset + index
         }
     }
 
+    private func physicalIndex(forMessageID messageID: String) -> Int? {
+        guard let logicalIndex = indexByMessageID[messageID] else { return nil }
+        let index = logicalIndex - indexOffset
+        guard messages.indices.contains(index) else { return nil }
+        return index
+    }
+
     /// Trims oldest messages over the cap; returns the trimmed message IDs.
     private func trimIfNeeded() -> [String] {
         guard messages.count > cap else { return [] }
@@ -282,7 +298,7 @@ final class Conversation: ObservableObject, Identifiable {
             indexByMessageID.removeValue(forKey: id)
         }
         messages.removeFirst(overflow)
-        reindex(from: 0)
+        indexOffset += overflow
         return trimmedIDs
     }
 }
@@ -844,8 +860,8 @@ extension Conversation {
     /// (positions 0 and 1 swap their index entries). Requires >= 2 messages.
     func _testCorruptIndexEntries() {
         guard messages.count >= 2 else { return }
-        indexByMessageID[messages[0].id] = 1
-        indexByMessageID[messages[1].id] = 0
+        indexByMessageID[messages[0].id] = indexOffset + 1
+        indexByMessageID[messages[1].id] = indexOffset
     }
 
     /// Drops a message's index entry entirely (count mismatch + missing).
@@ -859,8 +875,8 @@ extension Conversation {
     func _testCorruptOrderingPreservingIndex() {
         guard messages.count >= 2 else { return }
         messages.swapAt(0, messages.count - 1)
-        indexByMessageID[messages[0].id] = 0
-        indexByMessageID[messages[messages.count - 1].id] = messages.count - 1
+        indexByMessageID[messages[0].id] = indexOffset
+        indexByMessageID[messages[messages.count - 1].id] = indexOffset + messages.count - 1
     }
 }
 
@@ -900,7 +916,7 @@ extension ConversationStore {
 extension Conversation {
     fileprivate func _testAppendBypassingTrim(_ message: BitchatMessage) {
         messages.append(message)
-        indexByMessageID[message.id] = messages.count - 1
+        indexByMessageID[message.id] = indexOffset + messages.count - 1
     }
 }
 #endif

bitchat/App/ConversationUIModel.swift

@@ -12,7 +12,6 @@ final class ConversationUIModel: ObservableObject {
     @Published private(set) var currentNickname: String
     @Published private(set) var isBatchingPublic = false
     @Published private(set) var canSendMediaInCurrentContext = true
-    @Published private(set) var legacyPrivateMediaConsentRequest: LegacyPrivateMediaConsentRequest?
     /// Who is talking live in the public mesh channel right now (floor
     /// courtesy: the composer mic tints "busy" while someone holds the floor).
     @Published private(set) var activeLiveVoiceTalker: String?
@@ -154,13 +153,6 @@ final class ConversationUIModel: ObservableObject {
         chatViewModel.sendVoiceNote(at: url)
     }
 
-    func resolveLegacyPrivateMediaConsent(requestID: UUID, approved: Bool) {
-        chatViewModel.resolveLegacyPrivateMediaConsent(
-            requestID: requestID,
-            approved: approved
-        )
-    }
-
     /// Capture backend for the mic gesture: live PTT when the current DM
     /// peer can hear it now, classic voice note otherwise.
     func makeVoiceCaptureSession() -> VoiceCaptureSession {
@@ -201,10 +193,6 @@ final class ConversationUIModel: ObservableObject {
             .receive(on: DispatchQueue.main)
             .assign(to: &$activeLiveVoiceTalker)
 
-        chatViewModel.$legacyPrivateMediaConsentRequest
-            .receive(on: DispatchQueue.main)
-            .assign(to: &$legacyPrivateMediaConsentRequest)
-
         conversations.$activeChannel
             .receive(on: DispatchQueue.main)
             .sink { [weak self] channel in

bitchat/App/SharedContentImportModel.swift

@@ -0,0 +1,119 @@
+import BitFoundation
+import Combine
+import Foundation
+
+enum SharedContentDestination: Sendable, Equatable {
+    case mesh
+    case geohash(String)
+    case privateConversation(peerID: PeerID, displayName: String)
+
+    static func resolve(
+        selectedPrivatePeerID: PeerID?,
+        privateDisplayName: String?,
+        activeChannel: ChannelID
+    ) -> SharedContentDestination {
+        if let selectedPrivatePeerID {
+            let fallback = String(selectedPrivatePeerID.id.prefix(12))
+            return .privateConversation(
+                peerID: selectedPrivatePeerID,
+                displayName: privateDisplayName?.trimmedOrNilIfEmpty ?? fallback
+            )
+        }
+
+        switch activeChannel {
+        case .mesh:
+            return .mesh
+        case .location(let channel):
+            return .geohash(channel.geohash.lowercased())
+        }
+    }
+
+    var displayName: String {
+        switch self {
+        case .mesh:
+            return "#mesh"
+        case .geohash(let geohash):
+            return "#\(geohash)"
+        case .privateConversation(_, let displayName):
+            return displayName
+        }
+    }
+}
+
+struct SharedContentOffer: Identifiable, Sendable, Equatable {
+    let payload: SharedContentPayload
+    let destination: SharedContentDestination
+
+    var id: UUID { payload.id }
+}
+
+/// Holds a pending extension handoff until the user chooses a destination and
+/// explicitly adds it to the composer. This type has no send dependency by
+/// design: confirming an import can never transmit a message.
+@MainActor
+final class SharedContentImportModel: ObservableObject {
+    @Published private(set) var offer: SharedContentOffer?
+
+    private let store: SharedContentStore?
+
+    init(store: SharedContentStore?) {
+        self.store = store
+    }
+
+    @discardableResult
+    func refresh(
+        destination: SharedContentDestination,
+        now: Date = Date()
+    ) -> SharedContentPayload? {
+        guard let payload = store?.pending(now: now) else {
+            offer = nil
+            return nil
+        }
+
+        let nextOffer = SharedContentOffer(payload: payload, destination: destination)
+        if offer != nextOffer {
+            offer = nextOffer
+        }
+        return payload
+    }
+
+    func updateDestination(_ destination: SharedContentDestination) {
+        guard let offer, offer.destination != destination else { return }
+        self.offer = SharedContentOffer(payload: offer.payload, destination: destination)
+    }
+
+    /// Returns composer text only when the currently displayed destination is
+    /// still current and the reviewed envelope is still the stored envelope.
+    /// A destination change updates the prompt and requires another tap.
+    func confirm(
+        destination: SharedContentDestination,
+        now: Date = Date()
+    ) -> String? {
+        guard let offer else { return nil }
+        guard offer.destination == destination else {
+            updateDestination(destination)
+            return nil
+        }
+        guard let payload = store?.consume(id: offer.id, now: now) else {
+            _ = refresh(destination: destination, now: now)
+            return nil
+        }
+
+        self.offer = nil
+        return payload.composerText
+    }
+
+    func cancel(destination: SharedContentDestination, now: Date = Date()) {
+        guard let offer else { return }
+        store?.discard(id: offer.id)
+        self.offer = nil
+        // If a newer share replaced the reviewed envelope, surface it rather
+        // than losing it with the older cancellation.
+        _ = refresh(destination: destination, now: now)
+    }
+
+    func discardAll() {
+        store?.discardAll()
+        offer = nil
+    }
+}

bitchat/BitchatApp.swift

@@ -41,6 +41,7 @@ struct BitchatApp: App {
                 .environmentObject(runtime.peerListModel)
                 .environmentObject(runtime.appChromeModel)
                 .environmentObject(runtime.boardAlertsModel)
+                .environmentObject(runtime.sharedContentImportModel)
                 .onAppear {
                     appDelegate.runtime = runtime
                     runtime.start()

bitchat/Identity/IdentityModels.swift

@@ -189,18 +189,6 @@ struct IdentityCache: Codable {
     // Fingerprint -> when we verified it (orders outgoing vouch batches;
     // entries verified before this field exists sort as oldest)
     var verifiedAt: [String: Date]? = nil
-
-    // Stable Noise fingerprints that proved encrypted private-media support
-    // inside an authenticated Noise session. Optional for decoding caches
-    // written before this migration. Entries are monotonic until a panic wipe
-    // so an old/replayed announce cannot silently downgrade a peer.
-    var privateMediaCapableFingerprints: Set<String>? = nil
-
-    // Noise-fingerprint -> Ed25519 announcement key, learned only from the
-    // authenticated peer-state payload. This prevents a self-signed announce
-    // containing a copied public Noise key from replacing a previously bound
-    // public-message signing identity. Optional for old cache compatibility.
-    var authenticatedSigningKeysByFingerprint: [String: Data]? = nil
 }
 
 //

bitchat/Identity/SecureIdentityStateManager.swift

@@ -140,14 +140,6 @@ protocol SecureIdentityStateManagerProtocol {
     func markVouchBatchSent(to fingerprint: String, at date: Date)
     func signingPublicKey(forFingerprint fingerprint: String) -> Data?
     func mostRecentlyVerifiedFingerprints(limit: Int, excluding fingerprint: String) -> [String]
-
-    // MARK: Noise-authenticated announcement identity
-    func bindAuthenticatedSigningPublicKey(_ signingPublicKey: Data, fingerprint: String)
-    func authenticatedSigningPublicKey(forFingerprint fingerprint: String) -> Data?
-
-    // MARK: Private-media downgrade protection
-    func markPrivateMediaCapable(fingerprint: String)
-    func hasObservedPrivateMediaCapability(fingerprint: String) -> Bool
 }
 
 /// Singleton manager for secure identity state persistence and retrieval.
@@ -165,7 +157,6 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
     
     // Thread safety
     private let queue = DispatchQueue(label: "bitchat.identity.state", attributes: .concurrent)
-    private let queueSpecificKey = DispatchSpecificKey<UInt8>()
     
     // Pending-save coalescing flag. Reads/writes are serialized on `queue`.
     // Persistence is done with a fire-and-forget `queue.async(.barrier)` rather
@@ -223,7 +214,6 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
 
         self.encryptionKey = loadedKey
         self.encryptionKeyIsEphemeral = keyIsEphemeral
-        queue.setSpecific(key: queueSpecificKey, value: 1)
 
         // Only read the persisted cache when we hold the real key; with an
         // ephemeral key the decrypt would fail and discard the real cache.
@@ -381,66 +371,6 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
         }
     }
     
-    // MARK: - Private-media downgrade protection
-
-    func markPrivateMediaCapable(fingerprint: String) {
-        guard !fingerprint.isEmpty else { return }
-        let insertAndPersist = {
-            var pinned = self.cache.privateMediaCapableFingerprints ?? []
-            guard pinned.insert(fingerprint).inserted else { return }
-            self.cache.privateMediaCapableFingerprints = pinned
-            self.saveIdentityCache()
-        }
-        // Downgrade decisions can run immediately after an authenticated
-        // announce. Make the pin visible before returning; merely enqueueing a
-        // barrier leaves a cross-queue window where a replay can look legacy.
-        // The queue-specific fast path prevents self-deadlock if a future
-        // identity-state mutation records the capability from inside `queue`.
-        if DispatchQueue.getSpecific(key: queueSpecificKey) != nil {
-            insertAndPersist()
-        } else {
-            queue.sync(flags: .barrier, execute: insertAndPersist)
-        }
-    }
-
-    func hasObservedPrivateMediaCapability(fingerprint: String) -> Bool {
-        guard !fingerprint.isEmpty else { return false }
-        return queue.sync {
-            cache.privateMediaCapableFingerprints?.contains(fingerprint) == true
-        }
-    }
-
-    // MARK: - Noise-authenticated announcement identity
-
-    func bindAuthenticatedSigningPublicKey(_ signingPublicKey: Data, fingerprint: String) {
-        guard signingPublicKey.count == AuthenticatedPeerStatePacket.signingPublicKeyLength,
-              !fingerprint.isEmpty else { return }
-        let bindAndPersist = {
-            var bindings = self.cache.authenticatedSigningKeysByFingerprint ?? [:]
-            let bindingChanged = bindings[fingerprint] != signingPublicKey
-            bindings[fingerprint] = signingPublicKey
-            self.cache.authenticatedSigningKeysByFingerprint = bindings
-            if var cryptoIdentity = self.cryptographicIdentities[fingerprint] {
-                cryptoIdentity.signingPublicKey = signingPublicKey
-                self.cryptographicIdentities[fingerprint] = cryptoIdentity
-            }
-            guard bindingChanged else { return }
-            self.saveIdentityCache()
-        }
-        if DispatchQueue.getSpecific(key: queueSpecificKey) != nil {
-            bindAndPersist()
-        } else {
-            queue.sync(flags: .barrier, execute: bindAndPersist)
-        }
-    }
-
-    func authenticatedSigningPublicKey(forFingerprint fingerprint: String) -> Data? {
-        guard !fingerprint.isEmpty else { return nil }
-        return queue.sync {
-            cache.authenticatedSigningKeysByFingerprint?[fingerprint]
-        }
-    }
-    
     func updateSocialIdentity(_ identity: SocialIdentity) {
         queue.async(flags: .barrier) {
             let previousClaimedNickname = self.cache.socialIdentities[identity.fingerprint]?.claimedNickname

bitchat/Localizable.xcstrings

@@ -72662,6 +72662,114 @@
           }
         }
       }
+    },
+    "share_import.review.message" : {
+      "comment" : "Explains that shared content replaces the named destination's composer and is not sent automatically",
+      "extractionState" : "manual",
+      "localizations" : {
+        "ar" : { "stringUnit" : { "state" : "needs_review", "value" : "هل تريد استبدال مسودة %@ بهذا المحتوى؟ لن يتم إرسال أي شيء تلقائيًا." } },
+        "bn" : { "stringUnit" : { "state" : "needs_review", "value" : "%@-এর খসড়াটি এই কনটেন্ট দিয়ে বদলাবেন? কিছুই স্বয়ংক্রিয়ভাবে পাঠানো হবে না।" } },
+        "de" : { "stringUnit" : { "state" : "needs_review", "value" : "Entwurf für %@ durch diesen Inhalt ersetzen? Es wird nichts automatisch gesendet." } },
+        "en" : { "stringUnit" : { "state" : "translated", "value" : "Replace the draft for %@ with this content? Nothing will be sent automatically." } },
+        "es" : { "stringUnit" : { "state" : "needs_review", "value" : "¿Reemplazar el borrador de %@ con este contenido? No se enviará nada automáticamente." } },
+        "fa" : { "stringUnit" : { "state" : "needs_review", "value" : "پیش‌نویس %@ با این محتوا جایگزین شود؟ چیزی به‌طور خودکار ارسال نمی‌شود." } },
+        "fil" : { "stringUnit" : { "state" : "needs_review", "value" : "Palitan ng content na ito ang draft para sa %@? Walang awtomatikong ipapadala." } },
+        "fr" : { "stringUnit" : { "state" : "needs_review", "value" : "Remplacer le brouillon pour %@ par ce contenu ? Rien ne sera envoyé automatiquement." } },
+        "he" : { "stringUnit" : { "state" : "needs_review", "value" : "להחליף את הטיוטה עבור %@ בתוכן הזה? שום דבר לא יישלח אוטומטית." } },
+        "hi" : { "stringUnit" : { "state" : "needs_review", "value" : "%@ का ड्राफ़्ट इस सामग्री से बदलें? कुछ भी अपने आप नहीं भेजा जाएगा।" } },
+        "id" : { "stringUnit" : { "state" : "needs_review", "value" : "Ganti draf untuk %@ dengan konten ini? Tidak ada yang akan dikirim otomatis." } },
+        "it" : { "stringUnit" : { "state" : "needs_review", "value" : "Sostituire la bozza per %@ con questo contenuto? Nulla verrà inviato automaticamente." } },
+        "ja" : { "stringUnit" : { "state" : "needs_review", "value" : "%@ の下書きをこの内容で置き換えますか？自動的には送信されません。" } },
+        "ko" : { "stringUnit" : { "state" : "needs_review", "value" : "%@의 초안을 이 콘텐츠로 바꾸시겠습니까? 자동으로 전송되지 않습니다." } },
+        "ms" : { "stringUnit" : { "state" : "needs_review", "value" : "Gantikan draf untuk %@ dengan kandungan ini? Tiada apa-apa akan dihantar secara automatik." } },
+        "ne" : { "stringUnit" : { "state" : "needs_review", "value" : "%@ को मस्यौदा यो सामग्रीले बदल्ने? केही पनि स्वचालित रूपमा पठाइने छैन।" } },
+        "nl" : { "stringUnit" : { "state" : "needs_review", "value" : "Concept voor %@ vervangen door deze inhoud? Er wordt niets automatisch verzonden." } },
+        "pl" : { "stringUnit" : { "state" : "needs_review", "value" : "Zastąpić szkic dla %@ tą treścią? Nic nie zostanie wysłane automatycznie." } },
+        "pt" : { "stringUnit" : { "state" : "needs_review", "value" : "Substituir o rascunho para %@ por este conteúdo? Nada será enviado automaticamente." } },
+        "pt-BR" : { "stringUnit" : { "state" : "needs_review", "value" : "Substituir o rascunho de %@ por este conteúdo? Nada será enviado automaticamente." } },
+        "ru" : { "stringUnit" : { "state" : "needs_review", "value" : "Заменить черновик для %@ этим содержимым? Ничего не будет отправлено автоматически." } },
+        "sv" : { "stringUnit" : { "state" : "needs_review", "value" : "Ersätta utkastet för %@ med detta innehåll? Inget skickas automatiskt." } },
+        "ta" : { "stringUnit" : { "state" : "needs_review", "value" : "%@ க்கான வரைவைக் இந்த உள்ளடக்கத்தால் மாற்றவா? எதுவும் தானாக அனுப்பப்படாது." } },
+        "th" : { "stringUnit" : { "state" : "needs_review", "value" : "แทนที่ฉบับร่างสำหรับ %@ ด้วยเนื้อหานี้หรือไม่? จะไม่มีการส่งอัตโนมัติ" } },
+        "tr" : { "stringUnit" : { "state" : "needs_review", "value" : "%@ taslağı bu içerikle değiştirilsin mi? Hiçbir şey otomatik olarak gönderilmez." } },
+        "uk" : { "stringUnit" : { "state" : "needs_review", "value" : "Замінити чернетку для %@ цим вмістом? Нічого не буде надіслано автоматично." } },
+        "ur" : { "stringUnit" : { "state" : "needs_review", "value" : "%@ کا مسودہ اس مواد سے بدلیں؟ کچھ بھی خودکار طور پر نہیں بھیجا جائے گا۔" } },
+        "vi" : { "stringUnit" : { "state" : "needs_review", "value" : "Thay bản nháp cho %@ bằng nội dung này? Không có gì được tự động gửi." } },
+        "zh-Hans" : { "stringUnit" : { "state" : "needs_review", "value" : "要用此内容替换 %@ 的草稿吗？内容不会自动发送。" } },
+        "zh-Hant" : { "stringUnit" : { "state" : "needs_review", "value" : "要用此內容取代 %@ 的草稿嗎？內容不會自動傳送。" } }
+      }
+    },
+    "share_import.review.title" : {
+      "comment" : "Title for reviewing content received from the share extension",
+      "extractionState" : "manual",
+      "localizations" : {
+        "ar" : { "stringUnit" : { "state" : "needs_review", "value" : "مراجعة المحتوى المشترك" } },
+        "bn" : { "stringUnit" : { "state" : "needs_review", "value" : "শেয়ার করা কনটেন্ট পর্যালোচনা করুন" } },
+        "de" : { "stringUnit" : { "state" : "needs_review", "value" : "Geteilte Inhalte prüfen" } },
+        "en" : { "stringUnit" : { "state" : "translated", "value" : "Review shared content" } },
+        "es" : { "stringUnit" : { "state" : "needs_review", "value" : "Revisar contenido compartido" } },
+        "fa" : { "stringUnit" : { "state" : "needs_review", "value" : "بازبینی محتوای هم‌رسانی‌شده" } },
+        "fil" : { "stringUnit" : { "state" : "needs_review", "value" : "Suriin ang ibinahaging content" } },
+        "fr" : { "stringUnit" : { "state" : "needs_review", "value" : "Vérifier le contenu partagé" } },
+        "he" : { "stringUnit" : { "state" : "needs_review", "value" : "בדיקת תוכן משותף" } },
+        "hi" : { "stringUnit" : { "state" : "needs_review", "value" : "शेयर की गई सामग्री की समीक्षा करें" } },
+        "id" : { "stringUnit" : { "state" : "needs_review", "value" : "Tinjau konten yang dibagikan" } },
+        "it" : { "stringUnit" : { "state" : "needs_review", "value" : "Controlla il contenuto condiviso" } },
+        "ja" : { "stringUnit" : { "state" : "needs_review", "value" : "共有コンテンツを確認" } },
+        "ko" : { "stringUnit" : { "state" : "needs_review", "value" : "공유 콘텐츠 검토" } },
+        "ms" : { "stringUnit" : { "state" : "needs_review", "value" : "Semak kandungan yang dikongsi" } },
+        "ne" : { "stringUnit" : { "state" : "needs_review", "value" : "साझा सामग्री समीक्षा गर्नुहोस्" } },
+        "nl" : { "stringUnit" : { "state" : "needs_review", "value" : "Gedeelde inhoud bekijken" } },
+        "pl" : { "stringUnit" : { "state" : "needs_review", "value" : "Sprawdź udostępnioną treść" } },
+        "pt" : { "stringUnit" : { "state" : "needs_review", "value" : "Rever conteúdo partilhado" } },
+        "pt-BR" : { "stringUnit" : { "state" : "needs_review", "value" : "Revisar conteúdo compartilhado" } },
+        "ru" : { "stringUnit" : { "state" : "needs_review", "value" : "Проверить общий контент" } },
+        "sv" : { "stringUnit" : { "state" : "needs_review", "value" : "Granska delat innehåll" } },
+        "ta" : { "stringUnit" : { "state" : "needs_review", "value" : "பகிரப்பட்ட உள்ளடக்கத்தை மதிப்பாய்வு செய்" } },
+        "th" : { "stringUnit" : { "state" : "needs_review", "value" : "ตรวจสอบเนื้อหาที่แชร์" } },
+        "tr" : { "stringUnit" : { "state" : "needs_review", "value" : "Paylaşılan içeriği gözden geçir" } },
+        "uk" : { "stringUnit" : { "state" : "needs_review", "value" : "Переглянути спільний вміст" } },
+        "ur" : { "stringUnit" : { "state" : "needs_review", "value" : "شیئر کردہ مواد کا جائزہ لیں" } },
+        "vi" : { "stringUnit" : { "state" : "needs_review", "value" : "Xem lại nội dung được chia sẻ" } },
+        "zh-Hans" : { "stringUnit" : { "state" : "needs_review", "value" : "查看共享内容" } },
+        "zh-Hant" : { "stringUnit" : { "state" : "needs_review", "value" : "查看分享內容" } }
+      }
+    },
+    "share_import.review.use_in_composer" : {
+      "comment" : "Action that places reviewed shared content in the composer without sending it",
+      "extractionState" : "manual",
+      "localizations" : {
+        "ar" : { "stringUnit" : { "state" : "needs_review", "value" : "استخدام في مسودة الرسالة" } },
+        "bn" : { "stringUnit" : { "state" : "needs_review", "value" : "বার্তার খসড়ায় ব্যবহার করুন" } },
+        "de" : { "stringUnit" : { "state" : "needs_review", "value" : "Im Nachrichtenentwurf verwenden" } },
+        "en" : { "stringUnit" : { "state" : "translated", "value" : "Use in composer" } },
+        "es" : { "stringUnit" : { "state" : "needs_review", "value" : "Usar en el borrador" } },
+        "fa" : { "stringUnit" : { "state" : "needs_review", "value" : "استفاده در پیش‌نویس پیام" } },
+        "fil" : { "stringUnit" : { "state" : "needs_review", "value" : "Gamitin sa draft" } },
+        "fr" : { "stringUnit" : { "state" : "needs_review", "value" : "Utiliser dans le brouillon" } },
+        "he" : { "stringUnit" : { "state" : "needs_review", "value" : "שימוש בטיוטה" } },
+        "hi" : { "stringUnit" : { "state" : "needs_review", "value" : "संदेश के ड्राफ़्ट में उपयोग करें" } },
+        "id" : { "stringUnit" : { "state" : "needs_review", "value" : "Gunakan di draf" } },
+        "it" : { "stringUnit" : { "state" : "needs_review", "value" : "Usa nella bozza" } },
+        "ja" : { "stringUnit" : { "state" : "needs_review", "value" : "下書きで使用" } },
+        "ko" : { "stringUnit" : { "state" : "needs_review", "value" : "초안에 사용" } },
+        "ms" : { "stringUnit" : { "state" : "needs_review", "value" : "Gunakan dalam draf" } },
+        "ne" : { "stringUnit" : { "state" : "needs_review", "value" : "सन्देशको मस्यौदामा प्रयोग गर्नुहोस्" } },
+        "nl" : { "stringUnit" : { "state" : "needs_review", "value" : "In concept gebruiken" } },
+        "pl" : { "stringUnit" : { "state" : "needs_review", "value" : "Użyj w szkicu" } },
+        "pt" : { "stringUnit" : { "state" : "needs_review", "value" : "Usar no rascunho" } },
+        "pt-BR" : { "stringUnit" : { "state" : "needs_review", "value" : "Usar no rascunho" } },
+        "ru" : { "stringUnit" : { "state" : "needs_review", "value" : "Использовать в черновике" } },
+        "sv" : { "stringUnit" : { "state" : "needs_review", "value" : "Använd i utkast" } },
+        "ta" : { "stringUnit" : { "state" : "needs_review", "value" : "செய்தி வரைவில் பயன்படுத்து" } },
+        "th" : { "stringUnit" : { "state" : "needs_review", "value" : "ใช้ในฉบับร่าง" } },
+        "tr" : { "stringUnit" : { "state" : "needs_review", "value" : "Taslakta kullan" } },
+        "uk" : { "stringUnit" : { "state" : "needs_review", "value" : "Використати в чернетці" } },
+        "ur" : { "stringUnit" : { "state" : "needs_review", "value" : "پیغام کے مسودے میں استعمال کریں" } },
+        "vi" : { "stringUnit" : { "state" : "needs_review", "value" : "Dùng trong bản nháp" } },
+        "zh-Hans" : { "stringUnit" : { "state" : "needs_review", "value" : "用于草稿" } },
+        "zh-Hant" : { "stringUnit" : { "state" : "needs_review", "value" : "用於草稿" } }
+      }
     }
   },
   "version" : "1.1"

bitchat/Models/NoisePayload.swift

@@ -30,7 +30,7 @@ struct NoisePayload {
         
         // Safely get the first byte
         let firstByte = data[data.startIndex]
-        guard let type = NoisePayloadType.decoded(rawValue: firstByte) else {
+        guard let type = NoisePayloadType(rawValue: firstByte) else {
             return nil
         }
         

bitchat/Noise/NoiseSecurityConstants.swift

@@ -6,61 +6,18 @@
 // For more information, see <https://unlicense.org>
 //
 
-import BitFoundation
 import Foundation
 
 enum NoiseSecurityConstants {
     // Maximum message size to prevent memory exhaustion
     static let maxMessageSize = 65535 // 64KB as per Noise spec
     
-    /// The extracted transport nonce (4 bytes) and Poly1305 tag (16 bytes)
-    /// added by `NoiseCipherState` around every transport plaintext.
-    static let transportCiphertextOverhead = 20
-
-    /// Private files are an explicit BitChat extension to the ordinary Noise
-    /// message-size ceiling. They remain bounded by the same framed-file cap
-    /// used by the binary and fragment decoders. Only the `.privateFile`
-    /// typed-payload path is allowed to use this larger budget.
-    private static let privateFileOuterPacketOverhead =
-        (BinaryProtocol.v1HeaderSize + 2) // v2 adds two length bytes
-        + BinaryProtocol.senderIDSize
-        + BinaryProtocol.recipientIDSize
-    static let maxPrivateFilePlaintextSize = FileTransferLimits.maxFramedFileBytes
-        - privateFileOuterPacketOverhead
-        - transportCiphertextOverhead
-    static let maxPrivateFileCiphertextSize =
-        maxPrivateFilePlaintextSize + transportCiphertextOverhead
-    
     // Maximum handshake message size
     static let maxHandshakeMessageSize = 2048 // 2KB to accommodate XX pattern
 
     // Noise XX message 1 contains only the initiator's 32-byte ephemeral key.
     static let xxInitialMessageSize = 32
     
-    // Bounds an ordinary initiator whose message 1 or 2 is lost.
-    static let ordinaryHandshakeTimeout: TimeInterval = 10
-
-    // Bounds the receive-only rollback quarantine created by an unauthenticated
-    // inbound message 1. A lost message 3 must not strand outbound traffic.
-    static let ordinaryResponderHandshakeTimeout: TimeInterval = 20
-
-    // A released client may immediately retry after both crossed initiators
-    // yielded. Give that unilateral retry a brief head start before the
-    // patched side spends its one bounded recovery.
-    static let handshakeCollisionRecoveryDelay: TimeInterval = 0.2
-
-    // Rate-limited recovery remains actionable without spinning.
-    static let handshakeRateLimitRecoveryDelay: TimeInterval = 60
-
-    // Covers only reordering between a winning message 3 and the losing
-    // crossed message 1.
-    static let recentInitiatorCompletionGracePeriod: TimeInterval = 1
-
-    // After unauthenticated responder rollback, reject another attempt long
-    // enough that paced message 1 traffic cannot keep outbound paused. A
-    // legitimate peer converges through the one manager-owned local retry.
-    static let ordinaryReconnectRollbackCooldown: TimeInterval = 60
-    
     // Session timeout - sessions older than this should be renegotiated
     static let sessionTimeout: TimeInterval = 86400 // 24 hours
     

bitchat/Noise/NoiseSecurityValidator.swift

@@ -15,19 +15,6 @@ struct NoiseSecurityValidator {
         return data.count <= NoiseSecurityConstants.maxMessageSize
     }
     
-    static func validateCiphertextSize(_ data: Data) -> Bool {
-        data.count <= NoiseSecurityConstants.maxMessageSize
-            + NoiseSecurityConstants.transportCiphertextOverhead
-    }
-
-    static func validatePrivateFileMessageSize(_ data: Data) -> Bool {
-        data.count <= NoiseSecurityConstants.maxPrivateFilePlaintextSize
-    }
-
-    static func validatePrivateFileCiphertextSize(_ data: Data) -> Bool {
-        data.count <= NoiseSecurityConstants.maxPrivateFileCiphertextSize
-    }
-    
     /// Validate handshake message size
     static func validateHandshakeMessageSize(_ data: Data) -> Bool {
         return data.count <= NoiseSecurityConstants.maxHandshakeMessageSize

bitchat/Noise/NoiseSessionError.swift

@@ -13,9 +13,3 @@ enum NoiseSessionError: Error, Equatable {
     case alreadyEstablished
     case peerIdentityMismatch
 }
-
-/// The manager owns the exact attempt's one bounded recovery. Packet handling
-/// must not launch its historical second, immediate restart for this failure.
-struct NoiseManagedHandshakeFailure: Error {
-    let underlying: Error
-}

bitchat/Noise/SecureNoiseSession.swift

@@ -24,12 +24,8 @@ final class SecureNoiseSession: NoiseSession {
             throw NoiseSecurityError.sessionExhausted
         }
         
-        // Ordinary Noise messages keep the protocol ceiling. Finalized media
-        // is the sole typed-payload extension and remains under the framed-file
-        // cap enforced again at the service and file-decoder layers.
-        let isPrivateFile = NoisePayloadType.isPrivateFile(rawValue: plaintext.first)
-            && NoiseSecurityValidator.validatePrivateFileMessageSize(plaintext)
-        guard NoiseSecurityValidator.validateMessageSize(plaintext) || isPrivateFile else {
+        // Validate message size
+        guard NoiseSecurityValidator.validateMessageSize(plaintext) else {
             throw NoiseSecurityError.messageTooLarge
         }
         
@@ -46,11 +42,8 @@ final class SecureNoiseSession: NoiseSession {
             throw NoiseSecurityError.sessionExpired
         }
         
-        // The payload type is encrypted, so a large candidate can only be
-        // bounded here; `NoiseEncryptionService.decrypt` authenticates it and
-        // then requires the resulting type to be `.privateFile`.
-        guard NoiseSecurityValidator.validateCiphertextSize(ciphertext)
-                || NoiseSecurityValidator.validatePrivateFileCiphertextSize(ciphertext) else {
+        // Validate message size
+        guard NoiseSecurityValidator.validateMessageSize(ciphertext) else {
             throw NoiseSecurityError.messageTooLarge
         }
         

bitchat/Nostr/GeoRelayDirectory.swift

@@ -32,6 +32,23 @@ struct GeoRelayDirectoryDependencies {
     var retrySleep: (TimeInterval) async -> Void
     var activeNotificationName: Notification.Name?
     var autoStart: Bool
+    var validationPolicy: GeoRelayDirectoryValidationPolicy
+}
+
+struct GeoRelayDirectoryValidationPolicy: Sendable {
+    let maximumBytes: Int
+    let maximumRows: Int
+    let maximumEntries: Int
+    let minimumRemoteEntries: Int
+    let minimumRetainedFraction: Double
+
+    static let live = GeoRelayDirectoryValidationPolicy(
+        maximumBytes: 512 * 1024,
+        maximumRows: 5_000,
+        maximumEntries: 5_000,
+        minimumRemoteEntries: 50,
+        minimumRetainedFraction: 0.5
+    )
 }
 
 private extension GeoRelayDirectoryDependencies {
@@ -44,12 +61,16 @@ private extension GeoRelayDirectoryDependencies {
 #else
         let activeNotificationName: Notification.Name? = nil
 #endif
+        let validationPolicy = GeoRelayDirectoryValidationPolicy.live
 
         return Self(
             userDefaults: .standard,
             notificationCenter: .default,
             now: Date.init,
-            remoteURL: URL(string: "https://raw.githubusercontent.com/permissionlesstech/georelays/refs/heads/main/nostr_relays.csv")!,
+            // Runtime refreshes only from bitchat's reviewed copy. Upstream
+            // georelays/main is imported by a validator-backed pull request,
+            // so an upstream mutation cannot immediately retarget clients.
+            remoteURL: URL(string: "https://raw.githubusercontent.com/permissionlesstech/bitchat/refs/heads/main/relays/online_relays_gps.csv")!,
             fetchInterval: TransportConfig.geoRelayFetchIntervalSeconds,
             refreshCheckInterval: TransportConfig.geoRelayRefreshCheckIntervalSeconds,
             retryInitialSeconds: TransportConfig.geoRelayRetryInitialSeconds,
@@ -58,7 +79,27 @@ private extension GeoRelayDirectoryDependencies {
             makeFetchData: {
                 let session = TorURLSession.shared.session
                 return { request in
-                    let (data, _) = try await session.data(for: request)
+                    let (bytes, response) = try await session.bytes(for: request)
+                    guard let response = response as? HTTPURLResponse,
+                          (200...299).contains(response.statusCode),
+                          response.url == request.url else {
+                        throw URLError(.badServerResponse)
+                    }
+
+                    let maximumBytes = validationPolicy.maximumBytes
+                    guard response.expectedContentLength <= Int64(maximumBytes) else {
+                        throw URLError(.dataLengthExceedsMaximum)
+                    }
+                    var data = Data()
+                    if response.expectedContentLength > 0 {
+                        data.reserveCapacity(Int(response.expectedContentLength))
+                    }
+                    for try await byte in bytes {
+                        guard data.count < maximumBytes else {
+                            throw URLError(.dataLengthExceedsMaximum)
+                        }
+                        data.append(byte)
+                    }
                     return data
                 }
             },
@@ -76,7 +117,11 @@ private extension GeoRelayDirectoryDependencies {
                     )
                     let dir = base.appendingPathComponent("bitchat", isDirectory: true)
                     try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
-                    return dir.appendingPathComponent("georelays_cache.csv")
+                    // v2 ignores caches populated from the old direct-upstream
+                    // trust path and subjects every load to strict validation.
+                    let legacyCache = dir.appendingPathComponent("georelays_cache.csv")
+                    try? FileManager.default.removeItem(at: legacyCache)
+                    return dir.appendingPathComponent("georelays_cache_v2.csv")
                 } catch {
                     return nil
                 }
@@ -94,7 +139,8 @@ private extension GeoRelayDirectoryDependencies {
                 try? await Task.sleep(nanoseconds: nanoseconds)
             },
             activeNotificationName: activeNotificationName,
-            autoStart: true
+            autoStart: true,
+            validationPolicy: validationPolicy
         )
     }
 }
@@ -125,7 +171,7 @@ final class GeoRelayDirectory {
     }
 
     private enum DetachedFetchOutcome: Sendable {
-        case success(entries: [Entry], csv: String)
+        case success(entries: [Entry], csv: Data)
         case torNotReady
         case invalidData
         case network(String)
@@ -212,6 +258,8 @@ final class GeoRelayDirectory {
         )
         let awaitTorReady = dependencies.awaitTorReady
         let fetchData = dependencies.makeFetchData()
+        let validationPolicy = dependencies.validationPolicy
+        let baselineEntries = Set(entries)
 
         Task { [weak self] in
             guard let self else { return }
@@ -219,7 +267,9 @@ final class GeoRelayDirectory {
             let outcome = await Self.fetchRemoteOutcome(
                 request: request,
                 awaitTorReady: awaitTorReady,
-                fetchData: fetchData
+                fetchData: fetchData,
+                validationPolicy: validationPolicy,
+                baselineEntries: baselineEntries
             )
 
             switch outcome {
@@ -238,7 +288,9 @@ final class GeoRelayDirectory {
     nonisolated private static func fetchRemoteOutcome(
         request: URLRequest,
         awaitTorReady: @escaping @Sendable () async -> Bool,
-        fetchData: @escaping @Sendable (URLRequest) async throws -> Data
+        fetchData: @escaping @Sendable (URLRequest) async throws -> Data,
+        validationPolicy: GeoRelayDirectoryValidationPolicy,
+        baselineEntries: Set<Entry>
     ) async -> DetachedFetchOutcome {
         await Task.detached(priority: .utility) {
             let ready = await awaitTorReady()
@@ -246,16 +298,16 @@ final class GeoRelayDirectory {
 
             do {
                 let data = try await fetchData(request)
-                guard let text = String(data: data, encoding: .utf8) else {
+                guard let parsed = Self.validatedEntries(
+                    from: data,
+                    policy: validationPolicy,
+                    minimumEntries: validationPolicy.minimumRemoteEntries,
+                    baselineEntries: baselineEntries
+                ) else {
                     return .invalidData
                 }
 
-                let parsed = Self.parseCSV(text)
-                guard !parsed.isEmpty else {
-                    return .invalidData
-                }
-
-                return .success(entries: parsed, csv: text)
+                return .success(entries: parsed, csv: data)
             } catch {
                 return .network(error.localizedDescription)
             }
@@ -269,7 +321,7 @@ final class GeoRelayDirectory {
     }
 
     @MainActor
-    private func handleFetchSuccess(entries parsed: [Entry], csv: String) {
+    private func handleFetchSuccess(entries parsed: [Entry], csv: Data) {
         entries = parsed
         persistCache(csv)
         dependencies.userDefaults.set(dependencies.now(), forKey: lastFetchKey)
@@ -321,9 +373,8 @@ final class GeoRelayDirectory {
         cleanupState.retryTask = nil
     }
 
-    private func persistCache(_ text: String) {
+    private func persistCache(_ data: Data) {
         guard let url = dependencies.cacheURL() else { return }
-        guard let data = text.data(using: .utf8) else { return }
         do {
             try dependencies.writeData(data, url)
         } catch {
@@ -336,9 +387,12 @@ final class GeoRelayDirectory {
         // Prefer cached file if present
         if let cache = dependencies.cacheURL(),
            let data = dependencies.readData(cache),
-           let text = String(data: data, encoding: .utf8) {
-            let arr = Self.parseCSV(text)
-            if !arr.isEmpty { return arr }
+           let entries = Self.validatedEntries(
+               from: data,
+               policy: dependencies.validationPolicy,
+               minimumEntries: 1
+           ) {
+            return entries
         }
 
         // Try bundled resource(s)
@@ -346,36 +400,157 @@ final class GeoRelayDirectory {
 
         for url in bundleCandidates {
             if let data = dependencies.readData(url),
-               let text = String(data: data, encoding: .utf8) {
-                let arr = Self.parseCSV(text)
-                if !arr.isEmpty { return arr }
+               let entries = Self.validatedEntries(
+                   from: data,
+                   policy: dependencies.validationPolicy,
+                   minimumEntries: 1
+               ) {
+                return entries
             }
         }
 
         // Try filesystem path (development/test)
         if let cwd = dependencies.currentDirectoryPath(),
            let data = dependencies.readData(URL(fileURLWithPath: cwd).appendingPathComponent("relays/online_relays_gps.csv")),
-           let text = String(data: data, encoding: .utf8) {
-            return Self.parseCSV(text)
+           let entries = Self.validatedEntries(
+               from: data,
+               policy: dependencies.validationPolicy,
+               minimumEntries: 1
+           ) {
+            return entries
         }
 
         SecureLogger.warning("GeoRelayDirectory: no local CSV found; entries empty", category: .session)
         return []
     }
 
-    nonisolated static func parseCSV(_ text: String) -> [Entry] {
-        var result: Set<Entry> = []
-        let lines = text.split(whereSeparator: { $0.isNewline })
-        for (idx, raw) in lines.enumerated() {
-            guard let line = raw.trimmedOrNilIfEmpty else { continue }
-            if idx == 0 && line.lowercased().contains("relay url") { continue }
-            let parts = line.split(separator: ",").map { $0.trimmed }
-            guard parts.count >= 3 else { continue }
-            guard let host = NostrRelayURL.directoryAddress(parts[0]) else { continue }
-            guard let lat = Double(parts[1]), let lon = Double(parts[2]) else { continue }
-            result.insert(Entry(host: host, lat: lat, lon: lon))
+    /// Parses the fixed three-column format as an all-or-nothing trust unit.
+    /// One malformed or conflicting row rejects the complete dataset rather
+    /// than silently shrinking or partially replacing the current directory.
+    nonisolated static func validatedEntries(
+        from data: Data,
+        policy: GeoRelayDirectoryValidationPolicy,
+        minimumEntries: Int,
+        baselineEntries: Set<Entry>? = nil
+    ) -> [Entry]? {
+        guard !data.isEmpty, data.count <= policy.maximumBytes,
+              let text = String(data: data, encoding: .utf8),
+              !text.hasPrefix("\u{feff}") else {
+            return nil
         }
-        return Array(result)
+
+        let lines = text.split(whereSeparator: { $0.isNewline })
+            .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
+            .filter { !$0.isEmpty }
+        guard let header = lines.first,
+              lines.count - 1 <= policy.maximumRows else {
+            return nil
+        }
+
+        let headerParts = header
+            .split(separator: ",", omittingEmptySubsequences: false)
+            .map { $0.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() }
+        let supportedHeaders = [
+            ["relay url", "latitude", "longitude"],
+            ["relay url", "lat", "lon"]
+        ]
+        guard supportedHeaders.contains(headerParts) else {
+            return nil
+        }
+
+        var entriesByHost: [String: Entry] = [:]
+        for line in lines.dropFirst() {
+            let parts = line
+                .split(separator: ",", omittingEmptySubsequences: false)
+                .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
+            guard parts.count == 3,
+                  let host = validatedDirectoryAddress(parts[0]),
+                  let latitude = Double(parts[1]), latitude.isFinite,
+                  (-90.0...90.0).contains(latitude),
+                  let longitude = Double(parts[2]), longitude.isFinite,
+                  (-180.0...180.0).contains(longitude) else {
+                return nil
+            }
+
+            let entry = Entry(host: host, lat: latitude, lon: longitude)
+            if let existing = entriesByHost[host], existing != entry {
+                // One endpoint cannot truthfully occupy two coordinates. Do
+                // not let row ordering choose which location clients trust.
+                return nil
+            }
+            entriesByHost[host] = entry
+            guard entriesByHost.count <= policy.maximumEntries else { return nil }
+        }
+
+        let parsedEntries = Set(entriesByHost.values)
+        guard parsedEntries.count >= minimumEntries else { return nil }
+
+        if let baselineEntries {
+            guard (0...1).contains(policy.minimumRetainedFraction) else { return nil }
+            let requiredOverlap = Int(
+                ceil(Double(baselineEntries.count) * policy.minimumRetainedFraction)
+            )
+            guard parsedEntries.intersection(baselineEntries).count >= requiredOverlap else {
+                return nil
+            }
+        }
+
+        return parsedEntries.sorted {
+            ($0.host, $0.lat, $0.lon) < ($1.host, $1.lat, $1.lon)
+        }
+    }
+
+    nonisolated private static func validatedDirectoryAddress(_ rawValue: String) -> String? {
+        let value = rawValue.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !value.isEmpty,
+              value.unicodeScalars.allSatisfy({
+                  $0.isASCII && !CharacterSet.controlCharacters.contains($0)
+              }) else {
+            return nil
+        }
+
+        let candidate = value.contains("://") ? value : "wss://\(value)"
+        guard let components = URLComponents(string: candidate),
+              let scheme = components.scheme?.lowercased(),
+              scheme == "wss" || scheme == "https",
+              components.user == nil,
+              components.password == nil,
+              components.query == nil,
+              components.fragment == nil,
+              components.path.isEmpty || components.path == "/",
+              let rawHost = components.host else {
+            return nil
+        }
+
+        let host = rawHost.lowercased()
+        guard !host.isEmpty, host.count <= 253,
+              host.unicodeScalars.allSatisfy({ $0.isASCII }),
+              !host.hasSuffix("."),
+              host != "localhost",
+              !host.hasSuffix(".localhost"),
+              !host.hasSuffix(".local"),
+              !host.hasSuffix(".internal") else {
+            return nil
+        }
+
+        let labels = host.split(separator: ".", omittingEmptySubsequences: false)
+        let allowed = CharacterSet(charactersIn: "abcdefghijklmnopqrstuvwxyz0123456789-")
+        guard labels.count >= 2,
+              !labels.allSatisfy({ $0.allSatisfy(\.isNumber) }),
+              labels.allSatisfy({ label in
+                  (1...63).contains(label.count) &&
+                  label.first != "-" &&
+                  label.last != "-" &&
+                  label.unicodeScalars.allSatisfy { allowed.contains($0) }
+              }) else {
+            return nil
+        }
+
+        if let port = components.port {
+            guard (1...65_535).contains(port) else { return nil }
+            if port != 443 { return "\(host):\(port)" }
+        }
+        return host
     }
 
     // MARK: - Observers & Timers

bitchat/Nostr/NostrRelayURL.swift

@@ -39,13 +39,4 @@ enum NostrRelayURL {
 
         return components.string
     }
-
-    static func directoryAddress(_ rawValue: String) -> String? {
-        guard var normalized = normalized(rawValue, defaultScheme: "wss") else { return nil }
-        for prefix in ["wss://", "ws://"] where normalized.hasPrefix(prefix) {
-            normalized.removeFirst(prefix.count)
-            break
-        }
-        return normalized
-    }
 }

bitchat/Protocols/BitchatFilePacket.swift

@@ -154,90 +154,3 @@ struct BitchatFilePacket {
         )
     }
 }
-
-/// Wire-compatible identity for private media exchanged by clients using the
-/// current iOS entropy-bearing filenames, without extending the deployed file
-/// TLV. Android clients reject unknown file tags, so eligible senders and
-/// receivers derive the receipt key from fields already on the wire.
-///
-/// Locally-created image and voice-note filenames contain a UUID or live-voice
-/// burst ID. Including the normalized direction keeps a reused filename
-/// distinct across chats while allowing short and full Noise-key peer IDs to
-/// converge. Android and older-iOS timestamp-only names remain ineligible and
-/// retain their legacy random local IDs (transfer-compatible, no receipts).
-enum PrivateMediaMessageIdentity {
-    private static let domain = Data("bitchat-private-media-message-v1".utf8)
-    private static let idPrefix = "media-"
-    private static let digestHexLength = 32
-
-    static func isStableID(_ candidate: String) -> Bool {
-        guard candidate.hasPrefix(idPrefix) else { return false }
-        let digest = candidate.dropFirst(idPrefix.count)
-        guard digest.utf8.count == digestHexLength else { return false }
-        return digest.utf8.allSatisfy { byte in
-            (UInt8(ascii: "0")...UInt8(ascii: "9")).contains(byte)
-                || (UInt8(ascii: "a")...UInt8(ascii: "f")).contains(byte)
-        }
-    }
-
-    static func stableID(
-        senderPeerID: PeerID,
-        recipientPeerID: PeerID,
-        fileName: String?
-    ) -> String? {
-        guard let fileName, !fileName.isEmpty else { return nil }
-        let leafName = (fileName as NSString).lastPathComponent
-        guard leafName == fileName else { return nil }
-
-        let path = leafName as NSString
-        let stem = path.deletingPathExtension
-        let fileExtension = path.pathExtension.lowercased()
-        switch true {
-        case stem.hasPrefix("img_"):
-            guard fileExtension == "jpg" || fileExtension == "jpeg" else { return nil }
-        case stem.hasPrefix("voice_"):
-            guard fileExtension == "m4a" else { return nil }
-        default:
-            return nil
-        }
-        let entropyToken = stem.split(separator: "_").last.map(String.init)
-        let hasUUIDEntropy = entropyToken.flatMap(UUID.init(uuidString:)) != nil
-        let voiceBurstID = stem.hasPrefix("voice_")
-            ? String(stem.dropFirst("voice_".count))
-            : ""
-        let hasBurstEntropy = voiceBurstID.count == 16
-            && voiceBurstID.allSatisfy(\.isHexDigit)
-        guard hasUUIDEntropy || hasBurstEntropy else {
-            return nil
-        }
-
-        let fields = [
-            Data(senderPeerID.toShort().bare.utf8),
-            Data(recipientPeerID.toShort().bare.utf8),
-            Data(leafName.utf8)
-        ]
-        var input = domain
-        for field in fields {
-            guard let length = UInt32(exactly: field.count) else { return nil }
-            var bigEndianLength = length.bigEndian
-            withUnsafeBytes(of: &bigEndianLength) {
-                input.append(contentsOf: $0)
-            }
-            input.append(field)
-        }
-
-        return "\(idPrefix)\(input.sha256Hex().prefix(digestHexLength))"
-    }
-
-    static func stableID(
-        for packet: BitchatFilePacket,
-        senderPeerID: PeerID,
-        recipientPeerID: PeerID
-    ) -> String? {
-        stableID(
-            senderPeerID: senderPeerID,
-            recipientPeerID: recipientPeerID,
-            fileName: packet.fileName
-        )
-    }
-}

bitchat/Protocols/BitchatProtocol.swift

@@ -79,35 +79,12 @@ enum NoisePayloadType: UInt8 {
     case groupKeyUpdate = 0x07      // Creator-signed group state (key rotation / roster update)
     // Live voice (push-to-talk)
     case voiceFrame = 0x08          // One live voice-burst packet (see VoiceBurstPacket)
-    // Finalized private media. `0x20` is the value already deployed by the
-    // Android client. The complete BitchatFilePacket is encrypted inside
-    // Noise before the outer noiseEncrypted packet is fragmented.
-    case privateFile = 0x20
-    // Versioned peer state authenticated by the surrounding Noise session.
-    // This is intentionally distinct from the public announce: announce
-    // capabilities are discovery hints, while this payload proves possession
-    // of the advertised Noise static key before downgrade state is pinned.
-    case authenticatedPeerState = 0x21
     // Verification (QR-based OOB binding)
     case verifyChallenge = 0x10     // Verification challenge
     case verifyResponse  = 0x11     // Verification response
     // Transitive verification (web of trust)
     case vouch = 0x12               // Batch of vouch attestations
 
-    /// #1434 briefly used 0x09 before release. Accept it while prerelease
-    /// builds age out, but never emit it. Decoders canonicalize both values to
-    /// `.privateFile` so the compatibility alias cannot leak into app logic.
-    static let prereleasePrivateFileRawValue: UInt8 = 0x09
-
-    static func decoded(rawValue: UInt8) -> NoisePayloadType? {
-        rawValue == prereleasePrivateFileRawValue ? .privateFile : Self(rawValue: rawValue)
-    }
-
-    static func isPrivateFile(rawValue: UInt8?) -> Bool {
-        guard let rawValue else { return false }
-        return rawValue == privateFile.rawValue || rawValue == prereleasePrivateFileRawValue
-    }
-
     var description: String {
         switch self {
         case .privateMessage: return "privateMessage"
@@ -116,8 +93,6 @@ enum NoisePayloadType: UInt8 {
         case .groupInvite: return "groupInvite"
         case .groupKeyUpdate: return "groupKeyUpdate"
         case .voiceFrame: return "voiceFrame"
-        case .privateFile: return "privateFile"
-        case .authenticatedPeerState: return "authenticatedPeerState"
         case .verifyChallenge: return "verifyChallenge"
         case .verifyResponse: return "verifyResponse"
         case .vouch: return "vouch"

bitchat/Protocols/Packets.swift

@@ -156,89 +156,6 @@ struct AnnouncementPacket {
     }
 }
 
-/// State that is authoritative only because it is carried inside an
-/// established Noise session. The public announce remains useful for
-/// discovery, but its self-signature cannot prove possession of the copied
-/// Noise public key it contains.
-///
-/// Wire format (v1):
-/// `[version=0x01][type][length][value]...`
-/// - TLV `0x01`: canonical minimal little-endian `PeerCapabilities`
-/// - TLV `0x02`: 32-byte Ed25519 signing public key
-///
-/// Unknown TLVs are skipped for forward compatibility. Unknown versions,
-/// duplicates, non-canonical capability fields, and malformed lengths are
-/// rejected without changing authenticated state.
-struct AuthenticatedPeerStatePacket: Equatable {
-    static let currentVersion: UInt8 = 1
-    static let signingPublicKeyLength = 32
-
-    let capabilities: PeerCapabilities
-    let signingPublicKey: Data
-
-    private enum TLVType: UInt8 {
-        case capabilities = 0x01
-        case signingPublicKey = 0x02
-    }
-
-    func encode() -> Data? {
-        guard signingPublicKey.count == Self.signingPublicKeyLength else { return nil }
-        let capabilityBytes = capabilities.encoded()
-        guard !capabilityBytes.isEmpty, capabilityBytes.count <= 8 else { return nil }
-
-        var data = Data([Self.currentVersion])
-        data.append(TLVType.capabilities.rawValue)
-        data.append(UInt8(capabilityBytes.count))
-        data.append(capabilityBytes)
-        data.append(TLVType.signingPublicKey.rawValue)
-        data.append(UInt8(signingPublicKey.count))
-        data.append(signingPublicKey)
-        return data
-    }
-
-    static func decode(from data: Data) -> AuthenticatedPeerStatePacket? {
-        guard data.first == Self.currentVersion else { return nil }
-
-        var offset = 1
-        var capabilities: PeerCapabilities?
-        var signingPublicKey: Data?
-
-        while offset < data.count {
-            guard offset + 2 <= data.count else { return nil }
-            let typeRaw = data[offset]
-            let length = Int(data[offset + 1])
-            offset += 2
-            guard offset + length <= data.count else { return nil }
-            let value = Data(data[offset..<(offset + length)])
-            offset += length
-
-            guard let type = TLVType(rawValue: typeRaw) else {
-                continue
-            }
-            switch type {
-            case .capabilities:
-                guard capabilities == nil,
-                      !value.isEmpty,
-                      value.count <= 8 else { return nil }
-                let decoded = PeerCapabilities(encoded: value)
-                guard decoded.encoded() == value else { return nil }
-                capabilities = decoded
-
-            case .signingPublicKey:
-                guard signingPublicKey == nil,
-                      value.count == Self.signingPublicKeyLength else { return nil }
-                signingPublicKey = value
-            }
-        }
-
-        guard let capabilities, let signingPublicKey else { return nil }
-        return AuthenticatedPeerStatePacket(
-            capabilities: capabilities,
-            signingPublicKey: signingPublicKey
-        )
-    }
-}
-
 struct PrivateMessagePacket {
     let messageID: String
     let content: String

bitchat/Protocols/PeerCapabilities+Local.swift

@@ -3,11 +3,5 @@ import BitFoundation
 extension PeerCapabilities {
     /// Capabilities this build advertises in its announce packets.
     /// Each feature adds its bit here when it ships.
-    static let localSupported: PeerCapabilities = [
-        .vouch,
-        .prekeys,
-        .groups,
-        .privateMedia,
-        .privateMediaReceipts
-    ]
+    static let localSupported: PeerCapabilities = [.vouch, .prekeys, .groups]
 }

bitchat/Services/BLE/BLEAnnounceHandler.swift

@@ -16,9 +16,6 @@ struct BLEAnnounceHandlerEnvironment {
     let now: () -> Date
     /// Noise public key already recorded for the peer, if any (registry read).
     let existingNoisePublicKey: (PeerID) -> Data?
-    /// Ed25519 key previously bound to this Noise identity by an authenticated
-    /// peer-state payload, if any (persistent identity-state read).
-    let authenticatedSigningPublicKey: (_ noisePublicKey: Data) -> Data?
     /// Verifies the packet signature against the announced signing key.
     let verifySignature: (_ packet: BitchatPacket, _ signingPublicKey: Data) -> Bool
     /// Direct link state for the peer (BLE-queue read).
@@ -133,21 +130,11 @@ final class BLEAnnounceHandler {
             hasSignature: hasSignature,
             signatureValid: signatureValid,
             existingNoisePublicKey: existingNoisePublicKey,
-            announcedNoisePublicKey: announcement.noisePublicKey,
-            authenticatedSigningPublicKey: env.authenticatedSigningPublicKey(
-                announcement.noisePublicKey
-            ),
-            announcedSigningPublicKey: announcement.signingPublicKey
+            announcedNoisePublicKey: announcement.noisePublicKey
         )
         if case .reject(.keyMismatch) = trustDecision {
             SecureLogger.warning("⚠️ Announce key mismatch for \(peerID.id.prefix(8))… — keeping unverified", category: .security)
         }
-        if case .reject(.authenticatedSigningKeyMismatch) = trustDecision {
-            SecureLogger.warning(
-                "⚠️ Announce signing-key replacement rejected for Noise-authenticated peer \(peerID.id.prefix(8))…",
-                category: .security
-            )
-        }
         let verifiedAnnounce = trustDecision.isVerified
 
         var isNewPeer = false

bitchat/Services/BLE/BLEAnnounceHandlingPolicy.swift

@@ -56,7 +56,6 @@ enum BLEAnnounceTrustRejection: Equatable {
     case missingSignature
     case invalidSignature
     case keyMismatch
-    case authenticatedSigningKeyMismatch
 }
 
 enum BLEAnnounceTrustDecision: Equatable {
@@ -73,19 +72,12 @@ enum BLEAnnounceTrustPolicy {
         hasSignature: Bool,
         signatureValid: Bool,
         existingNoisePublicKey: Data?,
-        announcedNoisePublicKey: Data,
-        authenticatedSigningPublicKey: Data? = nil,
-        announcedSigningPublicKey: Data? = nil
+        announcedNoisePublicKey: Data
     ) -> BLEAnnounceTrustDecision {
         if let existingNoisePublicKey, existingNoisePublicKey != announcedNoisePublicKey {
             return .reject(.keyMismatch)
         }
 
-        if let authenticatedSigningPublicKey,
-           announcedSigningPublicKey != authenticatedSigningPublicKey {
-            return .reject(.authenticatedSigningKeyMismatch)
-        }
-
         guard hasSignature else {
             return .reject(.missingSignature)
         }

bitchat/Services/BLE/BLEFileTransferHandler.swift

@@ -16,8 +16,6 @@ struct BLEFileTransferHandlerEnvironment {
     let peersSnapshot: () -> [PeerID: BLEPeerInfo]
     /// Verifies a packet's signature against a candidate signing key (registry path).
     let verifyPacketSignature: (_ packet: BitchatPacket, _ signingPublicKey: Data) -> Bool
-    /// Local signing key used to authenticate our own gossip-sync replays.
-    let localSigningPublicKey: () -> Data
     /// Resolves a display name from a verified packet signature for peers missing from the registry.
     let signedSenderDisplayName: (_ packet: BitchatPacket, _ peerID: PeerID) -> String?
     /// Tracks the broadcast file packet for gossip sync.
@@ -32,79 +30,10 @@ struct BLEFileTransferHandlerEnvironment {
         _ fallbackExtension: String?,
         _ defaultPrefix: String
     ) -> URL?
-    /// Resolves the durable receiver decision for a stable private-media ID.
-    let privateMediaReceiptState: (
-        _ messageID: String
-    ) -> BLEPrivateMediaReceiptState
-    /// Atomically records a stable private-media ID after the payload save.
-    let commitPrivateMediaFile: (_ messageID: String, _ storedURL: URL) -> Bool
-    /// Rolls back a saved payload when its durable receipt commit fails.
-    let removeIncomingFile: (_ storedURL: URL) -> Void
-    /// Checks the authenticated sender before any private-media disk work.
-    let isPrivateMediaSenderBlocked: (PeerID) -> Bool
     /// Updates the registry last-seen timestamp for the peer (async barrier write).
     let updatePeerLastSeen: (PeerID) -> Void
-    /// Acknowledges stable private media only after its synchronous
-    /// conversation delivery has completed.
-    let acknowledgePrivateMedia: (_ messageID: String, _ peerID: PeerID) -> Void
-    /// Delivers `.messageReceived` as one main-actor hop while
-    /// `shouldDeliver` remains true before and after the synchronous sink.
-    /// The completion authorizes the stable-media ACK.
-    let deliverMessage: (
-        _ message: BitchatMessage,
-        _ shouldDeliver: @escaping () -> Bool,
-        _ completion: @escaping () -> Void
-    ) -> Void
-}
-
-/// Process-lifetime reservation cache for stable private-media IDs.
-///
-/// The first arrival reserves its ID before quota enforcement. Concurrent
-/// arrivals remain coalesced in memory, while accepted state is resolved from
-/// the durable ID-to-file ledger so it survives relaunch and becomes retryable
-/// if quota cleanup removed the file.
-private final class PrivateMediaArrivalDeduplicator {
-    enum Reservation {
-        case reserved
-        case pending
-        case accepted(URL)
-        case tombstoned
-        case unavailable
-    }
-
-    private let lock = NSLock()
-    private var pending: Set<String> = []
-
-    func reserve(
-        _ messageID: String,
-        receiptState: () -> BLEPrivateMediaReceiptState
-    ) -> Reservation {
-        lock.lock()
-        defer { lock.unlock() }
-        if pending.contains(messageID) {
-            return .pending
-        }
-
-        switch receiptState() {
-        case .accepted(let existingURL):
-            return .accepted(existingURL)
-        case .tombstoned:
-            return .tombstoned
-        case .unavailable:
-            return .unavailable
-        case .absent:
-            break
-        }
-
-        pending.insert(messageID)
-        return .reserved
-    }
-
-    func finish(_ messageID: String) {
-        lock.lock()
-        defer { lock.unlock() }
-        pending.remove(messageID)
-    }
+    /// Delivers `.messageReceived` to the UI as one main-actor hop.
+    let deliverMessage: (BitchatMessage) -> Void
 }
 
 /// Orchestrates inbound file transfers: self-echo policy, sender display-name
@@ -112,204 +41,61 @@ private final class PrivateMediaArrivalDeduplicator {
 /// and UI delivery.
 final class BLEFileTransferHandler {
     private let environment: BLEFileTransferHandlerEnvironment
-    private let privateMediaArrivals = PrivateMediaArrivalDeduplicator()
 
     init(environment: BLEFileTransferHandlerEnvironment) {
         self.environment = environment
     }
 
-    /// Returns `false` when the raw packet fails sender authentication (or is
-    /// a live self-echo) and must not be relayed onward. Authentication runs
-    /// before the routing decision, so a forged directed packet cannot use a
-    /// node that is not its recipient as an unsigned forwarding hop.
+    /// Returns `false` when the packet fails sender authentication and must
+    /// not be relayed onward. Every other outcome returns `true`: files
+    /// directed to another peer are forwarded untouched, and local-only drops
+    /// (malformed payload, quota, save failure) don't affect multi-hop
+    /// delivery to nodes that may handle them fine.
     @discardableResult
     func handle(_ packet: BitchatPacket, from peerID: PeerID) -> Bool {
         let env = environment
-        let localPeerID = env.localPeerID()
-        let peersSnapshot = env.peersSnapshot()
+        if BLEFileTransferPolicy.isSelfEcho(packet: packet, from: peerID, localPeerID: env.localPeerID()) { return true }
 
-        guard let senderNickname = authenticatedRawSenderNickname(
+        guard let deliveryPlan = BLEFileTransferPolicy.deliveryPlan(packet: packet, localPeerID: env.localPeerID()) else {
+            return true
+        }
+
+        let peersSnapshot = env.peersSnapshot()
+        guard let senderNickname = resolveSenderNickname(
             packet: packet,
             from: peerID,
+            isBroadcast: !deliveryPlan.isPrivateMessage,
             peers: peersSnapshot,
             env: env
         ) else {
-            SecureLogger.warning("🚫 Dropping raw file transfer with missing/invalid signature from \(peerID.id.prefix(8))…", category: .security)
+            SecureLogger.warning("🚫 Dropping file transfer from unverified or unknown peer \(peerID.id.prefix(8))…", category: .security)
             return false
         }
 
-        if BLEFileTransferPolicy.isSelfEcho(packet: packet, from: peerID, localPeerID: localPeerID) {
-            return false
-        }
-
-        guard let deliveryPlan = BLEFileTransferPolicy.deliveryPlan(packet: packet, localPeerID: localPeerID) else {
-            return true
-        }
-
         if deliveryPlan.shouldTrackForSync {
             env.trackPacketSeen(packet)
         }
 
-        _ = storeIncomingPayload(
-            packet.payload,
-            from: peerID,
-            senderNickname: senderNickname,
-            timestamp: Date(timeIntervalSince1970: Double(packet.timestamp) / 1000),
-            isPrivate: deliveryPlan.isPrivateMessage,
-            usesDurableReceipts: false,
-            env: env
-        )
-        // Once authenticated, a local decode/quota/save failure is not proof
-        // that downstream nodes should be denied the valid signed packet.
-        return true
-    }
-
-    /// Accepts a file packet only after it has been authenticated and
-    /// decrypted by the peer's Noise session. The inner packet deliberately
-    /// has no redundant signature: Noise supplies sender authentication and
-    /// confidentiality, while this handler retains the same validation,
-    /// quota, persistence, and UI-delivery behavior as public files.
-    @discardableResult
-    func handlePrivatePayload(_ payload: Data, from peerID: PeerID, timestamp: Date) -> Bool {
-        let env = environment
-        let peers = env.peersSnapshot()
-        let senderNickname = BLEPeerSenderDisplayName.resolveKnownPeer(
-            peerID: peerID,
-            localPeerID: env.localPeerID(),
-            localNickname: env.localNickname(),
-            peers: peers,
-            allowConnectedUnverified: true
-        ) ?? BLEPeerSenderDisplayName.anonymousNickname(for: peerID)
-
-        return storeIncomingPayload(
-            payload,
-            from: peerID,
-            senderNickname: senderNickname,
-            timestamp: timestamp,
-            isPrivate: true,
-            // Every authenticated Noise private-file keeps the stable ID/ACK
-            // contract introduced with capability bit 8. Bit 9 advertises
-            // sender-side automatic retry support; it must not downgrade
-            // prior iOS clients to random IDs or single-check delivery.
-            usesDurableReceipts: true,
-            env: env
-        )
-    }
-
-    private func storeIncomingPayload(
-        _ payload: Data,
-        from peerID: PeerID,
-        senderNickname: String,
-        timestamp: Date,
-        isPrivate: Bool,
-        usesDurableReceipts: Bool,
-        env: BLEFileTransferHandlerEnvironment
-    ) -> Bool {
-
-        let localPeerID = env.localPeerID()
         let filePacket: BitchatFilePacket
         let mime: MimeType
-        switch BLEIncomingFileValidator.validate(payload: payload) {
+        switch BLEIncomingFileValidator.validate(payload: packet.payload) {
         case .success(let acceptance):
             filePacket = acceptance.filePacket
             mime = acceptance.mime
         case .failure(.malformedPayload):
             SecureLogger.error("❌ Failed to decode file transfer payload", category: .session)
-            return false
+            return true
         case .failure(.payloadTooLarge(let bytes)):
             SecureLogger.warning("🚫 Dropping file transfer exceeding size cap (\(bytes) bytes)", category: .security)
-            return false
+            return true
         case .failure(.unsupportedMime(let mimeType, let bytes)):
             SecureLogger.warning("🚫 MIME REJECT: '\(mimeType ?? "<empty>")' not supported. Size=\(bytes)b from \(peerID.id.prefix(8))...", category: .security)
-            return false
+            return true
         case .failure(.magicMismatch(let mime, let bytes, let prefixHex)):
             SecureLogger.warning("🚫 MAGIC REJECT: MIME='\(mime)' size=\(bytes)b prefix=[\(prefixHex)] from \(peerID.id.prefix(8))...", category: .security)
-            return false
-        }
-
-        if isPrivate, env.isPrivateMediaSenderBlocked(peerID) {
-            SecureLogger.debug(
-                "🚫 Dropping private media from blocked peer \(peerID.id.prefix(8))… before disk write",
-                category: .security
-            )
             return true
         }
 
-        let messageID = usesDurableReceipts
-            ? PrivateMediaMessageIdentity.stableID(
-                for: filePacket,
-                senderPeerID: peerID,
-                recipientPeerID: localPeerID
-            )
-            : nil
-        if let messageID {
-            switch privateMediaArrivals.reserve(
-                messageID,
-                receiptState: { env.privateMediaReceiptState(messageID) }
-            ) {
-            case .reserved:
-                break
-            case .pending:
-                // The first arrival has not reached durable storage yet.
-                // Coalesce this retry without ACKing so a failed first save
-                // remains retryable by the sender.
-                SecureLogger.debug(
-                    "📁 Coalesced in-flight private media id=\(messageID.prefix(12))… from \(peerID.id.prefix(8))…",
-                    category: .session
-                )
-                return true
-            case .accepted(let existingFile):
-                env.updatePeerLastSeen(peerID)
-                let message = incomingMessage(
-                    messageID: messageID,
-                    senderNickname: senderNickname,
-                    timestamp: timestamp,
-                    isPrivate: true,
-                    peerID: peerID,
-                    destination: existingFile,
-                    category: storedMediaCategory(
-                        for: existingFile,
-                        fallback: mime.category
-                    ),
-                    env: env
-                )
-                SecureLogger.debug(
-                    "📁 Restored durable private media duplicate id=\(messageID.prefix(12))… from \(peerID.id.prefix(8))… -> \(existingFile.lastPathComponent)",
-                    category: .session
-                )
-                deliverStableMessage(
-                    message,
-                    messageID: messageID,
-                    peerID: peerID,
-                    expectedURL: existingFile,
-                    env: env
-                )
-                return true
-            case .tombstoned:
-                // Explicit deletion is a durable terminal receiver decision.
-                env.updatePeerLastSeen(peerID)
-                env.acknowledgePrivateMedia(messageID, peerID)
-                SecureLogger.debug(
-                    "📁 Dropped explicitly deleted private media id=\(messageID.prefix(12))… from \(peerID.id.prefix(8))…",
-                    category: .session
-                )
-                return true
-            case .unavailable:
-                // Never turn an unreadable ledger into an empty ledger. The
-                // sender can retry after the transient storage failure clears.
-                SecureLogger.warning(
-                    "📁 Withholding private media id=\(messageID.prefix(12))… while durable receipt state is unavailable",
-                    category: .session
-                )
-                return true
-            }
-        }
-        defer {
-            if let messageID {
-                privateMediaArrivals.finish(messageID)
-            }
-        }
-
         // BCH-01-002: Enforce storage quota before saving
         env.enforceStorageQuota(filePacket.content.count)
 
@@ -320,155 +106,82 @@ final class BLEFileTransferHandler {
             mime.defaultExtension,
             mime.category.rawValue
         ) else {
-            return false
+            return true
         }
 
-        if let messageID,
-           !env.commitPrivateMediaFile(messageID, destination) {
-            // A payload without its durable ID mapping cannot safely suppress
-            // a retry after relaunch. Roll it back and withhold UI/ACK.
-            env.removeIncomingFile(destination)
-            return false
-        }
-
-        if isPrivate {
+        if deliveryPlan.isPrivateMessage {
             env.updatePeerLastSeen(peerID)
         }
 
-        let message = incomingMessage(
-            messageID: messageID,
-            senderNickname: senderNickname,
-            timestamp: timestamp,
-            isPrivate: isPrivate,
-            peerID: peerID,
-            destination: destination,
-            category: mime.category,
-            env: env
+        let ts = Date(timeIntervalSince1970: Double(packet.timestamp) / 1000)
+        let message = BitchatMessage(
+            sender: senderNickname,
+            content: "\(mime.category.messagePrefix)\(destination.lastPathComponent)",
+            timestamp: ts,
+            isRelay: false,
+            originalSender: nil,
+            isPrivate: deliveryPlan.isPrivateMessage,
+            recipientNickname: nil,
+            senderPeerID: peerID,
+            // Received messages need an explicit status: BitchatMessage
+            // defaults private messages to .sending, which the media views
+            // render as an in-flight send (empty reveal mask, disabled tap).
+            deliveryStatus: deliveryPlan.isPrivateMessage
+                ? .delivered(to: env.localNickname(), at: ts)
+                : nil
         )
 
         SecureLogger.debug("📁 Stored incoming media from \(peerID.id.prefix(8))… -> \(destination.lastPathComponent)", category: .session)
 
-        if let messageID {
-            deliverStableMessage(
-                message,
-                messageID: messageID,
-                peerID: peerID,
-                expectedURL: destination,
-                env: env
-            )
-        } else {
-            env.deliverMessage(message, { true }, {})
-        }
+        env.deliverMessage(message)
         return true
     }
 
-    private func deliverStableMessage(
-        _ message: BitchatMessage,
-        messageID: String,
-        peerID: PeerID,
-        expectedURL: URL,
-        env: BLEFileTransferHandlerEnvironment
-    ) {
-        env.deliverMessage(
-            message,
-            {
-                guard case .accepted(let resolvedURL) =
-                        env.privateMediaReceiptState(messageID) else {
-                    return false
-                }
-                return resolvedURL.standardizedFileURL
-                    == expectedURL.standardizedFileURL
-            },
-            {
-                env.acknowledgePrivateMedia(messageID, peerID)
-            }
-        )
-    }
-
-    private func incomingMessage(
-        messageID: String?,
-        senderNickname: String,
-        timestamp: Date,
-        isPrivate: Bool,
-        peerID: PeerID,
-        destination: URL,
-        category: MimeType.Category,
-        env: BLEFileTransferHandlerEnvironment
-    ) -> BitchatMessage {
-        BitchatMessage(
-            id: messageID,
-            sender: senderNickname,
-            content: "\(category.messagePrefix)\(destination.lastPathComponent)",
-            timestamp: timestamp,
-            isRelay: false,
-            originalSender: nil,
-            isPrivate: isPrivate,
-            recipientNickname: nil,
-            senderPeerID: peerID,
-            // Received messages need an explicit status: BitchatMessage
-            // defaults private messages to .sending, which media views render
-            // as an in-flight send.
-            deliveryStatus: isPrivate
-                ? .delivered(to: env.localNickname(), at: timestamp)
-                : nil
-        )
-    }
-
-    /// The durable URL is authoritative during reconstruction. A sender that
-    /// reuses a stable filename with a different MIME type must not change how
-    /// the already-stored payload renders.
-    private func storedMediaCategory(
-        for url: URL,
-        fallback: MimeType.Category
-    ) -> MimeType.Category {
-        let mediaDirectory = url
-            .deletingLastPathComponent()
-            .deletingLastPathComponent()
-            .lastPathComponent
-        switch mediaDirectory {
-        case MimeType.Category.audio.mediaDir:
-            return .audio
-        case MimeType.Category.image.mediaDir:
-            return .image
-        case MimeType.Category.file.mediaDir:
-            return .file
-        default:
-            return fallback
-        }
-    }
-
-    /// Every remaining raw file transfer is signed, regardless of whether it
-    /// is broadcast, addressed to us, or merely passing through. Registry
-    /// signing keys are preferred; persisted identities cover peers that have
-    /// rotated or are not currently present in the registry.
-    private func authenticatedRawSenderNickname(
+    /// Resolves the authenticated display name for a file transfer's sender.
+    ///
+    /// Directed (private) transfers are addressed to us specifically and keep
+    /// the lenient connected-peer path. Broadcast transfers carry an
+    /// attacker-controllable `senderID` exactly like public messages and public
+    /// voice frames — registry membership alone is NOT proof of identity, so a
+    /// valid packet signature from the claimed sender is required before we
+    /// trust it. Without this, a peer that observed a public voice burst could
+    /// spoof a broadcast `voice_<burstID>.m4a` note under the talker's ID and
+    /// overwrite the signature-verified live bubble with attacker audio.
+    private func resolveSenderNickname(
         packet: BitchatPacket,
         from peerID: PeerID,
+        isBroadcast: Bool,
         peers: [PeerID: BLEPeerInfo],
         env: BLEFileTransferHandlerEnvironment
     ) -> String? {
-        guard packet.signature != nil else { return nil }
+        guard isBroadcast else {
+            return BLEPeerSenderDisplayName.resolveKnownPeer(
+                peerID: peerID,
+                localPeerID: env.localPeerID(),
+                localNickname: env.localNickname(),
+                peers: peers,
+                allowConnectedUnverified: true
+            ) ?? env.signedSenderDisplayName(packet, peerID)
+        }
 
-        let localPeerID = env.localPeerID()
-        let candidateKey = peerID == localPeerID
-            ? env.localSigningPublicKey()
-            : peers[peerID]?.signingPublicKey
-        let verifiedWithKnownKey = candidateKey.map {
-            env.verifyPacketSignature(packet, $0)
-        } ?? false
-        let signedDisplayName = verifiedWithKnownKey
-            ? nil
-            : env.signedSenderDisplayName(packet, peerID)
-        guard verifiedWithKnownKey || signedDisplayName != nil else { return nil }
+        // Our own broadcasts replayed back via gossip sync (ttl==0) are
+        // trivially authentic and cannot be verified against the peer registry
+        // or identity cache, so exempt self exactly as `BLEPublicMessageHandler`
+        // does. Verify against the signing key already in the
+        // (synchronously-updated) registry first, then fall back to the
+        // persisted-identity signature lookup for peers not yet cached there.
+        let isSelf = peerID == env.localPeerID()
+        let registrySigningKey = peers[peerID]?.signingPublicKey
+        let verifiedViaRegistry = !isSelf && (registrySigningKey.map { env.verifyPacketSignature(packet, $0) } ?? false)
+        let signedDisplayName = (isSelf || verifiedViaRegistry) ? nil : env.signedSenderDisplayName(packet, peerID)
+        guard isSelf || verifiedViaRegistry || signedDisplayName != nil else { return nil }
 
         return BLEPeerSenderDisplayName.resolveKnownPeer(
             peerID: peerID,
-            localPeerID: localPeerID,
+            localPeerID: env.localPeerID(),
             localNickname: env.localNickname(),
             peers: peers,
-            // The packet signature authenticates the announced peer; the old
-            // connected-but-unsigned leniency is not involved.
-            allowConnectedUnverified: true
-        ) ?? signedDisplayName ?? BLEPeerSenderDisplayName.anonymousNickname(for: peerID)
+            allowConnectedUnverified: false
+        ) ?? signedDisplayName
     }
 }

bitchat/Services/BLE/BLEFragmentAssemblyBuffer.swift

@@ -201,11 +201,8 @@ struct BLEFragmentAssemblyBuffer {
     }
 
     private static func assemblyLimit(for originalType: UInt8) -> Int {
-        if originalType == MessageType.fileTransfer.rawValue
-            || originalType == MessageType.noiseEncrypted.rawValue {
+        if originalType == MessageType.fileTransfer.rawValue {
             // Allow headroom for TLV metadata and binary framing overhead.
-            // A large noiseEncrypted packet can be an E2E-encrypted private
-            // file; its authenticated plaintext is validated after decrypt.
             return FileTransferLimits.maxFramedFileBytes
         }
 

bitchat/Services/BLE/BLEIncomingFileStore.swift

@@ -134,7 +134,6 @@ struct BLEIncomingFileStore {
     private let baseDirectory: URL?
     private let dateProvider: () -> Date
     private let panicMarkerWriter: (Data, URL) throws -> Void
-    private let privateMediaReceipts: BLEPrivateMediaReceiptStore
 
     init(
         fileManager: FileManager = .default,
@@ -148,11 +147,6 @@ struct BLEIncomingFileStore {
         self.baseDirectory = baseDirectory
         self.dateProvider = dateProvider
         self.panicMarkerWriter = panicMarkerWriter
-        self.privateMediaReceipts = BLEPrivateMediaReceiptStore(
-            fileManager: fileManager,
-            baseDirectory: baseDirectory,
-            now: dateProvider
-        )
     }
 
     /// Panic-wipe every managed incoming and outgoing media artifact before
@@ -165,11 +159,6 @@ struct BLEIncomingFileStore {
     func panicWipe(
         hasDurablePendingMarker: Bool = false
     ) throws {
-        // The receipt index caches tombstones as well as accepted payloads.
-        // Always invalidate it on return, including partial-failure paths, so
-        // no pre-panic receiver decision survives after identity reset.
-        defer { privateMediaReceipts.resetForPanic() }
-
         let markerError: Error?
         do {
             try markPanicRecoveryPending()
@@ -268,35 +257,6 @@ struct BLEIncomingFileStore {
         }
     }
 
-    func privateMediaReceiptState(
-        messageID: String
-    ) -> BLEPrivateMediaReceiptState {
-        privateMediaReceipts.state(for: messageID)
-    }
-
-    func commitPrivateMediaFile(
-        messageID: String,
-        storedURL: URL
-    ) -> Bool {
-        privateMediaReceipts.commitAccepted(
-            messageID: messageID,
-            storedURL: storedURL
-        )
-    }
-
-    /// Best-effort rollback for a payload whose durable receipt commit failed.
-    func removeIncomingFile(at storedURL: URL) {
-        guard isURLInsideFilesDirectory(storedURL) else { return }
-        do {
-            try fileManager.removeItem(at: storedURL)
-        } catch {
-            SecureLogger.warning(
-                "⚠️ Failed to roll back uncommitted incoming media: \(error)",
-                category: .session
-            )
-        }
-    }
-
     /// Frees least-recently-modified incoming files until `reservingBytes`
     /// fits under the quota. Files named `voice_live_*` (in-flight live
     /// captures) are never evicted regardless of who triggers enforcement —
@@ -389,13 +349,6 @@ struct BLEIncomingFileStore {
         ]
     }
 
-    private func isURLInsideFilesDirectory(_ url: URL) -> Bool {
-        guard let filesDirectory = try? filesDirectory().standardizedFileURL else {
-            return false
-        }
-        return url.standardizedFileURL.path.hasPrefix(filesDirectory.path + "/")
-    }
-
     private func sanitizedFileName(_ name: String?, defaultName: String, fallbackExtension: String?) -> String {
         var candidate = (name ?? "")
             .replacingOccurrences(of: "\0", with: "")

bitchat/Services/BLE/BLENoisePacketHandler.swift

@@ -1,6 +1,5 @@
 import BitFoundation
 import BitLogger
-import CryptoKit
 import Foundation
 
 struct BLENoiseHandshakeHandlingResult {
@@ -8,11 +7,6 @@ struct BLENoiseHandshakeHandlingResult {
     let didEstablishAuthenticatedSession: Bool
 }
 
-struct BLENoiseDecryptionResult {
-    let plaintext: Data
-    let sessionGeneration: UUID
-}
-
 /// Narrow environment for `BLENoisePacketHandler`.
 ///
 /// All queue hops (collections barrier writes, main-actor UI notification)
@@ -34,8 +28,6 @@ struct BLENoisePacketHandlerEnvironment {
             -> NoiseHandshakeProcessingResult
     /// Whether any Noise session (established or pending) exists for the peer (crypto).
     let hasNoiseSession: (PeerID) -> Bool
-    /// Whether an inbound ordinary XX responder is waiting for message 3.
-    let isAwaitingResponderHandshakeCompletion: (PeerID) -> Bool
     /// Initiates a fresh Noise handshake with the peer (crypto + send).
     let initiateHandshake: (PeerID) -> Void
     /// Broadcasts a packet on the mesh (caller is already on the message queue).
@@ -43,16 +35,9 @@ struct BLENoisePacketHandlerEnvironment {
     /// Updates the registry last-seen timestamp for the peer (async barrier write).
     let updatePeerLastSeen: (PeerID) -> Void
     /// Decrypts an encrypted payload from the peer (crypto).
-    let decrypt: (_ payload: Data, _ peerID: PeerID) throws -> BLENoiseDecryptionResult
+    let decrypt: (_ payload: Data, _ peerID: PeerID) throws -> Data
     /// Clears the peer's Noise session after an unrecoverable decrypt failure (crypto).
     let clearSession: (PeerID) -> Void
-    /// Consumes session-authenticated protocol state inside the transport. It
-    /// must never escape to UI or Nostr payload dispatch.
-    let handleAuthenticatedPeerState: (
-        _ peerID: PeerID,
-        _ payload: Data,
-        _ sessionGeneration: UUID
-    ) -> Void
     /// Delivers `.noisePayloadReceived` to the UI as one main-actor hop.
     let deliverNoisePayload: (
         _ peerID: PeerID,
@@ -66,36 +51,15 @@ struct BLENoisePacketHandlerEnvironment {
 /// processing (with response), encrypted payload decryption and dispatch,
 /// and session recovery on decrypt failure.
 final class BLENoisePacketHandler {
-    private struct DeferredCiphertext {
-        let packet: BitchatPacket
-        let receivedAt: Date
-    }
-
-    /// Early post-handshake packets are normally tiny control messages or
-    /// queued DMs. Keep the recovery surface deliberately small so an
-    /// unauthenticated half-handshake cannot create an unbounded memory queue.
-    private static let maxDeferredPacketsPerPeer = 4
-    private static let maxDeferredPacketsGlobal = 32
-    /// One legacy sender can immediately follow message 3 with the largest
-    /// valid private-file ciphertext and has no application-level retry. Keep
-    /// room for that packet plus a small control-message budget.
-    private static let maxDeferredBytes =
-        NoiseSecurityConstants.maxPrivateFileCiphertextSize + 256 * 1024
-    private static let deferredLifetime =
-        NoiseSecurityConstants.ordinaryResponderHandshakeTimeout
-
     private let environment: BLENoisePacketHandlerEnvironment
-    private let deferredLock = NSLock()
-    private var deferredCiphertexts: [PeerID: [DeferredCiphertext]] = [:]
-    private var deferredCiphertextBytes = 0
 
     init(environment: BLENoisePacketHandlerEnvironment) {
         self.environment = environment
     }
 
     /// Returns true when the handshake message was processed successfully.
-    /// Callers use this to distinguish an authenticated reconnect completion
-    /// from a rejected ordinary responder while rollback state is restored.
+    /// Callers use this to distinguish an authenticated replacement completion
+    /// from a rejected candidate while an older session remains established.
     @discardableResult
     func handleHandshake(_ packet: BitchatPacket, from peerID: PeerID) -> Bool {
         handleHandshakeWithResult(packet, from: peerID).processed
@@ -129,23 +93,15 @@ final class BLENoisePacketHandler {
                     env.broadcastPacket(responsePacket)
                 }
 
-                // The serialized authentication callback installs transport
-                // state before it drains any bounded early ciphertext.
+                // Session establishment will trigger onPeerAuthenticated callback
+                // which will send any pending messages at the right time
                 return BLENoiseHandshakeHandlingResult(
                     processed: true,
                     didEstablishAuthenticatedSession:
                         result.didEstablishAuthenticatedSession
                 )
-            } catch let managedFailure as NoiseManagedHandshakeFailure {
-                SecureLogger.error(
-                    "Failed to process handshake; manager owns recovery: \(managedFailure.underlying)"
-                )
-                return BLENoiseHandshakeHandlingResult(
-                    processed: false,
-                    didEstablishAuthenticatedSession: false
-                )
             } catch NoiseSessionError.peerIdentityMismatch {
-                // The responder was already discarded by the session manager.
+                // The candidate was already discarded by the session manager.
                 // Do not let a spoofed claimed ID trigger a fresh outbound
                 // handshake or recreate state for the attacker-selected ID.
                 SecureLogger.warning(
@@ -175,30 +131,6 @@ final class BLENoisePacketHandler {
     }
 
     func handleEncrypted(_ packet: BitchatPacket, from peerID: PeerID) {
-        handleEncrypted(packet, from: peerID, isDeferredRetry: false)
-    }
-
-    /// Called by the transport's serialized authentication callback after it
-    /// has installed state for the promoted or restored session generation.
-    func handleSessionAuthenticated(_ peerID: PeerID) {
-        drainDeferredCiphertextsIfReady(for: peerID)
-    }
-
-    /// Synchronously discards ciphertext retained for a pre-panic Noise
-    /// generation. The handler survives the service's identity replacement,
-    /// so keeping this queue would replay old bytes after post-panic auth.
-    func resetForPanic() {
-        deferredLock.lock()
-        deferredCiphertexts.removeAll(keepingCapacity: false)
-        deferredCiphertextBytes = 0
-        deferredLock.unlock()
-    }
-
-    private func handleEncrypted(
-        _ packet: BitchatPacket,
-        from peerID: PeerID,
-        isDeferredRetry: Bool
-    ) {
         let env = environment
         guard let recipientID = PeerID(hexData: packet.recipientID) else {
             SecureLogger.warning("⚠️ Encrypted message has no recipient ID", category: .session)
@@ -214,231 +146,35 @@ final class BLENoisePacketHandler {
         env.updatePeerLastSeen(peerID)
 
         do {
-            let decryption = try env.decrypt(packet.payload, peerID)
-            let decrypted = decryption.plaintext
+            let decrypted = try env.decrypt(packet.payload, peerID)
             guard decrypted.count > 0 else { return }
 
             // First byte indicates the payload type
             let payloadType = decrypted[0]
             let payloadData = decrypted.dropFirst()
 
-            guard let noisePayloadType = NoisePayloadType.decoded(rawValue: payloadType) else {
+            guard let noisePayloadType = NoisePayloadType(rawValue: payloadType) else {
                 SecureLogger.warning("⚠️ Unknown noise payload type: \(payloadType)")
                 return
             }
 
             SecureLogger.debug("🔐 Decrypted noise payload type \(noisePayloadType.description) from \(peerID.id.prefix(8))…", category: .session)
 
-            if noisePayloadType == .authenticatedPeerState {
-                env.handleAuthenticatedPeerState(
-                    peerID,
-                    Data(payloadData),
-                    decryption.sessionGeneration
-                )
-                return
-            }
-
             let ts = Date(timeIntervalSince1970: Double(packet.timestamp) / 1000)
             env.deliverNoisePayload(peerID, noisePayloadType, Data(payloadData), ts)
-        } catch NoiseEncryptionError.transportGenerationNotReady {
-            if isDeferredRetry {
-                SecureLogger.warning(
-                    "Dropping deferred Noise ciphertext from \(peerID.id.prefix(8))… because its authenticated transport generation changed again",
-                    category: .session
-                )
-                return
-            }
-            // The manager promoted or restored keys before BLE's serialized
-            // callback installed generation-bound transport state. The
-            // manager rejected this before decrypting, so replay is safe.
-            deferCiphertext(packet, from: peerID)
         } catch NoiseEncryptionError.sessionNotEstablished {
-            if isDeferredRetry {
-                SecureLogger.warning(
-                    "Dropping deferred Noise ciphertext from \(peerID.id.prefix(8))… because the authenticated session is unavailable",
-                    category: .session
-                )
-                return
-            }
             // We received an encrypted message before establishing a session with this peer.
-            // An initiator may already have sent message 3 followed by this
-            // ciphertext, with BLE delivering the ciphertext first.
-            if env.isAwaitingResponderHandshakeCompletion(peerID) {
-                deferCiphertext(packet, from: peerID)
-                return
-            }
-            // Otherwise trigger a handshake so future messages can decrypt.
+            // Trigger a handshake so future messages can be decrypted.
             SecureLogger.debug("🔑 Encrypted message from \(peerID.id.prefix(8))… without session; initiating handshake")
             if !env.hasNoiseSession(peerID) {
                 env.initiateHandshake(peerID)
             }
         } catch {
-            if isDeferredRetry {
-                // An early packet cannot tear down the authenticated session
-                // merely because its single bounded retry still fails.
-                SecureLogger.warning(
-                    "Dropping deferred Noise ciphertext from \(peerID.id.prefix(8))… after retry failed: \(error)",
-                    category: .session
-                )
-                return
-            }
-            // A responder may retain an older transport as receive-only
-            // rollback state while ordinary XX waits for message 3. New-key
-            // ciphertext can fail against those retained receive keys first.
-            if env.isAwaitingResponderHandshakeCompletion(peerID) {
-                if isDeferrableEarlyHandshakeFailure(error) {
-                    deferCiphertext(packet, from: peerID)
-                } else {
-                    SecureLogger.warning(
-                        "Dropping invalid Noise ciphertext from \(peerID.id.prefix(8))… while responder handshake is completing: \(error)",
-                        category: .session
-                    )
-                }
-                return
-            }
-            if isDropOnlyCiphertextFailure(error) {
-                // The packet is attacker-controlled and did not prove a
-                // transport-state failure. Never let malformed, replayed,
-                // forged, oversized, or rate-limited bytes evict working keys.
-                SecureLogger.warning(
-                    "Dropping rejected Noise ciphertext from \(peerID.id.prefix(8))… without clearing its session: \(error)",
-                    category: .security
-                )
-                return
-            }
             // Decryption failed - clear the corrupted session and re-initiate handshake
-            // Only local/session lifecycle failures reach this path.
+            // This handles cases where session state got out of sync (nonce mismatch, etc.)
             SecureLogger.error("❌ Failed to decrypt message from \(peerID.id.prefix(8))…: \(error) - clearing session and re-initiating handshake")
             env.clearSession(peerID)
             env.initiateHandshake(peerID)
         }
     }
-
-    private func isDeferrableEarlyHandshakeFailure(_ error: Error) -> Bool {
-        if let noiseError = error as? NoiseError {
-            switch noiseError {
-            case .authenticationFailure, .replayDetected:
-                return true
-            default:
-                return false
-            }
-        }
-        if let cryptoError = error as? CryptoKitError,
-           case .authenticationFailure = cryptoError {
-            return true
-        }
-        return false
-    }
-
-    private func isDropOnlyCiphertextFailure(_ error: Error) -> Bool {
-        if let securityError = error as? NoiseSecurityError {
-            switch securityError {
-            case .messageTooLarge, .rateLimitExceeded, .invalidPeerID:
-                return true
-            case .sessionExpired, .sessionExhausted:
-                return false
-            }
-        }
-        if let noiseError = error as? NoiseError {
-            switch noiseError {
-            case .invalidCiphertext, .authenticationFailure, .replayDetected:
-                return true
-            case .uninitializedCipher, .handshakeComplete,
-                    .handshakeNotComplete, .missingLocalStaticKey,
-                    .missingKeys, .invalidMessage, .invalidPublicKey,
-                    .nonceExceeded:
-                return false
-            }
-        }
-        return error is CryptoKitError
-    }
-
-    private func deferCiphertext(_ packet: BitchatPacket, from peerID: PeerID) {
-        guard NoiseSecurityValidator.validatePrivateFileCiphertextSize(
-            packet.payload
-        ) else {
-            SecureLogger.warning(
-                "Dropping oversized early Noise ciphertext from \(peerID.id.prefix(8))…",
-                category: .security
-            )
-            return
-        }
-
-        let now = environment.now()
-        deferredLock.lock()
-        defer { deferredLock.unlock() }
-        purgeExpiredCiphertextsLocked(now: now)
-
-        let peerCount = deferredCiphertexts[peerID]?.count ?? 0
-        let globalCount = deferredCiphertexts.values.reduce(0) {
-            $0 + $1.count
-        }
-        guard peerCount < Self.maxDeferredPacketsPerPeer,
-              globalCount < Self.maxDeferredPacketsGlobal,
-              deferredCiphertextBytes + packet.payload.count
-                <= Self.maxDeferredBytes else {
-            SecureLogger.warning(
-                "Dropping early Noise ciphertext from \(peerID.id.prefix(8))… because the handshake buffer is full",
-                category: .security
-            )
-            return
-        }
-
-        deferredCiphertexts[peerID, default: []].append(
-            DeferredCiphertext(packet: packet, receivedAt: now)
-        )
-        deferredCiphertextBytes += packet.payload.count
-        SecureLogger.debug(
-            "Deferring early Noise ciphertext from \(peerID.id.prefix(8))… until responder handshake completion",
-            category: .session
-        )
-    }
-
-    private func drainDeferredCiphertextsIfReady(for peerID: PeerID) {
-        let env = environment
-        guard !env.isAwaitingResponderHandshakeCompletion(peerID),
-              env.hasNoiseSession(peerID) else {
-            return
-        }
-
-        let now = env.now()
-        deferredLock.lock()
-        purgeExpiredCiphertextsLocked(now: now)
-        let deferred = deferredCiphertexts.removeValue(forKey: peerID) ?? []
-        deferredCiphertextBytes -= deferred.reduce(0) {
-            $0 + $1.packet.payload.count
-        }
-        deferredLock.unlock()
-
-        guard !deferred.isEmpty else { return }
-        SecureLogger.debug(
-            "Retrying \(deferred.count) early Noise ciphertext packet(s) from \(peerID.id.prefix(8))… after handshake completion",
-            category: .session
-        )
-        for item in deferred {
-            handleEncrypted(item.packet, from: peerID, isDeferredRetry: true)
-        }
-    }
-
-    private func purgeExpiredCiphertextsLocked(now: Date) {
-        for peerID in Array(deferredCiphertexts.keys) {
-            guard let items = deferredCiphertexts[peerID] else { continue }
-            let retained = items.filter {
-                now.timeIntervalSince($0.receivedAt) <= Self.deferredLifetime
-            }
-            guard retained.count != items.count else { continue }
-
-            deferredCiphertextBytes -= items.reduce(0) {
-                $0 + $1.packet.payload.count
-            }
-            deferredCiphertextBytes += retained.reduce(0) {
-                $0 + $1.packet.payload.count
-            }
-            if retained.isEmpty {
-                deferredCiphertexts.removeValue(forKey: peerID)
-            } else {
-                deferredCiphertexts[peerID] = retained
-            }
-        }
-    }
 }

bitchat/Services/BLE/BLENoisePayloadFactory.swift

@@ -17,16 +17,6 @@ enum BLENoisePayloadFactory {
         typedPayload(.delivered, payload: Data(messageID.utf8))
     }
 
-    static func privateFile(_ filePacket: BitchatFilePacket) -> Data? {
-        guard let payload = filePacket.encode() else { return nil }
-        return typedPayload(.privateFile, payload: payload)
-    }
-
-    static func authenticatedPeerState(_ state: AuthenticatedPeerStatePacket) -> Data? {
-        guard let payload = state.encode() else { return nil }
-        return typedPayload(.authenticatedPeerState, payload: payload)
-    }
-
     static func typedPayload(_ type: NoisePayloadType, payload: Data) -> Data {
         var typed = Data([type.rawValue])
         typed.append(payload)

bitchat/Services/BLE/BLENoiseReconnectPolicy.swift

@@ -1,40 +0,0 @@
-import Foundation
-
-/// Bounds ordinary Noise revalidation to one attempt per physical-link epoch.
-/// A live epoch may retry after the cooldown so a lost handshake cannot leave
-/// the link permanently unauthenticated.
-struct BLENoiseReconnectPolicy {
-    static let minimumRetryInterval: TimeInterval = 60
-
-    private var lastAttemptAt: [BLEIngressLinkID: Date] = [:]
-
-    mutating func shouldRevalidate(
-        on link: BLEIngressLinkID,
-        hasEstablishedSession: Bool,
-        isNoiseAuthenticatedLink: Bool,
-        hasAuthenticatedPeerLink: Bool,
-        now: Date
-    ) -> Bool {
-        guard hasEstablishedSession,
-              !isNoiseAuthenticatedLink,
-              !hasAuthenticatedPeerLink else {
-            return false
-        }
-        if let previous = lastAttemptAt[link],
-           now.timeIntervalSince(previous) < Self.minimumRetryInterval {
-            return false
-        }
-        lastAttemptAt[link] = now
-        return true
-    }
-
-    /// Link identifiers can be stable across CoreBluetooth reconnects, so a
-    /// disconnect explicitly starts a new epoch and permits one fresh attempt.
-    mutating func endLinkEpoch(_ link: BLEIngressLinkID) {
-        lastAttemptAt.removeValue(forKey: link)
-    }
-
-    mutating func removeAll() {
-        lastAttemptAt.removeAll()
-    }
-}

bitchat/Services/BLE/BLENoiseSessionQueues.swift

@@ -6,16 +6,9 @@ struct BLEPendingPrivateMessage: Equatable {
     let messageID: String
 }
 
-struct BLEPendingTypedPayload: Equatable {
-    let payload: Data
-    /// Present for app-initiated media so handshake queuing preserves the
-    /// fragment scheduler's progress/cancellation identity.
-    let transferId: String?
-}
-
 struct BLENoiseSessionQueues {
     private var privateMessagesByPeerID: [PeerID: [BLEPendingPrivateMessage]] = [:]
-    private var typedPayloadsByPeerID: [PeerID: [BLEPendingTypedPayload]] = [:]
+    private var typedPayloadsByPeerID: [PeerID: [Data]] = [:]
 
     var isEmpty: Bool {
         privateMessagesByPeerID.isEmpty && typedPayloadsByPeerID.isEmpty
@@ -41,35 +34,13 @@ struct BLENoiseSessionQueues {
         privateMessagesByPeerID[peerID, default: []].insert(contentsOf: messages, at: 0)
     }
 
-    mutating func appendTypedPayload(_ payload: Data, transferId: String? = nil, for peerID: PeerID) {
-        typedPayloadsByPeerID[peerID, default: []].append(
-            BLEPendingTypedPayload(payload: payload, transferId: transferId)
-        )
+    mutating func appendTypedPayload(_ payload: Data, for peerID: PeerID) {
+        typedPayloadsByPeerID[peerID, default: []].append(payload)
     }
 
-    mutating func takeTypedPayloads(for peerID: PeerID) -> [BLEPendingTypedPayload] {
+    mutating func takeTypedPayloads(for peerID: PeerID) -> [Data] {
         let payloads = typedPayloadsByPeerID[peerID] ?? []
         typedPayloadsByPeerID.removeValue(forKey: peerID)
         return payloads
     }
-
-    func containsTypedPayload(transferId: String) -> Bool {
-        typedPayloadsByPeerID.values.contains { payloads in
-            payloads.contains { $0.transferId == transferId }
-        }
-    }
-
-    @discardableResult
-    mutating func removeTypedPayload(transferId: String) -> Bool {
-        for peerID in Array(typedPayloadsByPeerID.keys) {
-            guard var payloads = typedPayloadsByPeerID[peerID],
-                  let index = payloads.firstIndex(where: { $0.transferId == transferId }) else {
-                continue
-            }
-            payloads.remove(at: index)
-            typedPayloadsByPeerID[peerID] = payloads.isEmpty ? nil : payloads
-            return true
-        }
-        return false
-    }
 }

bitchat/Services/BLE/BLEOutboundFragmentPlanner.swift

@@ -17,9 +17,6 @@ struct BLEOutboundFragmentPlan {
 }
 
 enum BLEOutboundFragmentPlanner {
-    /// Current Android receivers reject fragment sets above 256. Private
-    /// media v1 treats that deployed ceiling as a cross-platform contract.
-    static let privateMediaV1MaxFragments = 256
     private static let minimumChunkSize = 64
     private static let fragmentIDLength = 8
 
@@ -74,10 +71,6 @@ enum BLEOutboundFragmentPlanner {
         )
     }
 
-    static func isPrivateMediaV1Compatible(_ plan: BLEOutboundFragmentPlan) -> Bool {
-        plan.totalFragments <= privateMediaV1MaxFragments
-    }
-
     private static func sizingPolicy(
         for packet: BitchatPacket,
         requestedMaxChunk: Int?,

bitchat/Services/BLE/BLEOutboundFragmentTransferScheduler.swift

@@ -29,9 +29,8 @@ struct BLEOutboundFragmentTransferRequest {
     }
 
     var resolvedTransferId: String? {
-        if let transferId { return transferId }
         guard packet.type == MessageType.fileTransfer.rawValue else { return nil }
-        return packet.payload.sha256Hex()
+        return transferId ?? packet.payload.sha256Hex()
     }
 
     /// Content identity independent of the caller-chosen transfer ID: the

bitchat/Services/BLE/BLEPeerRegistry.swift

@@ -10,9 +10,6 @@ struct BLEPeerInfo: Equatable {
     var isVerifiedNickname: Bool
     var lastSeen: Date
     var capabilities: PeerCapabilities = []
-    /// Distinguishes an old client that omitted the capabilities TLV from a
-    /// modern client that explicitly advertised a set without a given bit.
-    var capabilitiesWereExplicitlyAdvertised: Bool = false
     /// Rendezvous cell from the peer's announce when it advertises `.bridge`.
     var bridgeGeohash: String?
 }
@@ -117,10 +114,6 @@ struct BLEPeerRegistry {
         peers[peerID.toShort()]?.capabilities ?? []
     }
 
-    func capabilitiesWereExplicitlyAdvertised(for peerID: PeerID) -> Bool {
-        peers[peerID.toShort()]?.capabilitiesWereExplicitlyAdvertised == true
-    }
-
     /// Peers whose last verified announce advertised the given capability.
     func peers(advertising capability: PeerCapabilities) -> [PeerID] {
         peers.values.filter { $0.capabilities.contains(capability) }.map(\.peerID)
@@ -181,14 +174,6 @@ struct BLEPeerRegistry {
         peers[peerID] = peer
     }
 
-    /// Replaces the announcement signing key only after the surrounding Noise
-    /// session proved possession of this peer's static key.
-    mutating func bindAuthenticatedSigningPublicKey(_ key: Data, for peerID: PeerID) {
-        guard var peer = peers[peerID.toShort()] else { return }
-        peer.signingPublicKey = key
-        peers[peer.peerID] = peer
-    }
-
     mutating func upsertVerifiedAnnounce(
         peerID: PeerID,
         nickname: String,
@@ -196,7 +181,7 @@ struct BLEPeerRegistry {
         signingPublicKey: Data?,
         isConnected: Bool,
         now: Date,
-        capabilities: PeerCapabilities? = nil,
+        capabilities: PeerCapabilities = [],
         bridgeGeohash: String? = nil
     ) -> BLEPeerAnnounceUpdate {
         let existing = peers[peerID]
@@ -214,8 +199,7 @@ struct BLEPeerRegistry {
             signingPublicKey: signingPublicKey,
             isVerifiedNickname: true,
             lastSeen: now,
-            capabilities: capabilities ?? [],
-            capabilitiesWereExplicitlyAdvertised: capabilities != nil,
+            capabilities: capabilities,
             bridgeGeohash: bridgeGeohash
         )
 

bitchat/Services/BLE/BLEPrivateMediaReceiptStore.swift

@@ -1,556 +0,0 @@
-import BitLogger
-import Foundation
-
-enum BLEPrivateMediaReceiptState: Equatable {
-    /// No durable receiver decision exists for this stable message ID.
-    case absent
-    /// The payload is durably mapped to a file that still exists.
-    case accepted(URL)
-    /// The user explicitly deleted the payload; retries must not resurrect it.
-    case tombstoned
-    /// Durable state could not be read safely. Callers must fail closed and
-    /// must not save, deliver, or acknowledge the payload.
-    case unavailable
-}
-
-/// Durable, per-message receiver decisions for stable private media.
-///
-/// Each ID has its own atomic record so one hot lookup never rewrites or
-/// decodes the entire ledger. The process-lifetime index is installed only
-/// after a complete, successful directory scan. An enumeration, read, decode,
-/// or structural-validation failure therefore remains retryable and cannot be
-/// mistaken for an empty ledger.
-final class BLEPrivateMediaReceiptStore: @unchecked Sendable {
-    typealias DirectoryReader = (_ directory: URL) throws -> [URL]
-    typealias DataReader = (_ url: URL) throws -> Data
-    private static let receiptDirectoryName = ".private-media-receipts"
-
-    private struct ReceiptRecord: Codable, Equatable {
-        enum Kind: String, Codable {
-            case accepted
-            case tombstone
-        }
-
-        let kind: Kind
-        /// Path below the app's `files/` root. Absolute application-container
-        /// prefixes are not stable across updates, restores, or reinstalls.
-        let relativePath: String?
-        let recordedAt: Date
-    }
-
-    private final class Runtime: @unchecked Sendable {
-        let lock = NSLock()
-        var records: [String: ReceiptRecord]?
-        var volatileTombstones: [String: Date] = [:]
-    }
-
-    private let fileManager: FileManager
-    private let baseDirectory: URL?
-    private let capacity: Int
-    private let ttl: TimeInterval
-    private let now: () -> Date
-    private let directoryReader: DirectoryReader?
-    private let dataReader: DataReader?
-    private let runtime = Runtime()
-
-    init(
-        fileManager: FileManager = .default,
-        baseDirectory: URL? = nil,
-        capacity: Int = TransportConfig.privateMediaReceivedLedgerCapacity,
-        ttl: TimeInterval = TransportConfig.privateMediaReceivedLedgerTTLSeconds,
-        now: @escaping () -> Date = Date.init,
-        directoryReader: DirectoryReader? = nil,
-        dataReader: DataReader? = nil
-    ) {
-        self.fileManager = fileManager
-        self.baseDirectory = baseDirectory
-        self.capacity = max(1, capacity)
-        self.ttl = max(0, ttl)
-        self.now = now
-        self.directoryReader = directoryReader
-        self.dataReader = dataReader
-    }
-
-    /// Drops process-lifetime decisions after the enclosing media directory
-    /// has been panic-wiped. A later lookup must rebuild from the durable
-    /// ledger instead of retaining an accepted receipt or tombstone whose
-    /// backing files no longer exist.
-    func resetForPanic() {
-        runtime.lock.lock()
-        runtime.records = nil
-        runtime.volatileTombstones.removeAll(keepingCapacity: false)
-        runtime.lock.unlock()
-    }
-
-    func state(for messageID: String) -> BLEPrivateMediaReceiptState {
-        guard PrivateMediaMessageIdentity.isStableID(messageID) else {
-            return .absent
-        }
-
-        runtime.lock.lock()
-        defer { runtime.lock.unlock() }
-
-        let date = now()
-        if let tombstonedAt = runtime.volatileTombstones[messageID] {
-            if !isExpired(tombstonedAt, at: date) {
-                return .tombstoned
-            }
-            runtime.volatileTombstones.removeValue(forKey: messageID)
-        }
-
-        guard let directory = resolvedReceiptDirectory(),
-              var records = loadIndexIfNeeded(from: directory, at: date) else {
-            return .unavailable
-        }
-        guard let record = records[messageID] else { return .absent }
-
-        if isExpired(record.recordedAt, at: date) {
-            records.removeValue(forKey: messageID)
-            runtime.records = records
-            removeRecord(messageID: messageID, from: directory)
-            return .absent
-        }
-
-        switch record.kind {
-        case .tombstone:
-            removePayloadRecordedByTombstone(record)
-            return .tombstoned
-
-        case .accepted:
-            guard let relativePath = record.relativePath,
-                  let existingURL = existingPayload(relativePath: relativePath) else {
-                // Quota cleanup is not explicit deletion. Remove the stale
-                // receipt so a sender retry can restore the payload and bubble.
-                records.removeValue(forKey: messageID)
-                runtime.records = records
-                removeRecord(messageID: messageID, from: directory)
-                return .absent
-            }
-            return .accepted(existingURL)
-        }
-    }
-
-    /// Records an accepted ID only after the payload is on disk. Callers must
-    /// roll the payload back and withhold UI delivery/ACK when this returns
-    /// false.
-    func commitAccepted(messageID: String, storedURL: URL) -> Bool {
-        guard PrivateMediaMessageIdentity.isStableID(messageID),
-              validExistingPayload(storedURL) != nil,
-              let relativePath = relativePath(for: storedURL) else {
-            return false
-        }
-
-        runtime.lock.lock()
-        defer { runtime.lock.unlock() }
-
-        let date = now()
-        if let tombstonedAt = runtime.volatileTombstones[messageID],
-           !isExpired(tombstonedAt, at: date) {
-            return false
-        }
-
-        guard let directory = resolvedReceiptDirectory(),
-              var records = loadIndexIfNeeded(from: directory, at: date) else {
-            return false
-        }
-        if let existing = records[messageID],
-           existing.kind == .tombstone,
-           !isExpired(existing.recordedAt, at: date) {
-            return false
-        }
-
-        let victim = capacityVictim(
-            for: .accepted,
-            replacing: messageID,
-            in: records
-        )
-        if records[messageID]?.kind != .accepted,
-           records.values.lazy.filter({ $0.kind == .accepted }).count >= capacity,
-           victim == nil {
-            return false
-        }
-
-        let record = ReceiptRecord(
-            kind: .accepted,
-            relativePath: relativePath,
-            recordedAt: date
-        )
-        guard persist(record, messageID: messageID, to: directory) else {
-            return false
-        }
-
-        records[messageID] = record
-        if let victim, victim != messageID {
-            records.removeValue(forKey: victim)
-            removeRecord(messageID: victim, from: directory)
-        }
-        runtime.records = records
-        return true
-    }
-
-    /// Foundation for explicit media deletion. This branch does not wire the
-    /// chat-clear UI; it only makes a tombstone durable and fail closed.
-    func recordDeleted(messageID: String) -> Bool {
-        guard PrivateMediaMessageIdentity.isStableID(messageID) else {
-            return false
-        }
-
-        runtime.lock.lock()
-        defer { runtime.lock.unlock() }
-
-        let date = now()
-        addVolatileTombstone(messageID, at: date)
-
-        guard let directory = resolvedReceiptDirectory(),
-              var records = loadIndexIfNeeded(from: directory, at: date) else {
-            runtime.volatileTombstones.removeValue(forKey: messageID)
-            return false
-        }
-        if let existing = records[messageID],
-           existing.kind == .tombstone,
-           !isExpired(existing.recordedAt, at: date) {
-            runtime.volatileTombstones.removeValue(forKey: messageID)
-            removePayloadRecordedByTombstone(existing)
-            return true
-        }
-
-        let victim = capacityVictim(
-            for: .tombstone,
-            replacing: messageID,
-            in: records
-        )
-        if records[messageID]?.kind != .tombstone,
-           records.values.lazy.filter({ $0.kind == .tombstone }).count >= capacity,
-           victim == nil {
-            runtime.volatileTombstones.removeValue(forKey: messageID)
-            return false
-        }
-
-        let tombstone = ReceiptRecord(
-            kind: .tombstone,
-            // Retain the accepted path so a crash between the atomic record
-            // write and payload unlink can finish cleanup after relaunch.
-            relativePath: records[messageID]?.relativePath,
-            recordedAt: date
-        )
-        guard persist(tombstone, messageID: messageID, to: directory) else {
-            runtime.volatileTombstones.removeValue(forKey: messageID)
-            return false
-        }
-
-        records[messageID] = tombstone
-        if let victim, victim != messageID {
-            records.removeValue(forKey: victim)
-            removeRecord(messageID: victim, from: directory)
-        }
-        runtime.records = records
-        runtime.volatileTombstones.removeValue(forKey: messageID)
-        removePayloadRecordedByTombstone(tombstone)
-        return true
-    }
-
-    private func loadIndexIfNeeded(
-        from directory: URL,
-        at date: Date
-    ) -> [String: ReceiptRecord]? {
-        if let records = runtime.records {
-            return records
-        }
-
-        do {
-            try fileManager.createDirectory(
-                at: directory,
-                withIntermediateDirectories: true,
-                attributes: nil
-            )
-        } catch {
-            SecureLogger.error(
-                "❌ Failed to create private-media receipt directory: \(error)",
-                category: .session
-            )
-            return nil
-        }
-
-        let urls: [URL]
-        do {
-            if let directoryReader {
-                urls = try directoryReader(directory)
-            } else {
-                urls = try fileManager.contentsOfDirectory(
-                    at: directory,
-                    includingPropertiesForKeys: nil,
-                    options: []
-                )
-            }
-        } catch {
-            SecureLogger.error(
-                "❌ Failed to enumerate private-media receipts: \(error)",
-                category: .session
-            )
-            return nil
-        }
-
-        var records: [String: ReceiptRecord] = [:]
-        var expired: [String] = []
-        var tombstones: [ReceiptRecord] = []
-        for url in urls {
-            guard url.pathExtension == "json" else { continue }
-            let messageID = url.deletingPathExtension().lastPathComponent
-            guard PrivateMediaMessageIdentity.isStableID(messageID) else {
-                continue
-            }
-
-            let record: ReceiptRecord
-            do {
-                let data = try dataReader?(url) ?? Data(contentsOf: url)
-                record = try JSONDecoder().decode(ReceiptRecord.self, from: data)
-            } catch {
-                // Never delete or skip an unreadable stable-ID record. Treating
-                // it as absent could resurrect accepted or deleted media.
-                SecureLogger.error(
-                    "❌ Failed to read private-media receipt \(messageID.prefix(12))…: \(error)",
-                    category: .session
-                )
-                return nil
-            }
-
-            guard isStructurallyValid(record) else {
-                SecureLogger.error(
-                    "❌ Invalid private-media receipt \(messageID.prefix(12))…",
-                    category: .session
-                )
-                return nil
-            }
-            if isExpired(record.recordedAt, at: date) {
-                expired.append(messageID)
-                continue
-            }
-            records[messageID] = record
-            if record.kind == .tombstone {
-                tombstones.append(record)
-            }
-        }
-
-        let overflow = overflowVictims(in: records)
-        for messageID in overflow {
-            records.removeValue(forKey: messageID)
-        }
-
-        // Install the index only after every stable-ID record was read and
-        // validated successfully. Cleanup cannot influence a failed scan.
-        runtime.records = records
-
-        for messageID in expired + overflow {
-            removeRecord(messageID: messageID, from: directory)
-        }
-        for tombstone in tombstones {
-            removePayloadRecordedByTombstone(tombstone)
-        }
-        return records
-    }
-
-    private func isStructurallyValid(_ record: ReceiptRecord) -> Bool {
-        switch record.kind {
-        case .tombstone:
-            guard let relativePath = record.relativePath else { return true }
-            return candidatePayload(relativePath: relativePath) != nil
-        case .accepted:
-            guard let relativePath = record.relativePath else { return false }
-            return candidatePayload(relativePath: relativePath) != nil
-        }
-    }
-
-    private func isExpired(_ recordedAt: Date, at date: Date) -> Bool {
-        date.timeIntervalSince(recordedAt) > ttl
-    }
-
-    private func overflowVictims(
-        in records: [String: ReceiptRecord]
-    ) -> [String] {
-        var victims: [String] = []
-        for kind in [ReceiptRecord.Kind.accepted, .tombstone] {
-            let matching = records.filter { $0.value.kind == kind }
-            let overflow = matching.count - capacity
-            guard overflow > 0 else { continue }
-            victims.append(contentsOf: matching.sorted { lhs, rhs in
-                if lhs.value.recordedAt == rhs.value.recordedAt {
-                    return lhs.key < rhs.key
-                }
-                return lhs.value.recordedAt < rhs.value.recordedAt
-            }
-            .prefix(overflow)
-            .map(\.key))
-        }
-        return victims
-    }
-
-    /// Accepted receipts and tombstones have independent capacity. High media
-    /// volume cannot evict explicit deletion intent, and vice versa.
-    private func capacityVictim(
-        for incomingKind: ReceiptRecord.Kind,
-        replacing messageID: String,
-        in records: [String: ReceiptRecord]
-    ) -> String? {
-        guard records[messageID]?.kind != incomingKind else { return nil }
-        let matching = records.filter {
-            $0.key != messageID && $0.value.kind == incomingKind
-        }
-        guard matching.count >= capacity else { return nil }
-        return matching.min { lhs, rhs in
-            if lhs.value.recordedAt == rhs.value.recordedAt {
-                return lhs.key < rhs.key
-            }
-            return lhs.value.recordedAt < rhs.value.recordedAt
-        }?.key
-    }
-
-    private func persist(
-        _ record: ReceiptRecord,
-        messageID: String,
-        to directory: URL
-    ) -> Bool {
-        do {
-            try fileManager.createDirectory(
-                at: directory,
-                withIntermediateDirectories: true,
-                attributes: nil
-            )
-            let data = try JSONEncoder().encode(record)
-            var options: Data.WritingOptions = [.atomic]
-            #if os(iOS)
-            options.insert(.completeFileProtectionUntilFirstUserAuthentication)
-            #endif
-            let url = recordURL(messageID: messageID, in: directory)
-            try data.write(to: url, options: options)
-            return true
-        } catch {
-            SecureLogger.error(
-                "❌ Failed to persist private-media receipt \(messageID.prefix(12))…: \(error)",
-                category: .session
-            )
-            return false
-        }
-    }
-
-    private func removeRecord(messageID: String, from directory: URL) {
-        let url = recordURL(messageID: messageID, in: directory)
-        guard fileManager.fileExists(atPath: url.path) else { return }
-        do {
-            try fileManager.removeItem(at: url)
-        } catch {
-            SecureLogger.warning(
-                "⚠️ Failed to prune private-media receipt \(messageID.prefix(12))…: \(error)",
-                category: .session
-            )
-        }
-    }
-
-    private func recordURL(messageID: String, in directory: URL) -> URL {
-        directory
-            .appendingPathComponent(messageID, isDirectory: false)
-            .appendingPathExtension("json")
-    }
-
-    private func removePayloadRecordedByTombstone(_ record: ReceiptRecord) {
-        guard record.kind == .tombstone,
-              let relativePath = record.relativePath,
-              let payload = candidatePayload(relativePath: relativePath),
-              fileManager.fileExists(atPath: payload.path) else {
-            return
-        }
-        do {
-            try fileManager.removeItem(at: payload)
-        } catch {
-            SecureLogger.warning(
-                "⚠️ Failed to remove explicitly deleted private media: \(error)",
-                category: .session
-            )
-        }
-    }
-
-    private func addVolatileTombstone(_ messageID: String, at date: Date) {
-        runtime.volatileTombstones[messageID] = date
-        let overflow = runtime.volatileTombstones.count - capacity
-        guard overflow > 0 else { return }
-        let oldest = runtime.volatileTombstones.sorted {
-            if $0.value == $1.value { return $0.key < $1.key }
-            return $0.value < $1.value
-        }
-        for (oldMessageID, _) in oldest.prefix(overflow) {
-            runtime.volatileTombstones.removeValue(forKey: oldMessageID)
-        }
-    }
-
-    private func validExistingPayload(_ url: URL) -> URL? {
-        let standardized = url.standardizedFileURL
-        guard isInsideFilesDirectory(standardized) else { return nil }
-        var isDirectory: ObjCBool = false
-        guard fileManager.fileExists(
-            atPath: standardized.path,
-            isDirectory: &isDirectory
-        ), !isDirectory.boolValue else {
-            return nil
-        }
-        return standardized
-    }
-
-    private func relativePath(for url: URL) -> String? {
-        guard let filesRoot = try? filesDirectory().standardizedFileURL else {
-            return nil
-        }
-        let prefix = filesRoot.path + "/"
-        let standardized = url.standardizedFileURL
-        guard standardized.path.hasPrefix(prefix) else { return nil }
-        let relativePath = String(standardized.path.dropFirst(prefix.count))
-        return relativePath.isEmpty ? nil : relativePath
-    }
-
-    private func existingPayload(relativePath: String) -> URL? {
-        guard let candidate = candidatePayload(relativePath: relativePath) else {
-            return nil
-        }
-        return validExistingPayload(candidate)
-    }
-
-    private func candidatePayload(relativePath: String) -> URL? {
-        guard !relativePath.isEmpty,
-              let filesRoot = try? filesDirectory().standardizedFileURL else {
-            return nil
-        }
-        let candidate = filesRoot
-            .appendingPathComponent(relativePath, isDirectory: false)
-            .standardizedFileURL
-        guard candidate.path.hasPrefix(filesRoot.path + "/") else { return nil }
-        return candidate
-    }
-
-    private func isInsideFilesDirectory(_ url: URL) -> Bool {
-        guard let filesRoot = try? filesDirectory().standardizedFileURL else {
-            return false
-        }
-        return url.standardizedFileURL.path.hasPrefix(filesRoot.path + "/")
-    }
-
-    private func resolvedReceiptDirectory() -> URL? {
-        return try? filesDirectory().appendingPathComponent(
-            Self.receiptDirectoryName,
-            isDirectory: true
-        )
-    }
-
-    private func filesDirectory() throws -> URL {
-        let root = try baseDirectory ?? fileManager.url(
-            for: .applicationSupportDirectory,
-            in: .userDomainMask,
-            appropriateFor: nil,
-            create: true
-        )
-        let files = root.appendingPathComponent("files", isDirectory: true)
-        try fileManager.createDirectory(
-            at: files,
-            withIntermediateDirectories: true,
-            attributes: nil
-        )
-        return files
-    }
-}

bitchat/Services/NoiseEncryptionService.swift

@@ -165,6 +165,7 @@ final class NoiseEncryptionService {
     // Peer fingerprints (SHA256 hash of static public key)
     private var peerFingerprints: [PeerID: String] = [:]
     private var fingerprintToPeerID: [String: PeerID] = [:]
+    
     // Thread safety
     private let serviceQueue = DispatchQueue(label: "chat.bitchat.noise.service", attributes: .concurrent)
     
@@ -182,24 +183,12 @@ final class NoiseEncryptionService {
     
     // Callbacks
     private var onPeerAuthenticatedHandlers: [((PeerID, String) -> Void)] = [] // Array of handlers for peer authentication
-    private var onPeerAuthenticatedWithGenerationHandlers: [((PeerID, String, UUID) -> Void)] = []
     var onHandshakeRequired: ((PeerID) -> Void)? // peerID needs handshake
-    /// Automatic rekey prepared XX message 1. The transport must claim the
-    /// exact attempt at its actual BLE handoff; a crossed inbound initiation
-    /// can invalidate the token before that point.
-    var onRekeyHandshakeReady:
-        ((_ peerID: PeerID, _ initiation: NoiseHandshakeInitiation) -> Void)?
-    var onHandshakeRecoveryRequired:
-        ((_ request: NoiseHandshakeRecoveryRequest) -> Void)?
-    /// An unauthenticated reconnect attempt failed or timed out and the
-    /// receive-only rollback session became the active transport again.
-    /// Transport queues must be drained for this exact restored generation.
-    var onSessionRestoredWithGeneration: ((_ peerID: PeerID, _ generation: UUID) -> Void)?
     
     // Add a handler for peer authentication
     func addOnPeerAuthenticatedHandler(_ handler: @escaping (PeerID, String) -> Void) {
-        serviceQueue.sync(flags: .barrier) {
-            onPeerAuthenticatedHandlers.append(handler)
+        serviceQueue.async(flags: .barrier) { [weak self] in
+            self?.onPeerAuthenticatedHandlers.append(handler)
         }
     }
     
@@ -213,29 +202,7 @@ final class NoiseEncryptionService {
         }
     }
     
-    /// Generation-aware authentication notifications are used by protocols
-    /// whose state must be bound to one exact Noise transport session.
-    var onPeerAuthenticatedWithGeneration: ((PeerID, String, UUID) -> Void)? {
-        get { nil }
-        set {
-            guard let handler = newValue else { return }
-            serviceQueue.sync(flags: .barrier) {
-                onPeerAuthenticatedWithGenerationHandlers.append(handler)
-            }
-        }
-    }
-    
-    init(
-        keychain: KeychainManagerProtocol,
-        ordinaryHandshakeTimeout: TimeInterval =
-            NoiseSecurityConstants.ordinaryHandshakeTimeout,
-        ordinaryResponderHandshakeTimeout: TimeInterval =
-            NoiseSecurityConstants.ordinaryResponderHandshakeTimeout,
-        recentInitiatorCompletionGracePeriod: TimeInterval =
-            NoiseSecurityConstants.recentInitiatorCompletionGracePeriod,
-        ordinaryReconnectRollbackCooldown: TimeInterval =
-            NoiseSecurityConstants.ordinaryReconnectRollbackCooldown
-    ) {
+    init(keychain: KeychainManagerProtocol) {
         self.keychain = keychain
         self.localPrekeys = LocalPrekeyStore(keychain: keychain)
 
@@ -325,31 +292,11 @@ final class NoiseEncryptionService {
         self.signingPublicKey = signingKey.publicKey
 
         // Initialize session manager
-        self.sessionManager = NoiseSessionManager(
-            localStaticKey: staticIdentityKey,
-            keychain: keychain,
-            ordinaryHandshakeTimeout: ordinaryHandshakeTimeout,
-            ordinaryResponderHandshakeTimeout:
-                ordinaryResponderHandshakeTimeout,
-            recentInitiatorCompletionGracePeriod:
-                recentInitiatorCompletionGracePeriod,
-            ordinaryReconnectRollbackCooldown:
-                ordinaryReconnectRollbackCooldown
-        )
+        self.sessionManager = NoiseSessionManager(localStaticKey: staticIdentityKey, keychain: keychain)
 
         // Set up session callbacks
-        sessionManager.onSessionEstablished = { [weak self] peerID, remoteStaticKey, generation in
-            self?.handleSessionEstablished(
-                peerID: peerID,
-                remoteStaticKey: remoteStaticKey,
-                sessionGeneration: generation
-            )
-        }
-        sessionManager.onSessionRestored = { [weak self] peerID, generation in
-            self?.onSessionRestoredWithGeneration?(peerID, generation)
-        }
-        sessionManager.onHandshakeRecoveryRequired = { [weak self] request in
-            self?.onHandshakeRecoveryRequired?(request)
+        sessionManager.onSessionEstablished = { [weak self] peerID, remoteStaticKey in
+            self?.handleSessionEstablished(peerID: peerID, remoteStaticKey: remoteStaticKey)
         }
 
         // Start session maintenance timer
@@ -715,90 +662,6 @@ final class NoiseEncryptionService {
         return handshakeData
     }
     
-    /// Atomically admits and prepares one initial ordinary handshake. Returns
-    /// nil when another discovery callback already created a session.
-    func initiateHandshakeIfNeeded(
-        with peerID: PeerID,
-        retryOnTimeout: Bool = false
-    ) throws -> NoiseHandshakeInitiation? {
-        guard peerID.isValid else {
-            SecureLogger.warning(.authenticationFailed(peerID: peerID.id))
-            throw NoiseSecurityError.invalidPeerID
-        }
-
-        guard let initiation = try sessionManager.initiateHandshakeIfAbsent(
-            with: peerID,
-            notifyOnTimeout: retryOnTimeout,
-            authorize: { [rateLimiter] in
-                guard rateLimiter.allowHandshake(from: peerID) else {
-                    SecureLogger.warning(
-                        .authenticationFailed(peerID: "Rate limited: \(peerID)")
-                    )
-                    throw NoiseSecurityError.rateLimitExceeded
-                }
-            }
-        ) else {
-            return nil
-        }
-        SecureLogger.info(.handshakeStarted(peerID: peerID.id))
-        return initiation
-    }
-
-    /// Atomically prepares an ordinary reconnect for a peer whose cached
-    /// transport belongs to an earlier physical link. Failed authorization or
-    /// handshake setup preserves the established session.
-    func initiateReconnectHandshake(
-        with peerID: PeerID,
-        retryOnTimeout: Bool = false
-    ) throws -> NoiseHandshakeInitiation {
-        guard peerID.isValid else {
-            SecureLogger.warning(.authenticationFailed(peerID: peerID.id))
-            throw NoiseSecurityError.invalidPeerID
-        }
-
-        return try sessionManager.initiateReconnectHandshake(
-            with: peerID,
-            notifyOnTimeout: retryOnTimeout,
-            authorize: { [rateLimiter] in
-                guard rateLimiter.allowHandshake(from: peerID) else {
-                    SecureLogger.warning(
-                        .authenticationFailed(peerID: "Rate limited: \(peerID)")
-                    )
-                    throw NoiseSecurityError.rateLimitExceeded
-                }
-            }
-        )
-    }
-
-    func prepareHandshakeRecovery(
-        _ request: NoiseHandshakeRecoveryRequest
-    ) throws -> NoiseHandshakeRecoveryPreparation? {
-        try sessionManager.prepareHandshakeRecovery(
-            request,
-            authorizeAttempt: { [rateLimiter] in
-                guard rateLimiter.allowHandshake(from: request.peerID) else {
-                    SecureLogger.warning(
-                        .authenticationFailed(
-                            peerID: "Rate limited: \(request.peerID)"
-                        )
-                    )
-                    throw NoiseSecurityError.rateLimitExceeded
-                }
-            }
-        )
-    }
-
-    func cancelHandshakeRecovery(_ request: NoiseHandshakeRecoveryRequest) {
-        sessionManager.cancelHandshakeRecovery(request)
-    }
-
-    func claimHandshakeInitiation(
-        _ initiation: NoiseHandshakeInitiation,
-        for peerID: PeerID
-    ) -> Data? {
-        sessionManager.claimHandshakeInitiation(initiation, for: peerID)
-    }
-    
     /// Process an incoming handshake message
     func processHandshakeMessage(from peerID: PeerID, message: Data) throws -> Data? {
         try processHandshakeMessageWithResult(
@@ -854,13 +717,6 @@ final class NoiseEncryptionService {
         return sessionManager.getSession(for: peerID) != nil
     }
     
-    /// True while an inbound ordinary XX responder is waiting for message 3.
-    /// A small amount of immediately-following ciphertext may arrive first
-    /// over BLE and must be retried only after responder promotion.
-    func isAwaitingResponderHandshakeCompletion(with peerID: PeerID) -> Bool {
-        sessionManager.isAwaitingResponderHandshakeCompletion(for: peerID)
-    }
-    
     // MARK: - Encryption/Decryption
     
     /// Encrypt data for a specific peer
@@ -885,86 +741,24 @@ final class NoiseEncryptionService {
         return try sessionManager.encrypt(data, for: peerID)
     }
     
-    /// Encrypts a finalized private-media packet. Ordinary Noise application
-    /// messages retain the 64 KiB ceiling; this purpose-specific path permits
-    /// the bounded `BitchatFilePacket` envelope and refuses every other typed
-    /// payload so the larger allocation budget cannot become a generic bypass.
-    func encryptPrivateFilePayload(
-        _ data: Data,
-        for peerID: PeerID,
-        sessionGeneration: UUID? = nil
-    ) throws -> Data {
-        guard NoisePayloadType.isPrivateFile(rawValue: data.first),
-              NoiseSecurityValidator.validatePrivateFileMessageSize(data) else {
+    /// Decrypt data from a specific peer
+    func decrypt(_ data: Data, from peerID: PeerID) throws -> Data {
+        // Validate message size
+        guard NoiseSecurityValidator.validateMessageSize(data) else {
             throw NoiseSecurityError.messageTooLarge
         }
         
+        // Check rate limit
         guard rateLimiter.allowMessage(from: peerID) else {
             throw NoiseSecurityError.rateLimitExceeded
         }
         
+        // Check if we have an established session
         guard hasEstablishedSession(with: peerID) else {
-            onHandshakeRequired?(peerID)
-            throw NoiseEncryptionError.handshakeRequired
-        }
-
-        // `maxPrivateFilePlaintextSize` already subtracts the cipher's fixed
-        // nonce/tag overhead, so the result is bounded without a second copy.
-        if let sessionGeneration {
-            return try sessionManager.encrypt(
-                data,
-                for: peerID,
-                expectedSessionGeneration: sessionGeneration
-            )
-        }
-        return try sessionManager.encrypt(data, for: peerID)
-    }
-    
-    /// Decrypt data from a specific peer
-    func decrypt(_ data: Data, from peerID: PeerID) throws -> Data {
-        try decryptWithSessionGeneration(data, from: peerID).plaintext
-    }
-
-    func decryptWithSessionGeneration(
-        _ data: Data,
-        from peerID: PeerID,
-        establishedGenerationIsReady: (UUID) -> Bool = { _ in true }
-    ) throws -> (plaintext: Data, sessionGeneration: UUID) {
-        // Standard transport ciphertext has 20 bytes of nonce/tag overhead.
-        // A larger ciphertext is admitted only up to the framed-file ceiling;
-        // after authenticated decryption it must prove it is `.privateFile`.
-        let isStandardCiphertext = NoiseSecurityValidator.validateCiphertextSize(data)
-        let isAdmittedCiphertext = isStandardCiphertext
-            || NoiseSecurityValidator.validatePrivateFileCiphertextSize(data)
-        
-        // A quarantined transport is deliberately unavailable for outbound
-        // state, but remains receive-only until the responder proves identity
-        // or the bounded rollback restores it.
-        guard sessionManager.hasReceiveSession(for: peerID) else {
             throw NoiseEncryptionError.sessionNotEstablished
         }
         
-        let result = try sessionManager.decryptWithSessionGeneration(
-            data,
-            from: peerID,
-            establishedGenerationIsReady:
-                establishedGenerationIsReady,
-            authorizeDecrypt: { [rateLimiter] in
-                guard isAdmittedCiphertext else {
-                    throw NoiseSecurityError.messageTooLarge
-                }
-                guard rateLimiter.allowMessage(from: peerID) else {
-                    throw NoiseSecurityError.rateLimitExceeded
-                }
-            }
-        )
-        if !isStandardCiphertext {
-            guard NoisePayloadType.isPrivateFile(rawValue: result.plaintext.first),
-                  NoiseSecurityValidator.validatePrivateFileMessageSize(result.plaintext) else {
-                throw NoiseSecurityError.messageTooLarge
-            }
-        }
-        return result
+        return try sessionManager.decrypt(data, from: peerID)
     }
     
     // MARK: - Peer Management
@@ -976,25 +770,6 @@ final class NoiseEncryptionService {
         }
     }
 
-    func sessionGeneration(for peerID: PeerID) -> UUID? {
-        sessionManager.sessionGeneration(for: peerID)
-    }
-
-    /// Runs `body` while holding a read lease on the exact session generation.
-    /// Session insertion, replacement, and removal use the same manager
-    /// barrier, so they cannot interleave with an authenticated-state commit.
-    func withCurrentSessionGeneration<Result>(
-        for peerID: PeerID,
-        expected: UUID,
-        _ body: () -> Result
-    ) -> Result? {
-        sessionManager.withCurrentSessionGeneration(
-            for: peerID,
-            expected: expected,
-            body
-        )
-    }
-
     func clearEphemeralStateForPanic() {
         sessionManager.removeAllSessions()
         serviceQueue.sync(flags: .barrier) {
@@ -1017,36 +792,24 @@ final class NoiseEncryptionService {
     
     // MARK: - Private Helpers
     
-    private func handleSessionEstablished(
-        peerID: PeerID,
-        remoteStaticKey: Curve25519.KeyAgreement.PublicKey,
-        sessionGeneration: UUID
-    ) {
+    private func handleSessionEstablished(peerID: PeerID, remoteStaticKey: Curve25519.KeyAgreement.PublicKey) {
         // Calculate fingerprint
         let fingerprint = remoteStaticKey.rawRepresentation.sha256Fingerprint()
         
-        // Registering handlers is synchronous, and this barrier snapshots them
-        // with the fingerprint update. Invoke the snapshot outside the queue:
-        // parallel Swift Testing workers must not block behind queued callback
-        // registration or allow a handler to re-enter serviceQueue.
-        let handlers: (
-            generationAware: [(PeerID, String, UUID) -> Void],
-            legacy: [(PeerID, String) -> Void]
-        ) = serviceQueue.sync(flags: .barrier) {
+        // Store fingerprint mapping
+        serviceQueue.sync(flags: .barrier) {
             peerFingerprints[peerID] = fingerprint
             fingerprintToPeerID[fingerprint] = peerID
-            return (onPeerAuthenticatedWithGenerationHandlers, onPeerAuthenticatedHandlers)
         }
         
         // Log security event
         SecureLogger.info(.handshakeCompleted(peerID: peerID.id))
         
-        // Notify all handlers about authentication.
-        handlers.generationAware.forEach { handler in
-            handler(peerID, fingerprint, sessionGeneration)
-        }
-        handlers.legacy.forEach { handler in
-            handler(peerID, fingerprint)
+        // Notify all handlers about authentication
+        serviceQueue.async { [weak self] in
+            self?.onPeerAuthenticatedHandlers.forEach { handler in
+                handler(peerID, fingerprint)
+            }
         }
     }
         
@@ -1067,27 +830,20 @@ final class NoiseEncryptionService {
         let sessionsNeedingRekey = sessionManager.getSessionsNeedingRekey()
         
         for (peerID, needsRekey) in sessionsNeedingRekey where needsRekey {
+            
+            // Attempt to rekey the session
             do {
-                try initiateAutomaticRekey(for: peerID)
+                try sessionManager.initiateRekey(for: peerID)
+                SecureLogger.debug("Key rotation initiated for peer: \(peerID)", category: .security)
+                
+                // Signal that handshake is needed
+                onHandshakeRequired?(peerID)
             } catch {
                 SecureLogger.error(error, context: "Failed to initiate rekey for peer: \(peerID)", category: .session)
             }
         }
     }
     
-    private func initiateAutomaticRekey(for peerID: PeerID) throws {
-        let initiation = try sessionManager.initiateRekey(for: peerID)
-        SecureLogger.debug("Key rotation initiated for peer: \(peerID)", category: .security)
-        onRekeyHandshakeReady?(peerID, initiation)
-        onHandshakeRequired?(peerID)
-    }
-
-    #if DEBUG
-    func _test_initiateAutomaticRekey(for peerID: PeerID) throws {
-        try initiateAutomaticRekey(for: peerID)
-    }
-    #endif
-    
     deinit {
         stopRekeyTimer()
     }
@@ -1174,9 +930,6 @@ struct NoiseMessage: Codable {
 enum NoiseEncryptionError: Error {
     case handshakeRequired
     case sessionNotEstablished
-    /// Manager keys are established or restored, but BLE has not installed
-    /// generation-bound transport state. No receive nonce was consumed.
-    case transportGenerationNotReady
     /// Envelope references a prekey ID we don't hold (never ours, already
     /// deleted after its grace window, or wiped in a panic).
     case unknownPrekey

bitchat/Services/SharedContentHandoff.swift

@@ -0,0 +1,212 @@
+import Foundation
+
+enum SharedContentKind: String, Codable, Sendable, Equatable {
+    case text
+    case url
+}
+
+/// The single, bounded payload handed from the share extension to the app.
+///
+/// The app-group store intentionally contains at most one envelope. A newer
+/// share replaces an older one, which prevents unbounded shared-container
+/// growth while still surviving suspension and a later app launch.
+struct SharedContentPayload: Codable, Sendable, Equatable, Identifiable {
+    static let currentVersion = 1
+    static let maxContentBytes = 16_000
+    static let maxTitleBytes = 512
+    static let maxEnvelopeBytes = 24_000
+    static let retentionSeconds: TimeInterval = 24 * 60 * 60
+    static let allowedFutureSkewSeconds: TimeInterval = 5 * 60
+
+    let version: Int
+    let id: UUID
+    let kind: SharedContentKind
+    let content: String
+    let title: String?
+    let createdAt: Date
+
+    init(
+        version: Int = Self.currentVersion,
+        id: UUID = UUID(),
+        kind: SharedContentKind,
+        content: String,
+        title: String? = nil,
+        createdAt: Date = Date()
+    ) {
+        self.version = version
+        self.id = id
+        self.kind = kind
+        self.content = content
+        self.title = title
+        self.createdAt = createdAt
+    }
+
+    static func text(_ content: String, createdAt: Date = Date()) -> SharedContentPayload {
+        SharedContentPayload(kind: .text, content: content, createdAt: createdAt)
+    }
+
+    var composerText: String { content }
+
+    var preview: String {
+        let normalized = content
+            .replacingOccurrences(of: "\r\n", with: "\n")
+            .replacingOccurrences(of: "\r", with: "\n")
+        guard normalized.count > 240 else { return normalized }
+        return String(normalized.prefix(240)) + "…"
+    }
+
+    func validate(now: Date = Date()) throws {
+        guard version == Self.currentVersion else {
+            throw SharedContentHandoffError.unsupportedVersion
+        }
+
+        let trimmed = content.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else {
+            throw SharedContentHandoffError.emptyContent
+        }
+        guard content.utf8.count <= Self.maxContentBytes else {
+            throw SharedContentHandoffError.contentTooLarge
+        }
+        if let title {
+            guard title.utf8.count <= Self.maxTitleBytes else {
+                throw SharedContentHandoffError.titleTooLarge
+            }
+            guard !Self.containsDisallowedControl(in: title, allowsTextLayout: false) else {
+                throw SharedContentHandoffError.invalidCharacters
+            }
+        }
+
+        let age = now.timeIntervalSince(createdAt)
+        guard age >= -Self.allowedFutureSkewSeconds,
+              age <= Self.retentionSeconds else {
+            throw SharedContentHandoffError.expired
+        }
+
+        switch kind {
+        case .text:
+            guard !Self.containsDisallowedControl(in: content, allowsTextLayout: true) else {
+                throw SharedContentHandoffError.invalidCharacters
+            }
+        case .url:
+            guard !Self.containsDisallowedControl(in: content, allowsTextLayout: false),
+                  let components = URLComponents(string: content),
+                  let scheme = components.scheme?.lowercased(),
+                  scheme == "http" || scheme == "https",
+                  components.host?.isEmpty == false else {
+                throw SharedContentHandoffError.unsupportedURL
+            }
+        }
+    }
+
+    private static func containsDisallowedControl(
+        in value: String,
+        allowsTextLayout: Bool
+    ) -> Bool {
+        value.unicodeScalars.contains { scalar in
+            guard CharacterSet.controlCharacters.contains(scalar) else { return false }
+            if allowsTextLayout, scalar == "\n" || scalar == "\r" || scalar == "\t" {
+                return false
+            }
+            return true
+        }
+    }
+}
+
+enum SharedContentHandoffError: Error, Equatable {
+    case unsupportedVersion
+    case emptyContent
+    case contentTooLarge
+    case titleTooLarge
+    case invalidCharacters
+    case expired
+    case unsupportedURL
+    case envelopeTooLarge
+    case encodingFailed
+}
+
+/// Durable, single-item app-group storage used by both the extension and app.
+final class SharedContentStore {
+    static let storageKey = "sharedContentEnvelopeV1"
+
+    private static let legacyKeys = [
+        "sharedContent",
+        "sharedContentType",
+        "sharedContentDate"
+    ]
+
+    private let defaults: UserDefaults
+    private let encoder: JSONEncoder
+    private let decoder: JSONDecoder
+
+    init(defaults: UserDefaults) {
+        self.defaults = defaults
+        self.encoder = JSONEncoder()
+        self.decoder = JSONDecoder()
+    }
+
+    /// Replaces any older pending share with a validated, bounded envelope.
+    func stage(_ payload: SharedContentPayload, now: Date = Date()) throws {
+        try payload.validate(now: now)
+        guard let encoded = try? encoder.encode(payload) else {
+            throw SharedContentHandoffError.encodingFailed
+        }
+        guard encoded.count <= SharedContentPayload.maxEnvelopeBytes else {
+            throw SharedContentHandoffError.envelopeTooLarge
+        }
+
+        defaults.set(encoded, forKey: Self.storageKey)
+        clearLegacyKeys()
+    }
+
+    /// Reads the pending share without consuming it. Invalid and expired data
+    /// is removed immediately so malformed app-group state cannot linger.
+    func pending(now: Date = Date()) -> SharedContentPayload? {
+        clearLegacyKeys()
+
+        guard let encoded = defaults.data(forKey: Self.storageKey) else { return nil }
+        guard encoded.count <= SharedContentPayload.maxEnvelopeBytes,
+              let payload = try? decoder.decode(SharedContentPayload.self, from: encoded) else {
+            defaults.removeObject(forKey: Self.storageKey)
+            return nil
+        }
+
+        do {
+            try payload.validate(now: now)
+            return payload
+        } catch {
+            defaults.removeObject(forKey: Self.storageKey)
+            return nil
+        }
+    }
+
+    /// Consumes only the envelope the user actually reviewed. If a newer share
+    /// already replaced it, the newer content remains pending.
+    func consume(id: UUID, now: Date = Date()) -> SharedContentPayload? {
+        guard let payload = pending(now: now), payload.id == id else { return nil }
+        defaults.removeObject(forKey: Self.storageKey)
+        return payload
+    }
+
+    /// Explicit cancellation has the same identity guard as consumption so it
+    /// can never discard a newer share that arrived while a prompt was open.
+    func discard(id: UUID) {
+        guard let encoded = defaults.data(forKey: Self.storageKey),
+              encoded.count <= SharedContentPayload.maxEnvelopeBytes,
+              let payload = try? decoder.decode(SharedContentPayload.self, from: encoded),
+              payload.id == id else {
+            return
+        }
+        defaults.removeObject(forKey: Self.storageKey)
+    }
+
+    func discardAll() {
+        defaults.removeObject(forKey: Self.storageKey)
+        clearLegacyKeys()
+    }
+
+    private func clearLegacyKeys() {
+        for key in Self.legacyKeys {
+            defaults.removeObject(forKey: key)
+        }
+    }
+}

bitchat/Services/TransferProgressManager.swift

@@ -11,7 +11,6 @@ final class TransferProgressManager {
         case updated(id: String, sentFragments: Int, totalFragments: Int)
         case completed(id: String, totalFragments: Int)
         case cancelled(id: String, sentFragments: Int, totalFragments: Int)
-        case rejected(id: String, reason: String)
     }
 
     private let subject = PassthroughSubject<Event, Never>()
@@ -50,17 +49,6 @@ final class TransferProgressManager {
         }
     }
 
-    /// Fails a preflight check while keeping the outgoing placeholder visible
-    /// with an actionable reason instead of treating policy/size rejection as
-    /// a user cancellation.
-    func rejectBeforeStart(id: String, reason: String) {
-        queue.async(flags: .barrier) { [weak self] in
-            guard let self = self else { return }
-            self.states.removeValue(forKey: id)
-            self.subject.send(.rejected(id: id, reason: reason))
-        }
-    }
-
     func snapshot(id: String) -> (sent: Int, total: Int)? {
         var result: (sent: Int, total: Int)?
         queue.sync {

bitchat/Services/Transport.swift

@@ -83,31 +83,10 @@ enum TransportEvent: @unchecked Sendable {
     case bluetoothStateUpdated(CBManagerState)
 }
 
-/// Downgrade-safe decision for a private-media recipient. Callers ask before
-/// prompting, and BLEService checks again when it consumes any one-shot
-/// legacy consent.
-enum PrivateMediaSendPolicy: Equatable {
-    case encrypted
-    /// A public announce hinted at encrypted media (or a prior authenticated
-    /// pin exists), but this exact Noise session has not yet supplied its
-    /// authenticated peer-state proof. Callers wait boundedly; they must not
-    /// pre-queue encrypted bytes or silently select the legacy path.
-    case awaitingCapabilityProof
-    case legacyRequiresConsent
-    case blockedDowngrade
-}
-
 protocol TransportEventDelegate: AnyObject {
     @MainActor func didReceiveTransportEvent(_ event: TransportEvent)
 }
 
-/// Optional typed-event contract for sinks that can synchronously decide
-/// whether an inbound message was accepted.
-protocol SynchronousMessageTransportEventDelegate: TransportEventDelegate {
-    @MainActor
-    func didReceiveTransportMessageSynchronously(_ message: BitchatMessage) -> Bool
-}
-
 protocol Transport: AnyObject {
     // Event sink
     var delegate: BitchatDelegate? { get set }
@@ -184,20 +163,6 @@ protocol Transport: AnyObject {
     func sendDeliveryAck(for messageID: String, to peerID: PeerID)
     func sendFileBroadcast(_ packet: BitchatFilePacket, transferId: String)
     func sendFilePrivate(_ packet: BitchatFilePacket, to peerID: PeerID, transferId: String)
-    func sendFilePrivate(
-        _ packet: BitchatFilePacket,
-        to peerID: PeerID,
-        transferId: String,
-        allowLegacyFallback: Bool
-    )
-    /// Automatic whole-file retry is admitted only while this exact Noise
-    /// generation authenticates bit 9. It must never queue across a session
-    /// replacement or enter the signed raw legacy path.
-    func sendFilePrivateReceiptRetry(
-        _ packet: BitchatFilePacket,
-        to peerID: PeerID,
-        transferId: String
-    )
     func cancelTransfer(_ transferId: String)
 
     // Live voice / push-to-talk (mesh transports only): one encoded
@@ -243,16 +208,6 @@ protocol Transport: AnyObject {
     /// Capabilities the peer advertised in its last verified announce;
     /// empty for peers that predate the capabilities TLV.
     func peerCapabilities(_ peerID: PeerID) -> PeerCapabilities
-    func privateMediaSendPolicy(to peerID: PeerID) -> PrivateMediaSendPolicy
-    /// The exact current Noise generation that authenticated both encrypted
-    /// private media (bit 8) and durable receipts/retry (bit 9).
-    func authenticatedPrivateMediaReceiptSessionGeneration(
-        to peerID: PeerID
-    ) -> UUID?
-    func resolvePrivateMediaSendPolicy(
-        to peerID: PeerID,
-        completion: @escaping @MainActor (PrivateMediaSendPolicy) -> Void
-    )
     /// Sends an encoded vouch-attestation batch inside the Noise session.
     func sendVouchAttestations(_ payload: Data, to peerID: PeerID)
     /// Appends a peer-authenticated observer. Unlike
@@ -323,21 +278,6 @@ extension Transport {
     func sendGroupKeyUpdate(_ statePayload: Data, to peerID: PeerID) {}
     func broadcastGroupMessage(_ envelope: Data) {}
     func peerCapabilities(_ peerID: PeerID) -> PeerCapabilities { [] }
-    func privateMediaSendPolicy(to peerID: PeerID) -> PrivateMediaSendPolicy { .blockedDowngrade }
-    func authenticatedPrivateMediaReceiptSessionGeneration(
-        to peerID: PeerID
-    ) -> UUID? {
-        nil
-    }
-    func resolvePrivateMediaSendPolicy(
-        to peerID: PeerID,
-        completion: @escaping @MainActor (PrivateMediaSendPolicy) -> Void
-    ) {
-        let policy = privateMediaSendPolicy(to: peerID)
-        Task { @MainActor in
-            completion(policy == .awaitingCapabilityProof ? .blockedDowngrade : policy)
-        }
-    }
     func sendVouchAttestations(_ payload: Data, to peerID: PeerID) {}
     func addPeerAuthenticatedObserver(_ handler: @escaping (PeerID, String) -> Void) {}
     func sendCourierMessage(_ content: String, messageID: String, recipientNoiseKey: Data, via couriers: [PeerID]) -> Bool { false }
@@ -354,20 +294,6 @@ extension Transport {
     func currentMeshTopology() -> MeshTopologySnapshot? { nil }
     func sendFileBroadcast(_ packet: BitchatFilePacket, transferId: String) {}
     func sendFilePrivate(_ packet: BitchatFilePacket, to peerID: PeerID, transferId: String) {}
-    func sendFilePrivate(
-        _ packet: BitchatFilePacket,
-        to peerID: PeerID,
-        transferId: String,
-        allowLegacyFallback: Bool
-    ) {
-        guard !allowLegacyFallback else { return }
-        sendFilePrivate(packet, to: peerID, transferId: transferId)
-    }
-    func sendFilePrivateReceiptRetry(
-        _ packet: BitchatFilePacket,
-        to peerID: PeerID,
-        transferId: String
-    ) {}
     func cancelTransfer(_ transferId: String) {}
 
     func sendMessage(_ content: String, mentions: [String], messageID: String, timestamp: Date) {

bitchat/Services/TransportConfig.swift

@@ -9,19 +9,6 @@ enum TransportConfig {
     static let bleMaxInFlightAssemblies: Int = 128          // Cap concurrent fragment assemblies
     static let bleHighDegreeThreshold: Int = 6              // For adaptive TTL/probabilistic relays
     static let bleMaxConcurrentTransfers: Int = 2           // Limit simultaneous large media sends
-    // Bounded wait for the session-authenticated capability proof used by
-    // private-media migration. Expiry never auto-sends clear bytes; it only
-    // resolves to the existing one-shot consent or downgrade-blocked path.
-    static let privateMediaCapabilityProofTimeoutSeconds: TimeInterval = 5
-    static let privateMediaCapabilityProofPendingPeerCap: Int = 64
-    static let privateMediaCapabilityProofWaitersPerPeerCap: Int = 16
-    /// Accepted private-media receipts and explicit-deletion tombstones each
-    /// receive this independent capacity.
-    static let privateMediaReceivedLedgerCapacity: Int = 4_096
-    /// A bounded retry horizon prevents stable receipt state from growing into
-    /// permanent application history.
-    static let privateMediaReceivedLedgerTTLSeconds: TimeInterval =
-        7 * 24 * 60 * 60
     static let bleFragmentRelayMinDelayMs: Int = 8          // Faster forwarding for media fragments
     static let bleFragmentRelayMaxDelayMs: Int = 25         // Upper jitter bound for fragment relays
     // Fragment relay TTL in sparse graphs; matches messageTTLDefault so media
@@ -338,7 +325,6 @@ enum TransportConfig {
 
     // Share extension
     static let uiShareExtensionDismissDelaySeconds: TimeInterval = 2.0
-    static let uiShareAcceptWindowSeconds: TimeInterval = 30.0
     static let uiMigrationCutoffSeconds: TimeInterval = 24 * 60 * 60
 
     // Gossip Sync Configuration

bitchat/ViewModels/ChatDeliveryCoordinator.swift

@@ -55,9 +55,6 @@ extension ChatViewModel: ChatDeliveryContext {
 
     func markMessageDelivered(_ messageID: String) {
         messageRouter.markDelivered(messageID)
-        mediaTransferCoordinator.confirmPrivateMediaDelivery(
-            messageID: messageID
-        )
     }
 }
 

bitchat/ViewModels/ChatLiveVoiceCoordinator.swift

@@ -10,7 +10,6 @@ import Foundation
 @MainActor
 protocol ChatLiveVoiceContext: AnyObject {
     var nickname: String { get }
-    var myPeerID: PeerID { get }
     var selectedPrivateChatPeer: PeerID? { get }
     /// Whether the public mesh timeline is what's on screen (autoplay gate
     /// for public bursts).
@@ -31,12 +30,6 @@ protocol ChatLiveVoiceContext: AnyObject {
     func upsertPublicMeshMessage(_ message: BitchatMessage)
     @discardableResult
     func removePrivateMessage(withID messageID: String) -> BitchatMessage?
-    /// Records and sends the finalized note's read receipt after a live
-    /// bubble adopts its wire-derivable message ID.
-    func hasSentReadReceipt(_ messageID: String) -> Bool
-    @discardableResult
-    func markReadReceiptSent(_ messageID: String) -> Bool
-    func sendMeshReadReceipt(_ receipt: ReadReceipt, to peerID: PeerID)
     /// Removes a message from whichever conversation holds it.
     func removeMessage(withID messageID: String, cleanupFile: Bool)
     /// Publishes who is currently talking live in the public mesh channel
@@ -279,16 +272,8 @@ final class ChatLiveVoiceCoordinator {
         guard let entry = finishedBursts.first(where: { matches($0.key) }) else { return false }
         let finished = entry.value
 
-        // A DM live bubble starts before the finalized file exists and
-        // therefore has a receiver-local random ID. Adopt the finalized
-        // message's deterministic ID so delivery/read ACKs address the same
-        // row as the sender's media placeholder. Public notes retain their
-        // live-bubble ID because public transfers have no private receipts.
-        let replacementID = finished.scope == .directMessage
-            ? message.id
-            : finished.messageID
         let replacement = BitchatMessage(
-            id: replacementID,
+            id: finished.messageID,
             sender: message.sender,
             content: message.content,
             timestamp: finished.messageTimestamp,
@@ -302,31 +287,7 @@ final class ChatLiveVoiceCoordinator {
         )
         switch finished.scope {
         case .directMessage:
-            // Capture read state before rekeying. The user may have read the
-            // live bubble and navigated away before the finalized .m4a lands.
-            let shouldSendAdoptedReadReceipt =
-                context.hasSentReadReceipt(finished.messageID)
-                || context.selectedPrivateChatPeer == finished.peerID
-
-            // Insert first so replacing the only row in a DM never
-            // transiently deletes its conversation, unread state, or current
-            // selection. Then remove the receiver-local live-bubble alias.
             context.upsertPrivateMessage(replacement, in: finished.peerID)
-            if replacementID != finished.messageID {
-                context.removePrivateMessage(withID: finished.messageID)
-            }
-            // The live bubble may already have emitted a receiver-local READ
-            // before the sender created its finalized media row. Re-emit once
-            // for the adopted stable ID now that the file has arrived.
-            if shouldSendAdoptedReadReceipt,
-               context.markReadReceiptSent(replacementID) {
-                let receipt = ReadReceipt(
-                    originalMessageID: replacementID,
-                    readerID: context.myPeerID,
-                    readerNickname: context.nickname
-                )
-                context.sendMeshReadReceipt(receipt, to: finished.peerID)
-            }
         case .publicMesh:
             context.upsertPublicMeshMessage(replacement)
         }

bitchat/ViewModels/ChatPeerListCoordinator.swift

@@ -100,14 +100,9 @@ final class ChatPeerListCoordinator: @unchecked Sendable {
 
     func didUpdatePeerList(_ peers: [PeerID]) {
         Task { @MainActor [weak self] in
-            self?.didUpdatePeerListSynchronously(peers)
+            self?.handlePeerListUpdate(peers)
         }
     }
-
-    @MainActor
-    func didUpdatePeerListSynchronously(_ peers: [PeerID]) {
-        handlePeerListUpdate(peers)
-    }
 }
 
 private extension ChatPeerListCoordinator {

bitchat/ViewModels/ChatTransportEventCoordinator.swift

@@ -163,18 +163,19 @@ final class ChatTransportEventCoordinator {
     }
 
     func didReceiveMessage(_ message: BitchatMessage) {
-        runOnMain { [self] context in
-            handleReceivedMessage(message, in: context)
-        }
-    }
+        runOnMain { context in
+            guard !context.isMessageBlocked(message) else { return }
+            guard !message.content.trimmed.isEmpty || message.isPrivate else { return }
 
-    /// Typed transport events already arrive on the main actor. Handle them
-    /// synchronously so observers see the ConversationStore mutation before
-    /// the transport completes delivery.
-    @MainActor
-    @discardableResult
-    func didReceiveMessageSynchronously(_ message: BitchatMessage) -> Bool {
-        handleReceivedMessage(message, in: context)
+            if message.isPrivate {
+                context.handlePrivateMessage(message)
+            } else {
+                context.handlePublicMessage(message)
+            }
+
+            context.checkForMentions(message)
+            context.sendHapticFeedback(for: message)
+        }
     }
 
     func didReceivePublicMessage(
@@ -184,34 +185,26 @@ final class ChatTransportEventCoordinator {
         timestamp: Date,
         messageID: String?
     ) {
-        runOnMain { [self] context in
-            handlePublicMessage(
-                from: peerID,
-                nickname: nickname,
-                content: content,
+        runOnMain { context in
+            let normalized = content.trimmed
+            let mentions = context.parseMentions(from: normalized)
+            let message = BitchatMessage(
+                id: messageID,
+                sender: nickname,
+                content: normalized,
                 timestamp: timestamp,
-                messageID: messageID,
-                in: context
+                isRelay: false,
+                originalSender: nil,
+                isPrivate: false,
+                recipientNickname: nil,
+                senderPeerID: peerID,
+                mentions: mentions.isEmpty ? nil : mentions
             )
-        }
-    }
 
-    @MainActor
-    func didReceivePublicMessageSynchronously(
-        from peerID: PeerID,
-        nickname: String,
-        content: String,
-        timestamp: Date,
-        messageID: String?
-    ) {
-        handlePublicMessage(
-            from: peerID,
-            nickname: nickname,
-            content: content,
-            timestamp: timestamp,
-            messageID: messageID,
-            in: context
-        )
+            context.handlePublicMessage(message)
+            context.checkForMentions(message)
+            context.sendHapticFeedback(for: message)
+        }
     }
 
     func didReceiveNoisePayload(
@@ -231,134 +224,59 @@ final class ChatTransportEventCoordinator {
         }
     }
 
-    @MainActor
-    func didReceiveNoisePayloadSynchronously(
-        from peerID: PeerID,
-        type: NoisePayloadType,
-        payload: Data,
-        timestamp: Date
-    ) {
-        handleNoisePayload(
-            from: peerID,
-            type: type,
-            payload: payload,
-            timestamp: timestamp,
-            in: context
-        )
-    }
-
     func didConnectToPeer(_ peerID: PeerID) {
-        runOnMain { [weak self] _ in
-            self?.didConnectToPeerSynchronously(peerID)
-        }
-    }
-
-    @MainActor
-    func didConnectToPeerSynchronously(_ peerID: PeerID) {
         SecureLogger.debug("🤝 Peer connected: \(peerID)", category: .session)
 
-        context.isConnected = true
-        context.registerEphemeralSession(peerID: peerID)
-        context.notifyUIChanged()
+        runOnMain { context in
+            context.isConnected = true
+            context.registerEphemeralSession(peerID: peerID)
+            context.notifyUIChanged()
 
-        if let peer = context.unifiedPeer(for: peerID) {
-            let stablePeerID = PeerID(hexData: peer.noisePublicKey)
-            context.cacheStablePeerID(stablePeerID, for: peerID)
+            if let peer = context.unifiedPeer(for: peerID) {
+                let stablePeerID = PeerID(hexData: peer.noisePublicKey)
+                context.cacheStablePeerID(stablePeerID, for: peerID)
+            }
+
+            context.flushRouterOutbox(for: peerID)
+            context.retryCourierDeposits(via: peerID)
         }
-
-        context.flushRouterOutbox(for: peerID)
-        context.retryCourierDeposits(via: peerID)
     }
 
     func didDisconnectFromPeer(_ peerID: PeerID) {
-        runOnMain { [weak self] _ in
-            self?.didDisconnectFromPeerSynchronously(peerID)
-        }
-    }
-
-    @MainActor
-    func didDisconnectFromPeerSynchronously(_ peerID: PeerID) {
         SecureLogger.debug("👋 Peer disconnected: \(peerID)", category: .session)
 
-        context.removeEphemeralSession(peerID: peerID)
+        runOnMain { context in
+            context.removeEphemeralSession(peerID: peerID)
 
-        var stablePeerID = context.cachedStablePeerID(for: peerID)
-        if stablePeerID == nil,
-           let key = context.noiseSessionPublicKeyData(for: peerID) {
-            let derivedPeerID = PeerID(hexData: key)
-            context.cacheStablePeerID(derivedPeerID, for: peerID)
-            stablePeerID = derivedPeerID
+            var stablePeerID = context.cachedStablePeerID(for: peerID)
+            if stablePeerID == nil,
+               let key = context.noiseSessionPublicKeyData(for: peerID) {
+                let derivedPeerID = PeerID(hexData: key)
+                context.cacheStablePeerID(derivedPeerID, for: peerID)
+                stablePeerID = derivedPeerID
+            }
+
+            if let currentPeerID = context.selectedPrivateChatPeer,
+               currentPeerID == peerID,
+               let stablePeerID {
+                self.migrateSelectedConversationIfNeeded(
+                    from: peerID,
+                    to: stablePeerID,
+                    in: context
+                )
+            }
+
+            let receiptIDs = context.privateMessages(for: peerID)
+                .filter { $0.senderPeerID == peerID }
+                .map(\.id)
+            context.unmarkReadReceiptsSent(receiptIDs)
+
+            context.notifyUIChanged()
         }
-
-        if let currentPeerID = context.selectedPrivateChatPeer,
-           currentPeerID == peerID,
-           let stablePeerID {
-            migrateSelectedConversationIfNeeded(
-                from: peerID,
-                to: stablePeerID,
-                in: context
-            )
-        }
-
-        let receiptIDs = context.privateMessages(for: peerID)
-            .filter { $0.senderPeerID == peerID }
-            .map(\.id)
-        context.unmarkReadReceiptsSent(receiptIDs)
-
-        context.notifyUIChanged()
     }
 }
 
 private extension ChatTransportEventCoordinator {
-    @MainActor
-    func handlePublicMessage(
-        from peerID: PeerID,
-        nickname: String,
-        content: String,
-        timestamp: Date,
-        messageID: String?,
-        in context: any ChatTransportEventContext
-    ) {
-        let normalized = content.trimmed
-        let mentions = context.parseMentions(from: normalized)
-        let message = BitchatMessage(
-            id: messageID,
-            sender: nickname,
-            content: normalized,
-            timestamp: timestamp,
-            isRelay: false,
-            originalSender: nil,
-            isPrivate: false,
-            recipientNickname: nil,
-            senderPeerID: peerID,
-            mentions: mentions.isEmpty ? nil : mentions
-        )
-
-        context.handlePublicMessage(message)
-        context.checkForMentions(message)
-        context.sendHapticFeedback(for: message)
-    }
-
-    @MainActor
-    @discardableResult
-    func handleReceivedMessage(
-        _ message: BitchatMessage,
-        in context: any ChatTransportEventContext
-    ) -> Bool {
-        guard !context.isMessageBlocked(message) else { return false }
-        guard !message.content.trimmed.isEmpty || message.isPrivate else { return false }
-
-        if message.isPrivate {
-            context.handlePrivateMessage(message)
-        } else {
-            context.handlePublicMessage(message)
-        }
-
-        context.checkForMentions(message)
-        context.sendHapticFeedback(for: message)
-        return true
-    }
-
     func runOnMain(_ action: @escaping @MainActor (any ChatTransportEventContext) -> Void) {
         Task { @MainActor [weak context = self.context] in
             guard let context else { return }
@@ -489,13 +407,6 @@ private extension ChatTransportEventCoordinator {
 
         case .voiceFrame:
             context.handleVoiceFramePayload(from: peerID, payload: payload, timestamp: timestamp)
-
-        case .privateFile, .authenticatedPeerState:
-            // BLEService validates and persists decrypted private files before
-            // emitting a normal `.messageReceived` event, and consumes peer
-            // state inside the transport. Neither payload crosses this
-            // UI-facing typed-payload fallback.
-            break
         }
     }
 

bitchat/ViewModels/ChatVerificationCoordinator.swift

@@ -58,7 +58,6 @@ protocol ChatVerificationContext: AnyObject {
     func noiseStaticPublicKeyData() -> Data
     func hasEstablishedNoiseSession(with peerID: PeerID) -> Bool
     func triggerHandshake(with peerID: PeerID)
-    func privateMediaPeerDidAuthenticate(_ peerID: PeerID)
     func sendVerifyChallenge(to peerID: PeerID, noiseKeyHex: String, nonceA: Data)
     func sendVerifyResponse(to peerID: PeerID, noiseKeyHex: String, nonceA: Data)
 
@@ -117,10 +116,6 @@ extension ChatViewModel: ChatVerificationContext {
         meshService.noiseStaticPublicKeyData()
     }
 
-    func privateMediaPeerDidAuthenticate(_ peerID: PeerID) {
-        mediaTransferCoordinator.peerDidAuthenticate(peerID.toShort())
-    }
-
     func sendVerifyChallenge(to peerID: PeerID, noiseKeyHex: String, nonceA: Data) {
         meshService.sendVerifyChallenge(to: peerID, noiseKeyHex: noiseKeyHex, nonceA: nonceA)
     }
@@ -134,10 +129,6 @@ extension ChatViewModel: ChatVerificationContext {
     }
 }
 
-extension ChatVerificationContext {
-    func privateMediaPeerDidAuthenticate(_ peerID: PeerID) {}
-}
-
 @MainActor
 final class ChatVerificationCoordinator {
     struct PendingVerification {
@@ -206,7 +197,6 @@ final class ChatVerificationCoordinator {
                     guard let self else { return }
 
                     SecureLogger.debug("🔐 Authenticated: \(peerID)", category: .security)
-                    self.context.privateMediaPeerDidAuthenticate(peerID)
 
                     if self.context.isVerifiedFingerprint(fingerprint) {
                         self.context.setEncryptionStatus(.noiseVerified, for: peerID)

bitchat/ViewModels/ChatViewModel.swift

@@ -112,7 +112,7 @@ struct PanicNetworkLifecycle {
 /// Manages the application state and business logic for BitChat.
 /// Acts as the primary coordinator between UI components and backend services,
 /// implementing the BitchatDelegate protocol to handle network events.
-final class ChatViewModel: ObservableObject, BitchatDelegate, SynchronousMessageTransportEventDelegate, CommandContextProvider, GeohashParticipantContext, MessageFormattingContext {
+final class ChatViewModel: ObservableObject, BitchatDelegate, TransportEventDelegate, CommandContextProvider, GeohashParticipantContext, MessageFormattingContext {
     // Use MessageFormattingEngine.Patterns for regex matching (shared, precompiled)
     typealias Patterns = MessageFormattingEngine.Patterns
 
@@ -375,8 +375,6 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, SynchronousMessage
     @Published var showBluetoothAlert = false
     @Published var bluetoothAlertMessage = ""
     @Published var bluetoothState: CBManagerState = .unknown
-    @Published private(set) var legacyPrivateMediaConsentRequest: LegacyPrivateMediaConsentRequest?
-    private var pendingLegacyPrivateMediaConsents: [PendingLegacyPrivateMediaConsent] = []
 
     private func performDeliveryUpdate(_ update: @escaping @MainActor (ChatDeliveryCoordinator) -> Void) {
         if Thread.isMainThread {
@@ -495,12 +493,6 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, SynchronousMessage
         }
     }
 
-    /// Whether a read receipt has already been recorded for `messageID`.
-    @MainActor
-    func hasSentReadReceipt(_ messageID: String) -> Bool {
-        sentReadReceipts.contains(messageID)
-    }
-
     /// Records that a read receipt is being sent for `messageID`.
     /// Returns `false` when one was already recorded — the caller must skip sending.
     @MainActor
@@ -1276,10 +1268,6 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, SynchronousMessage
         mediaTransferCoordinator.resetForPanic()
         liveVoiceCoordinator.resetForPanic()
 
-        // Deny and release any clear-media confirmations before identities,
-        // message state, and local files are wiped.
-        cancelAllLegacyPrivateMediaConsents()
-
         // Clear all messages (public timelines and private chats live in the
         // single-writer ConversationStore; the derived `messages` view and
         // the legacy mirror empty with it)
@@ -1343,6 +1331,15 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, SynchronousMessage
         // posts are signed with our identity key and persist for days.
         BoardStore.shared.wipe()
 
+        // Drop any share-extension handoff staged in the app group. The normal
+        // panic path clears this through AppChromeModel.onPanicWipe, but the
+        // crash-recovery replay calls this method directly and would otherwise
+        // let a staged envelope survive the wipe. Clearing here is idempotent
+        // (it only removes the app-group key), so the double-clear is harmless.
+        if let sharedDefaults = UserDefaults(suiteName: BitchatApp.groupID) {
+            SharedContentStore(defaults: sharedDefaults).discardAll()
+        }
+
         // Identity manager has cleared persisted identity data above
 
         // Clear autocomplete state
@@ -1707,82 +1704,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, SynchronousMessage
 
     @MainActor
     func didReceiveTransportEvent(_ event: TransportEvent) {
-        switch event {
-        case .messageReceived(let message):
-            _ = didReceiveTransportMessageSynchronously(message)
-
-        case let .publicMessageReceived(
-            peerID,
-            nickname,
-            content,
-            timestamp,
-            messageID
-        ):
-            transportEventCoordinator.didReceivePublicMessageSynchronously(
-                from: peerID,
-                nickname: nickname,
-                content: content,
-                timestamp: timestamp,
-                messageID: messageID
-            )
-
-        case let .noisePayloadReceived(peerID, type, payload, timestamp):
-            transportEventCoordinator.didReceiveNoisePayloadSynchronously(
-                from: peerID,
-                type: type,
-                payload: payload,
-                timestamp: timestamp
-            )
-
-        case let .groupMessageReceived(payload, timestamp):
-            groupCoordinator.handleGroupMessagePayload(
-                payload,
-                timestamp: timestamp
-            )
-
-        case let .publicVoiceFrameReceived(
-            peerID,
-            nickname,
-            payload,
-            timestamp
-        ):
-            liveVoiceCoordinator.handlePublicVoiceFramePayload(
-                from: peerID,
-                nickname: nickname,
-                payload: payload,
-                timestamp: timestamp
-            )
-
-        case .peerConnected(let peerID):
-            transportEventCoordinator.didConnectToPeerSynchronously(peerID)
-            mediaTransferCoordinator.peerDidReconnect(peerID)
-
-        case .peerDisconnected(let peerID):
-            transportEventCoordinator.didDisconnectFromPeerSynchronously(peerID)
-
-        case .peerListUpdated(let peers):
-            peerListCoordinator.didUpdatePeerListSynchronously(peers)
-            // A peer-list update follows every verified announce, which is
-            // where a peer's `.vouch` capability actually arrives.
-            vouchCoordinator.peersUpdated(peers)
-
-        case .peerSnapshotsUpdated:
-            break
-
-        case let .messageDeliveryStatusUpdated(messageID, status):
-            deliveryCoordinator.didUpdateMessageDeliveryStatus(
-                messageID,
-                status: status
-            )
-
-        case .bluetoothStateUpdated(let state):
-            updateBluetoothState(state)
-        }
-    }
-
-    @MainActor
-    func didReceiveTransportMessageSynchronously(_ message: BitchatMessage) -> Bool {
-        transportEventCoordinator.didReceiveMessageSynchronously(message)
+        receiveTransportEvent(event)
     }
 
     func didReceiveMessage(_ message: BitchatMessage) {
@@ -1845,9 +1767,6 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, SynchronousMessage
 
     func didConnectToPeer(_ peerID: PeerID) {
         transportEventCoordinator.didConnectToPeer(peerID)
-        Task { @MainActor [weak self] in
-            self?.mediaTransferCoordinator.peerDidReconnect(peerID)
-        }
     }
 
     func didDisconnectFromPeer(_ peerID: PeerID) {
@@ -2012,91 +1931,4 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, SynchronousMessage
         publicConversationCoordinator.sendHapticFeedback(for: message)
     }
 }
-
-@MainActor
-extension ChatViewModel {
-    func enqueueLegacyPrivateMediaConsent(
-        for peerID: PeerID,
-        transferId: String,
-        messageID: String,
-        completion: @escaping @MainActor (Bool) -> Void
-    ) {
-        let request = LegacyPrivateMediaConsentRequest(
-            id: UUID(),
-            peerID: peerID,
-            peerName: nicknameForPeer(peerID),
-            transferId: transferId,
-            messageID: messageID
-        )
-        pendingLegacyPrivateMediaConsents.append(PendingLegacyPrivateMediaConsent(
-            request: request,
-            completion: completion
-        ))
-        if legacyPrivateMediaConsentRequest == nil {
-            legacyPrivateMediaConsentRequest = request
-        }
-    }
-
-    func resolveLegacyPrivateMediaConsent(requestID: UUID, approved: Bool) {
-        // SwiftUI may report both the selected button and the presentation
-        // binding's dismissal. Resolve only the exact request that was shown;
-        // a duplicate callback for it must not consume the next queued send.
-        guard legacyPrivateMediaConsentRequest?.id == requestID,
-              pendingLegacyPrivateMediaConsents.first?.request.id == requestID else {
-            return
-        }
-        let resolved = pendingLegacyPrivateMediaConsents.removeFirst()
-        // Drive the boolean presentation state through false before showing
-        // the next queued per-send warning. Otherwise SwiftUI sees true→true,
-        // closes the first dialog, and never presents the second.
-        legacyPrivateMediaConsentRequest = nil
-        resolved.completion(approved)
-        presentNextLegacyPrivateMediaConsentDeferred()
-    }
-
-    func invalidateLegacyPrivateMediaConsent(transferId: String, messageID: String) {
-        let invalidatedIDs = Set(
-            pendingLegacyPrivateMediaConsents.compactMap { pending -> UUID? in
-                let request = pending.request
-                return request.transferId == transferId && request.messageID == messageID
-                    ? request.id
-                    : nil
-            }
-        )
-        guard !invalidatedIDs.isEmpty else { return }
-
-        pendingLegacyPrivateMediaConsents.removeAll {
-            invalidatedIDs.contains($0.request.id)
-        }
-        if let currentID = legacyPrivateMediaConsentRequest?.id,
-           invalidatedIDs.contains(currentID) {
-            legacyPrivateMediaConsentRequest = nil
-            presentNextLegacyPrivateMediaConsentDeferred()
-        }
-    }
-
-    func cancelAllLegacyPrivateMediaConsents() {
-        let pending = pendingLegacyPrivateMediaConsents
-        pendingLegacyPrivateMediaConsents.removeAll()
-        legacyPrivateMediaConsentRequest = nil
-        for item in pending {
-            item.completion(false)
-        }
-    }
-
-    private func presentNextLegacyPrivateMediaConsentDeferred() {
-        guard legacyPrivateMediaConsentRequest == nil,
-              let nextRequestID = pendingLegacyPrivateMediaConsents.first?.request.id else {
-            return
-        }
-        DispatchQueue.main.async { [weak self] in
-            guard let self,
-                  self.legacyPrivateMediaConsentRequest == nil,
-                  self.pendingLegacyPrivateMediaConsents.first?.request.id == nextRequestID else {
-                return
-            }
-            self.legacyPrivateMediaConsentRequest = self.pendingLegacyPrivateMediaConsents[0].request
-        }
-    }
-}
 // End of ChatViewModel class

bitchat/ViewModels/NostrInboundPipeline.swift

@@ -310,7 +310,7 @@ final class NostrInboundPipeline {
         // claiming to be group traffic over Nostr is ignored.
         // Live voice is mesh-only: latency and relay cost make it
         // meaningless over Nostr.
-        case .verifyChallenge, .verifyResponse, .groupInvite, .groupKeyUpdate, .vouch, .voiceFrame, .privateFile, .authenticatedPeerState:
+        case .verifyChallenge, .verifyResponse, .groupInvite, .groupKeyUpdate, .vouch, .voiceFrame:
             break
         }
     }
@@ -366,7 +366,7 @@ final class NostrInboundPipeline {
         // claiming to be group traffic over Nostr is ignored.
         // Live voice is mesh-only: latency and relay cost make it
         // meaningless over Nostr.
-        case .verifyChallenge, .verifyResponse, .groupInvite, .groupKeyUpdate, .vouch, .voiceFrame, .privateFile, .authenticatedPeerState:
+        case .verifyChallenge, .verifyResponse, .groupInvite, .groupKeyUpdate, .vouch, .voiceFrame:
             break
         }
     }
@@ -449,7 +449,7 @@ final class NostrInboundPipeline {
                         // in v1; group traffic over Nostr is ignored.
                         // Live voice is mesh-only: latency and relay cost make it
                         // meaningless over Nostr.
-                        case .verifyChallenge, .verifyResponse, .groupInvite, .groupKeyUpdate, .vouch, .voiceFrame, .privateFile, .authenticatedPeerState:
+                        case .verifyChallenge, .verifyResponse, .groupInvite, .groupKeyUpdate, .vouch, .voiceFrame:
                             break
                         }
                     }

bitchat/Views/ContentSheetViews.swift

@@ -36,7 +36,6 @@ struct ContentPeopleSheetView: View {
     #endif
 
     var body: some View {
-        let legacyConsentRequest = conversationUIModel.legacyPrivateMediaConsentRequest
         NavigationStack {
             Group {
                 if privateConversationModel.selectedPeerID != nil {
@@ -98,63 +97,6 @@ struct ContentPeopleSheetView: View {
         }
         .themedSheetBackground()
         .foregroundColor(palette.primary)
-        .confirmationDialog(
-            String(
-                localized: "content.private_media.legacy_warning.title",
-                defaultValue: "Send without end-to-end encryption?",
-                comment: "Title warning before sending private media to an older client in a clear signed envelope"
-            ),
-            isPresented: Binding(
-                get: { legacyConsentRequest != nil },
-                set: { isPresented in
-                    if !isPresented, let requestID = legacyConsentRequest?.id {
-                        conversationUIModel.resolveLegacyPrivateMediaConsent(
-                            requestID: requestID,
-                            approved: false
-                        )
-                    }
-                }
-            ),
-            titleVisibility: .visible
-        ) {
-            Button(
-                String(
-                    localized: "content.private_media.legacy_warning.send",
-                    defaultValue: "send visible file",
-                    comment: "Destructive confirmation action for one legacy clear private-media send"
-                ),
-                role: .destructive
-            ) {
-                if let requestID = legacyConsentRequest?.id {
-                    conversationUIModel.resolveLegacyPrivateMediaConsent(
-                        requestID: requestID,
-                        approved: true
-                    )
-                }
-            }
-            Button("common.cancel", role: .cancel) {
-                if let requestID = legacyConsentRequest?.id {
-                    conversationUIModel.resolveLegacyPrivateMediaConsent(
-                        requestID: requestID,
-                        approved: false
-                    )
-                }
-            }
-        } message: {
-            if let request = legacyConsentRequest {
-                Text(
-                    String(
-                        format: String(
-                            localized: "content.private_media.legacy_warning.message",
-                            defaultValue: "%@'s client does not advertise encrypted private media. This file will be signed but not end-to-end encrypted, so mesh relays can see it. Send this file anyway?",
-                            comment: "Warning explaining the confidentiality loss for one legacy private-media send; parameter is the peer name"
-                        ),
-                        locale: .current,
-                        request.peerName
-                    )
-                )
-            }
-        }
         #if os(macOS)
         .frame(minWidth: 420, minHeight: 520)
         #endif

bitchat/Views/ContentView.swift

@@ -36,6 +36,7 @@ struct ContentView: View {
     @EnvironmentObject private var verificationModel: VerificationModel
     @EnvironmentObject private var conversationUIModel: ConversationUIModel
     @EnvironmentObject private var locationChannelsModel: LocationChannelsModel
+    @EnvironmentObject private var sharedContentImportModel: SharedContentImportModel
 
     @StateObject private var voiceRecordingVM = VoiceRecordingViewModel()
     @State private var messageText = ""
@@ -69,6 +70,14 @@ struct ContentView: View {
         privateConversationModel.selectedPeerID
     }
 
+    private var sharedContentDestination: SharedContentDestination {
+        SharedContentDestination.resolve(
+            selectedPrivatePeerID: selectedPrivatePeerID,
+            privateDisplayName: privateConversationModel.selectedHeaderState?.displayName,
+            activeChannel: locationChannelsModel.selectedChannel
+        )
+    }
+
     private var usesGlassLayout: Bool { appTheme.usesGlassChrome }
 
     var body: some View {
@@ -88,6 +97,7 @@ struct ContentView: View {
                     isTextFieldFocused = true
                 }
                 #endif
+                sharedContentImportModel.updateDestination(sharedContentDestination)
             }
             .onChange(of: colorScheme) { newValue in
                 conversationUIModel.setCurrentColorScheme(newValue)
@@ -104,6 +114,10 @@ struct ContentView: View {
             if newValue != nil {
                 showSidebar = true
             }
+            sharedContentImportModel.updateDestination(sharedContentDestination)
+        }
+        .onChange(of: locationChannelsModel.selectedChannel) { _ in
+            sharedContentImportModel.updateDestination(sharedContentDestination)
         }
         .sheet(
             isPresented: Binding(
@@ -230,6 +244,34 @@ struct ContentView: View {
         } message: {
             Text(appChromeModel.bluetoothAlertMessage)
         }
+        .alert(
+            String(localized: "share_import.review.title", comment: "Title for reviewing content received from the share extension"),
+            isPresented: Binding(
+                get: { sharedContentImportModel.offer != nil },
+                set: { _ in }
+            ),
+            presenting: sharedContentImportModel.offer
+        ) { _ in
+            Button("common.cancel", role: .cancel) {
+                sharedContentImportModel.cancel(destination: sharedContentDestination)
+            }
+            Button("share_import.review.use_in_composer") {
+                guard let importedText = sharedContentImportModel.confirm(
+                    destination: sharedContentDestination
+                ) else { return }
+                // Replacing is deliberate and called out in the prompt. It
+                // avoids combining a stale draft from another conversation
+                // with newly shared content.
+                messageText = importedText
+                isTextFieldFocused = true
+            }
+        } message: { offer in
+            let format = String(
+                localized: "share_import.review.message",
+                comment: "Explains that shared content will replace the named destination's composer and will not be sent automatically"
+            )
+            Text(String(format: format, offer.destination.displayName) + "\n\n" + offer.payload.preview)
+        }
         .onDisappear {
             autocompleteDebounceTimer?.invalidate()
             appChromeModel.setPanicPreparation(nil)

bitchatShareExtension/Localization/Localizable.xcstrings

@@ -202,207 +202,6 @@
         }
       }
     },
-    "share.status.failed_to_encode" : {
-      "extractionState" : "manual",
-      "localizations" : {
-        "ar" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "تعذر ترميز الرابط",
-            "comment" : "Shown when the share payload cannot be encoded"
-          }
-        },
-        "bn" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "লিঙ্ক এনকোড করা যায়নি"
-          }
-        },
-        "de" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "link konnte nicht codiert werden",
-            "comment" : "Shown when the share payload cannot be encoded"
-          }
-        },
-        "en" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "failed to encode link",
-            "comment" : "Shown when the share payload cannot be encoded"
-          }
-        },
-        "es" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "no se pudo codificar el enlace",
-            "comment" : "Shown when the share payload cannot be encoded"
-          }
-        },
-        "fa" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "کدگذاری پیوند ناموفق بود"
-          }
-        },
-        "fil" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "hindi ma-encode ang link"
-          }
-        },
-        "fr" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "échec de l'encodage du lien",
-            "comment" : "Shown when the share payload cannot be encoded"
-          }
-        },
-        "he" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "לא ניתן לקודד את הקישור",
-            "comment" : "Shown when the share payload cannot be encoded"
-          }
-        },
-        "hi" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "लिंक एन्कोड नहीं हो सका"
-          }
-        },
-        "id" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "gagal mengodekan tautan",
-            "comment" : "Shown when the share payload cannot be encoded"
-          }
-        },
-        "it" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "impossibile codificare il link",
-            "comment" : "Shown when the share payload cannot be encoded"
-          }
-        },
-        "ja" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "リンクのエンコードに失敗しました",
-            "comment" : "Shown when the share payload cannot be encoded"
-          }
-        },
-        "ko" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "링크를 인코딩하는 데 실패했습니다",
-            "comment" : "Shown when the share payload cannot be encoded"
-          }
-        },
-        "ms" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "gagal mengekod pautan"
-          }
-        },
-        "ne" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "लिङ्क सङ्केत गर्न सकेन",
-            "comment" : "Shown when the share payload cannot be encoded"
-          }
-        },
-        "nl" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "link coderen mislukt"
-          }
-        },
-        "pl" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "nie udało się zakodować linku"
-          }
-        },
-        "pt" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "falha ao codificar a ligação"
-          }
-        },
-        "pt-BR" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "falha ao codificar link",
-            "comment" : "Shown when the share payload cannot be encoded"
-          }
-        },
-        "ru" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "не удалось закодировать ссылку",
-            "comment" : "Shown when the share payload cannot be encoded"
-          }
-        },
-        "sv" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "kunde inte koda länken"
-          }
-        },
-        "ta" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "இணைப்பை என்கோட் செய்ய முடியவில்லை"
-          }
-        },
-        "th" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "เข้ารหัสลิงก์ไม่สำเร็จ"
-          }
-        },
-        "tr" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "bağlantı kodlanamadı",
-            "comment" : "Shown when the share payload cannot be encoded"
-          }
-        },
-        "uk" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "не вдалося закодувати посилання",
-            "comment" : "Shown when the share payload cannot be encoded"
-          }
-        },
-        "ur" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "لنک انکوڈ نہیں ہو سکا"
-          }
-        },
-        "vi" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "không thể mã hóa liên kết"
-          }
-        },
-        "zh-Hans" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "无法编码链接",
-            "comment" : "Shown when the share payload cannot be encoded"
-          }
-        },
-        "zh-Hant" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "無法編碼連結"
-          }
-        }
-      }
-    },
     "share.status.no_shareable_content" : {
       "extractionState" : "manual",
       "localizations" : {
@@ -805,406 +604,76 @@
         }
       }
     },
-    "share.status.shared_link" : {
+    "share.status.failed_to_save" : {
+      "comment" : "Shown when content cannot be staged for the main app",
       "extractionState" : "manual",
       "localizations" : {
-        "ar" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ تم إرسال الرابط إلى bitchat",
-            "comment" : "Confirmation after successfully sharing a link"
-          }
-        },
-        "bn" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ bitchat-এ লিঙ্ক শেয়ার করা হয়েছে"
-          }
-        },
-        "de" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ link zu bitchat geteilt",
-            "comment" : "Confirmation after successfully sharing a link"
-          }
-        },
-        "en" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ shared link to bitchat",
-            "comment" : "Confirmation after successfully sharing a link"
-          }
-        },
-        "es" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ enlace compartido con bitchat",
-            "comment" : "Confirmation after successfully sharing a link"
-          }
-        },
-        "fa" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ پیوند در bitchat به اشتراک گذاشته شد"
-          }
-        },
-        "fil" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ naibahagi ang link sa bitchat"
-          }
-        },
-        "fr" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ lien partagé vers bitchat",
-            "comment" : "Confirmation after successfully sharing a link"
-          }
-        },
-        "he" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ הקישור נשלח אל bitchat",
-            "comment" : "Confirmation after successfully sharing a link"
-          }
-        },
-        "hi" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ bitchat पर लिंक शेयर किया गया"
-          }
-        },
-        "id" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ tautan dikirim ke bitchat",
-            "comment" : "Confirmation after successfully sharing a link"
-          }
-        },
-        "it" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ link inviato a bitchat",
-            "comment" : "Confirmation after successfully sharing a link"
-          }
-        },
-        "ja" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ bitchatにリンクを共有",
-            "comment" : "Confirmation after successfully sharing a link"
-          }
-        },
-        "ko" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ bitchat으로 링크를 공유했습니다",
-            "comment" : "Confirmation after successfully sharing a link"
-          }
-        },
-        "ms" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ pautan dikongsi ke bitchat"
-          }
-        },
-        "ne" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ bitchat मा लिङ्क पठाइयो",
-            "comment" : "Confirmation after successfully sharing a link"
-          }
-        },
-        "nl" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ link gedeeld met bitchat"
-          }
-        },
-        "pl" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ udostępniono link w bitchat"
-          }
-        },
-        "pt" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ ligação enviada para o bitchat"
-          }
-        },
-        "pt-BR" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ link enviado para bitchat",
-            "comment" : "Confirmation after successfully sharing a link"
-          }
-        },
-        "ru" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ ссылка отправлена в bitchat",
-            "comment" : "Confirmation after successfully sharing a link"
-          }
-        },
-        "sv" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ länk delad till bitchat"
-          }
-        },
-        "ta" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ bitchat-க்கு இணைப்பு பகிரப்பட்டது"
-          }
-        },
-        "th" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ แชร์ลิงก์ไปยัง bitchat แล้ว"
-          }
-        },
-        "tr" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ bitchat'e bağlantı paylaşıldı",
-            "comment" : "Confirmation after successfully sharing a link"
-          }
-        },
-        "uk" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ посилання надіслано в bitchat",
-            "comment" : "Confirmation after successfully sharing a link"
-          }
-        },
-        "ur" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ bitchat پر لنک شیئر کر دیا گیا"
-          }
-        },
-        "vi" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ đã chia sẻ liên kết tới bitchat"
-          }
-        },
-        "zh-Hans" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ 已将链接分享至 bitchat",
-            "comment" : "Confirmation after successfully sharing a link"
-          }
-        },
-        "zh-Hant" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ 已將連結分享至 bitchat"
-          }
-        }
+        "ar" : { "stringUnit" : { "state" : "needs_review", "value" : "تعذر الحفظ في bitchat" } },
+        "bn" : { "stringUnit" : { "state" : "needs_review", "value" : "bitchat-এ সংরক্ষণ করা যায়নি" } },
+        "de" : { "stringUnit" : { "state" : "needs_review", "value" : "Konnte nicht in bitchat gespeichert werden" } },
+        "en" : { "stringUnit" : { "state" : "translated", "value" : "Could not save to bitchat" } },
+        "es" : { "stringUnit" : { "state" : "needs_review", "value" : "No se pudo guardar en bitchat" } },
+        "fa" : { "stringUnit" : { "state" : "needs_review", "value" : "ذخیره در bitchat ممکن نشد" } },
+        "fil" : { "stringUnit" : { "state" : "needs_review", "value" : "Hindi ma-save sa bitchat" } },
+        "fr" : { "stringUnit" : { "state" : "needs_review", "value" : "Impossible d’enregistrer dans bitchat" } },
+        "he" : { "stringUnit" : { "state" : "needs_review", "value" : "לא ניתן לשמור ב-bitchat" } },
+        "hi" : { "stringUnit" : { "state" : "needs_review", "value" : "bitchat में सेव नहीं किया जा सका" } },
+        "id" : { "stringUnit" : { "state" : "needs_review", "value" : "Tidak dapat menyimpan ke bitchat" } },
+        "it" : { "stringUnit" : { "state" : "needs_review", "value" : "Impossibile salvare in bitchat" } },
+        "ja" : { "stringUnit" : { "state" : "needs_review", "value" : "bitchat に保存できませんでした" } },
+        "ko" : { "stringUnit" : { "state" : "needs_review", "value" : "bitchat에 저장할 수 없습니다" } },
+        "ms" : { "stringUnit" : { "state" : "needs_review", "value" : "Tidak dapat menyimpan ke bitchat" } },
+        "ne" : { "stringUnit" : { "state" : "needs_review", "value" : "bitchat मा सुरक्षित गर्न सकिएन" } },
+        "nl" : { "stringUnit" : { "state" : "needs_review", "value" : "Kon niet opslaan in bitchat" } },
+        "pl" : { "stringUnit" : { "state" : "needs_review", "value" : "Nie udało się zapisać w bitchat" } },
+        "pt" : { "stringUnit" : { "state" : "needs_review", "value" : "Não foi possível guardar no bitchat" } },
+        "pt-BR" : { "stringUnit" : { "state" : "needs_review", "value" : "Não foi possível salvar no bitchat" } },
+        "ru" : { "stringUnit" : { "state" : "needs_review", "value" : "Не удалось сохранить в bitchat" } },
+        "sv" : { "stringUnit" : { "state" : "needs_review", "value" : "Kunde inte spara i bitchat" } },
+        "ta" : { "stringUnit" : { "state" : "needs_review", "value" : "bitchat-இல் சேமிக்க முடியவில்லை" } },
+        "th" : { "stringUnit" : { "state" : "needs_review", "value" : "บันทึกไปยัง bitchat ไม่ได้" } },
+        "tr" : { "stringUnit" : { "state" : "needs_review", "value" : "bitchat’e kaydedilemedi" } },
+        "uk" : { "stringUnit" : { "state" : "needs_review", "value" : "Не вдалося зберегти в bitchat" } },
+        "ur" : { "stringUnit" : { "state" : "needs_review", "value" : "bitchat میں محفوظ نہیں ہو سکا" } },
+        "vi" : { "stringUnit" : { "state" : "needs_review", "value" : "Không thể lưu vào bitchat" } },
+        "zh-Hans" : { "stringUnit" : { "state" : "needs_review", "value" : "无法保存到 bitchat" } },
+        "zh-Hant" : { "stringUnit" : { "state" : "needs_review", "value" : "無法儲存到 bitchat" } }
       }
     },
-    "share.status.shared_text" : {
+    "share.status.saved_for_review" : {
+      "comment" : "Shown after content is staged for review in the main app",
       "extractionState" : "manual",
       "localizations" : {
-        "ar" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ تم إرسال النص إلى bitchat",
-            "comment" : "Confirmation after successfully sharing text"
-          }
-        },
-        "bn" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ bitchat-এ টেক্সট শেয়ার করা হয়েছে"
-          }
-        },
-        "de" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ text zu bitchat geteilt",
-            "comment" : "Confirmation after successfully sharing text"
-          }
-        },
-        "en" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ shared text to bitchat",
-            "comment" : "Confirmation after successfully sharing text"
-          }
-        },
-        "es" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ texto compartido con bitchat",
-            "comment" : "Confirmation after successfully sharing text"
-          }
-        },
-        "fa" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ متن در bitchat به اشتراک گذاشته شد"
-          }
-        },
-        "fil" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ naibahagi ang teksto sa bitchat"
-          }
-        },
-        "fr" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ texte partagé vers bitchat",
-            "comment" : "Confirmation after successfully sharing text"
-          }
-        },
-        "he" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ הטקסט נשלח אל bitchat",
-            "comment" : "Confirmation after successfully sharing text"
-          }
-        },
-        "hi" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ bitchat पर टेक्स्ट शेयर किया गया"
-          }
-        },
-        "id" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ teks dikirim ke bitchat",
-            "comment" : "Confirmation after successfully sharing text"
-          }
-        },
-        "it" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ testo inviato a bitchat",
-            "comment" : "Confirmation after successfully sharing text"
-          }
-        },
-        "ja" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ bitchatにテキストを共有",
-            "comment" : "Confirmation after successfully sharing text"
-          }
-        },
-        "ko" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ bitchat으로 텍스트를 공유했습니다",
-            "comment" : "Confirmation after successfully sharing text"
-          }
-        },
-        "ms" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ teks dikongsi ke bitchat"
-          }
-        },
-        "ne" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ bitchat मा पाठ पठाइयो",
-            "comment" : "Confirmation after successfully sharing text"
-          }
-        },
-        "nl" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ tekst gedeeld met bitchat"
-          }
-        },
-        "pl" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ udostępniono tekst w bitchat"
-          }
-        },
-        "pt" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ texto enviado para o bitchat"
-          }
-        },
-        "pt-BR" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ texto enviado para bitchat",
-            "comment" : "Confirmation after successfully sharing text"
-          }
-        },
-        "ru" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ текст отправлен в bitchat",
-            "comment" : "Confirmation after successfully sharing text"
-          }
-        },
-        "sv" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ text delad till bitchat"
-          }
-        },
-        "ta" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ bitchat-க்கு உரை பகிரப்பட்டது"
-          }
-        },
-        "th" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ แชร์ข้อความไปยัง bitchat แล้ว"
-          }
-        },
-        "tr" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ bitchat'e metin paylaşıldı",
-            "comment" : "Confirmation after successfully sharing text"
-          }
-        },
-        "uk" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ текст надіслано в bitchat",
-            "comment" : "Confirmation after successfully sharing text"
-          }
-        },
-        "ur" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ bitchat پر متن شیئر کر دیا گیا"
-          }
-        },
-        "vi" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ đã chia sẻ văn bản tới bitchat"
-          }
-        },
-        "zh-Hans" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ 已将文本分享至 bitchat",
-            "comment" : "Confirmation after successfully sharing text"
-          }
-        },
-        "zh-Hant" : {
-          "stringUnit" : {
-            "state" : "needs_review",
-            "value" : "✓ 已將文字分享至 bitchat"
-          }
-        }
+        "ar" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ حُفظ في bitchat — افتح التطبيق للمراجعة" } },
+        "bn" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ bitchat-এ সংরক্ষিত — পর্যালোচনার জন্য অ্যাপটি খুলুন" } },
+        "de" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ In bitchat gespeichert — App zum Prüfen öffnen" } },
+        "en" : { "stringUnit" : { "state" : "translated", "value" : "✓ Saved in bitchat — open the app to review" } },
+        "es" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ Guardado en bitchat — abre la app para revisarlo" } },
+        "fa" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ در bitchat ذخیره شد — برای بازبینی، برنامه را باز کنید" } },
+        "fil" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ Na-save sa bitchat — buksan ang app para suriin" } },
+        "fr" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ Enregistré dans bitchat — ouvrez l’app pour vérifier" } },
+        "he" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ נשמר ב-bitchat — יש לפתוח את האפליקציה לבדיקה" } },
+        "hi" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ bitchat में सेव किया गया — समीक्षा के लिए ऐप खोलें" } },
+        "id" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ Disimpan di bitchat — buka aplikasi untuk meninjau" } },
+        "it" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ Salvato in bitchat — apri l’app per controllare" } },
+        "ja" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ bitchat に保存しました — アプリを開いて確認してください" } },
+        "ko" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ bitchat에 저장됨 — 앱을 열어 검토하세요" } },
+        "ms" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ Disimpan dalam bitchat — buka aplikasi untuk menyemak" } },
+        "ne" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ bitchat मा सुरक्षित गरियो — समीक्षा गर्न एप खोल्नुहोस्" } },
+        "nl" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ Opgeslagen in bitchat — open de app om te bekijken" } },
+        "pl" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ Zapisano w bitchat — otwórz aplikację, aby sprawdzić" } },
+        "pt" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ Guardado no bitchat — abra a app para rever" } },
+        "pt-BR" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ Salvo no bitchat — abra o app para revisar" } },
+        "ru" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ Сохранено в bitchat — откройте приложение для проверки" } },
+        "sv" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ Sparat i bitchat — öppna appen för att granska" } },
+        "ta" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ bitchat-இல் சேமிக்கப்பட்டது — மதிப்பாய்வு செய்ய செயலியைத் திறக்கவும்" } },
+        "th" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ บันทึกใน bitchat แล้ว — เปิดแอปเพื่อตรวจสอบ" } },
+        "tr" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ bitchat’e kaydedildi — incelemek için uygulamayı açın" } },
+        "uk" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ Збережено в bitchat — відкрийте застосунок для перегляду" } },
+        "ur" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ bitchat میں محفوظ ہو گیا — جائزے کے لیے ایپ کھولیں" } },
+        "vi" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ Đã lưu trong bitchat — mở ứng dụng để xem lại" } },
+        "zh-Hans" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ 已保存在 bitchat 中 — 打开应用查看" } },
+        "zh-Hant" : { "stringUnit" : { "state" : "needs_review", "value" : "✓ 已儲存在 bitchat 中 — 開啟 App 查看" } }
       }
     }
   },

bitchatShareExtension/ShareViewController.swift

@@ -19,9 +19,8 @@ final class ShareViewController: UIViewController {
         static let nothingToShare = String(localized: "share.status.nothing_to_share", comment: "Shown when the share extension receives no content")
         static let noShareableContent = String(localized: "share.status.no_shareable_content", comment: "Shown when provided content cannot be shared")
         static let sharedLinkTitleFallback = String(localized: "share.fallback.shared_link_title", comment: "Fallback title when saving a shared link")
-        static let sharedLinkConfirmation = String(localized: "share.status.shared_link", comment: "Confirmation after successfully sharing a link")
-        static let sharedTextConfirmation = String(localized: "share.status.shared_text", comment: "Confirmation after successfully sharing text")
-        static let failedToEncode = String(localized: "share.status.failed_to_encode", comment: "Shown when the share payload cannot be encoded")
+        static let savedForReview = String(localized: "share.status.saved_for_review", comment: "Shown after content is staged for review in the main app")
+        static let failedToSave = String(localized: "share.status.failed_to_save", comment: "Shown when content cannot be staged for the main app")
     }
     
     private let statusLabel: UILabel = {
@@ -44,9 +43,7 @@ final class ShareViewController: UIViewController {
             statusLabel.leadingAnchor.constraint(greaterThanOrEqualTo: view.layoutMarginsGuide.leadingAnchor),
             statusLabel.trailingAnchor.constraint(lessThanOrEqualTo: view.layoutMarginsGuide.trailingAnchor)
         ])
-        DispatchQueue.global().async {
-            self.processShare()
-        }
+        processShare()
     }
 
     // MARK: - Processing
@@ -151,30 +148,33 @@ final class ShareViewController: UIViewController {
 
     // MARK: - Save + Finish
     private func saveAndFinish(url: URL, title: String?) {
-        let payload: [String: String] = [
-            "url": url.absoluteString,
-            "title": title ?? url.host ?? Strings.sharedLinkTitleFallback
-        ]
-        if let json = try? JSONSerialization.data(withJSONObject: payload),
-           let s = String(data: json, encoding: .utf8) {
-            saveToSharedDefaults(content: s, type: "url")
-            finishWithMessage(Strings.sharedLinkConfirmation)
-        } else {
-            finishWithMessage(Strings.failedToEncode)
-        }
+        let payload = SharedContentPayload(
+            kind: .url,
+            content: url.absoluteString,
+            title: title ?? url.host ?? Strings.sharedLinkTitleFallback
+        )
+        stageAndFinish(payload)
     }
 
     private func saveAndFinish(text: String) {
-        saveToSharedDefaults(content: text, type: "text")
-        finishWithMessage(Strings.sharedTextConfirmation)
+        stageAndFinish(.text(text))
     }
 
-    private func saveToSharedDefaults(content: String, type: String) {
-        guard let userDefaults = UserDefaults(suiteName: Self.groupID) else { return }
-        userDefaults.set(content, forKey: "sharedContent")
-        userDefaults.set(type, forKey: "sharedContentType")
-        userDefaults.set(Date(), forKey: "sharedContentDate")
-        // No need to force synchronize; the system persists changes
+    private func stageAndFinish(_ payload: SharedContentPayload) {
+        guard let defaults = UserDefaults(suiteName: Self.groupID) else {
+            finishWithMessage(Strings.failedToSave)
+            return
+        }
+        let store = SharedContentStore(defaults: defaults)
+
+        do {
+            try store.stage(payload)
+            // Staging is not sending. The main app will require a second,
+            // destination-labelled confirmation before filling its composer.
+            finishWithMessage(Strings.savedForReview)
+        } catch {
+            finishWithMessage(Strings.failedToSave)
+        }
     }
 
     private func finishWithMessage(_ msg: String) {

bitchatTests/BLEServiceCoreTests.swift

@@ -502,26 +502,14 @@ struct BLEServiceCoreTests {
         )
         let replay = try #require(victim.signPacket(unsigned), "Failed to sign replayed announce")
         #expect(ble._test_recordIngressIfNew(packet: replay, linkID: attackerLink))
-        let rebindGate = VerifiedDirectRebindGate()
-        ble._test_afterVerifiedDirectRebindEnqueued = rebindGate.pause
-        defer {
-            rebindGate.release()
-            ble._test_afterVerifiedDirectRebindEnqueued = nil
-        }
         ble._test_handlePacket(replay, fromPeerID: victimPeerID, preseedPeer: false)
 
-        let announcePaused = await TestHelpers.waitUntil(
-            { rebindGate.hasPaused },
+        let rebound = await TestHelpers.waitUntil(
+            { ble._test_centralBinding(attackerLink) == victimPeerID },
             timeout: TestConstants.longTimeout
         )
-        try #require(announcePaused)
-
-        // Rebind and ordinary reconnect preparation are one bleQueue
-        // critical section. Once the binding is visible, stale sending keys
-        // must already be unavailable.
-        #expect(ble._test_centralBinding(attackerLink) == victimPeerID)
-        #expect(!ble.canDeliverSecurely(to: victimPeerID))
-        rebindGate.release()
+        #expect(rebound)
+        #expect(ble.canDeliverSecurely(to: victimPeerID))
 
         let outbound = OutboundPacketTap()
         ble._test_onOutboundPacket = { outbound.record($0) }
@@ -549,26 +537,20 @@ struct BLEServiceCoreTests {
 
         // Preserve a working victim session while an unauthenticated
         // replacement candidate arrives on a newly bound physical link.
-        // Establish BLE as responder so the replacement candidate below is
-        // not coalesced by the initiator-completion grace path.
-        let message1 = try victim.initiateHandshake(with: ble.myPeerID)
+        let message1 = try ble._test_noiseInitiateHandshake(with: victimPeerID)
         let message2 = try #require(
-            try ble._test_noiseProcessHandshakeMessage(
-                from: victimPeerID,
-                message: message1
-            )
+            try victim.processHandshakeMessage(from: ble.myPeerID, message: message1)
         )
         let message3 = try #require(
-            try victim.processHandshakeMessage(
-                from: ble.myPeerID,
+            try ble._test_noiseProcessHandshakeMessage(
+                from: victimPeerID,
                 message: message2
             )
         )
-        _ = try ble._test_noiseProcessHandshakeMessage(
-            from: victimPeerID,
+        _ = try victim.processHandshakeMessage(
+            from: ble.myPeerID,
             message: message3
         )
-        await ble._test_drainNoiseMessagePipeline()
         #expect(ble.canDeliverSecurely(to: victimPeerID))
 
         let centralUUID = "central-replacement-xx-message-one"
@@ -632,168 +614,7 @@ struct BLEServiceCoreTests {
                 for: victimPeerID
             )
         )
-        // Ordinary reconnect hardening quarantines the cached transport while
-        // this candidate proves the claimed identity. It must be unavailable
-        // for sending as well as unable to authenticate this ingress link.
-        #expect(!ble.canDeliverSecurely(to: victimPeerID))
-    }
-
-    @Test
-    func failedInboundReconnectRestoresAndDrainsWaitingWorkOnce() async throws {
-        let ble = makeService()
-        let alice = NoiseEncryptionService(keychain: MockKeychain())
-        let mallory = NoiseEncryptionService(keychain: MockKeychain())
-        let alicePeerID = PeerID(publicKey: alice.getStaticPublicKeyData())
-
-        // Establish BLE as responder so the following inbound reconnect is
-        // not intentionally coalesced by the initiator-completion grace path.
-        let message1 = try alice.initiateHandshake(with: ble.myPeerID)
-        let message2 = try #require(
-            try ble._test_noiseProcessHandshakeMessage(
-                from: alicePeerID,
-                message: message1
-            )
-        )
-        let message3 = try #require(
-            try alice.processHandshakeMessage(
-                from: ble.myPeerID,
-                message: message2
-            )
-        )
-        _ = try ble._test_noiseProcessHandshakeMessage(
-            from: alicePeerID,
-            message: message3
-        )
-        await ble._test_drainNoiseMessagePipeline()
-        #expect(ble.canDeliverSecurely(to: alicePeerID))
-
-        let outbound = OutboundPacketTap()
-        ble._test_onOutboundPacket = outbound.record
-        let forgedMessage1 = try mallory.initiateHandshake(with: ble.myPeerID)
-        let firstPacket = BitchatPacket(
-            type: MessageType.noiseHandshake.rawValue,
-            senderID: Data(hexString: alicePeerID.id) ?? Data(),
-            recipientID: Data(hexString: ble.myPeerID.id),
-            timestamp: UInt64(Date().timeIntervalSince1970 * 1_000),
-            payload: forgedMessage1,
-            signature: nil,
-            ttl: 7
-        )
-        ble._test_handlePacket(firstPacket, fromPeerID: alicePeerID)
-
-        let responseReady = await TestHelpers.waitUntil(
-            {
-                outbound.snapshot().contains {
-                    $0.type == MessageType.noiseHandshake.rawValue
-                        && PeerID(hexData: $0.senderID) == ble.myPeerID
-                        && $0.payload.count
-                            != NoiseSecurityConstants.xxInitialMessageSize
-                }
-            },
-            timeout: TestConstants.longTimeout
-        )
-        try #require(responseReady)
-        let forgedMessage2 = try #require(
-            outbound.snapshot().first {
-                $0.type == MessageType.noiseHandshake.rawValue
-                    && PeerID(hexData: $0.senderID) == ble.myPeerID
-                    && $0.payload.count
-                        != NoiseSecurityConstants.xxInitialMessageSize
-            }?.payload
-        )
-        #expect(!ble.canDeliverSecurely(to: alicePeerID))
-
-        // Typed control traffic must queue behind the ordinary responder,
-        // rather than attempting encryption and disappearing.
-        let privateMessageID = "quarantine-pm-\(UUID().uuidString)"
-        ble.sendPrivateMessage(
-            "queued private message",
-            to: alicePeerID,
-            recipientNickname: "Alice",
-            messageID: privateMessageID
-        )
-        ble.sendGroupInvite(Data("queued-during-quarantine".utf8), to: alicePeerID)
-        await ble._test_drainNoiseMessagePipeline()
-        #expect(outbound.count(ofType: .noiseEncrypted) == 0)
-
-        let forgedMessage3 = try #require(
-            try mallory.processHandshakeMessage(
-                from: ble.myPeerID,
-                message: forgedMessage2
-            )
-        )
-        let forgedEarlyPayload = try #require(
-            BLENoisePayloadFactory.privateMessage(
-                content: "forged early message",
-                messageID: "forged-early"
-            )
-        )
-        try #require(
-            mallory.hasEstablishedSession(with: ble.myPeerID),
-            "forged initiator did not establish after producing message three"
-        )
-        let forgedEarlyCiphertext = try mallory.encrypt(
-            forgedEarlyPayload,
-            for: ble.myPeerID
-        )
-        let earlyPacket = BitchatPacket(
-            type: MessageType.noiseEncrypted.rawValue,
-            senderID: Data(hexString: alicePeerID.id) ?? Data(),
-            recipientID: Data(hexString: ble.myPeerID.id),
-            timestamp: UInt64(Date().timeIntervalSince1970 * 1_000) + 1,
-            payload: forgedEarlyCiphertext,
-            signature: nil,
-            ttl: 7
-        )
-        ble._test_handlePacket(earlyPacket, fromPeerID: alicePeerID)
-        await ble._test_drainNoiseMessagePipeline()
-
-        let thirdPacket = BitchatPacket(
-            type: MessageType.noiseHandshake.rawValue,
-            senderID: Data(hexString: alicePeerID.id) ?? Data(),
-            recipientID: Data(hexString: ble.myPeerID.id),
-            timestamp: UInt64(Date().timeIntervalSince1970 * 1_000) + 2,
-            payload: forgedMessage3,
-            signature: nil,
-            ttl: 7
-        )
-        ble._test_handlePacket(thirdPacket, fromPeerID: alicePeerID)
-
-        // Rollback restores the same generation. It retries the bounded early
-        // ciphertext and drains both outbound queues, but must not repeat a
-        // new-generation capability proof or forced announce.
-        let drained = await TestHelpers.waitUntil(
-            { outbound.count(ofType: .noiseEncrypted) >= 2 },
-            timeout: TestConstants.longTimeout
-        )
-        try #require(drained)
-        await ble._test_drainNoiseMessagePipeline()
-        let plaintexts = try outbound.snapshot()
-            .filter { $0.type == MessageType.noiseEncrypted.rawValue }
-            .map { try alice.decrypt($0.payload, from: ble.myPeerID) }
-        #expect(plaintexts.count == 2)
-        #expect(
-            plaintexts.filter {
-                $0.first == NoisePayloadType.authenticatedPeerState.rawValue
-            }.isEmpty
-        )
-        #expect(
-            plaintexts.filter {
-                $0.first == NoisePayloadType.privateMessage.rawValue
-            }.count == 1
-        )
-        #expect(
-            plaintexts.filter {
-                $0.first == NoisePayloadType.groupInvite.rawValue
-            }.count == 1
-        )
-        #expect(outbound.count(ofType: .announce) == 0)
-
-        // A duplicate ready callback cannot replay either buffer.
-        ble._test_reconcileCurrentNoiseSession(for: alicePeerID)
-        await ble._test_drainNoiseMessagePipeline()
-        #expect(outbound.count(ofType: .noiseEncrypted) == 2)
-        #expect(outbound.count(ofType: .announce) == 0)
+        #expect(ble.canDeliverSecurely(to: victimPeerID))
     }
 
     /// A legitimate rotation announce necessarily arrives on a link still
@@ -1122,40 +943,6 @@ private final class OutboundPacketTap {
         lock.lock(); defer { lock.unlock() }
         return packets.filter { $0.type == type.rawValue }.count
     }
-
-    func snapshot() -> [BitchatPacket] {
-        lock.lock(); defer { lock.unlock() }
-        return packets
-    }
-}
-
-private final class VerifiedDirectRebindGate: @unchecked Sendable {
-    private let condition = NSCondition()
-    private var paused = false
-    private var released = false
-
-    var hasPaused: Bool {
-        condition.lock()
-        defer { condition.unlock() }
-        return paused
-    }
-
-    func pause() {
-        condition.lock()
-        paused = true
-        condition.broadcast()
-        while !released {
-            condition.wait()
-        }
-        condition.unlock()
-    }
-
-    func release() {
-        condition.lock()
-        released = true
-        condition.broadcast()
-        condition.unlock()
-    }
 }
 
 private final class ReceivePacketHandoffGate: @unchecked Sendable {
@@ -1289,7 +1076,6 @@ private final class PublicCaptureDelegate: BitchatDelegate {
         defer { lock.unlock() }
         return publicMessages
     }
-
 }
 
 @MainActor

bitchatTests/ChatLiveVoiceCoordinatorTests.swift

@@ -14,7 +14,6 @@ import BitFoundation
 @MainActor
 private final class MockChatLiveVoiceContext: ChatLiveVoiceContext {
     var nickname = "me"
-    var myPeerID = PeerID(str: "0102030405060708")
     var selectedPrivateChatPeer: PeerID?
     var isViewingPublicMeshTimeline = false
     var blockedPeers: Set<PeerID> = []
@@ -24,10 +23,7 @@ private final class MockChatLiveVoiceContext: ChatLiveVoiceContext {
     private(set) var upsertedMessages: [(message: BitchatMessage, peerID: PeerID)] = []
     private(set) var upsertedPublicMessages: [BitchatMessage] = []
     private(set) var removedMessageIDs: [String] = []
-    private(set) var sentReadReceipts: [(receipt: ReadReceipt, peerID: PeerID)] = []
     private(set) var talkerUpdates: [String?] = []
-    private(set) var privateMutationLog: [String] = []
-    private var readReceiptMessageIDs: Set<String> = []
 
     func isPeerBlocked(_ peerID: PeerID) -> Bool { blockedPeers.contains(peerID) }
     func resolveNickname(for peerID: PeerID) -> String { "alice" }
@@ -35,7 +31,6 @@ private final class MockChatLiveVoiceContext: ChatLiveVoiceContext {
     func appendPublicMeshMessage(_ message: BitchatMessage) { appendedPublicMessages.append(message) }
     func upsertPrivateMessage(_ message: BitchatMessage, in peerID: PeerID) {
         upsertedMessages.append((message, peerID))
-        privateMutationLog.append("upsert:\(message.id)")
     }
     func upsertPublicMeshMessage(_ message: BitchatMessage) {
         upsertedPublicMessages.append(message)
@@ -43,18 +38,8 @@ private final class MockChatLiveVoiceContext: ChatLiveVoiceContext {
     @discardableResult
     func removePrivateMessage(withID messageID: String) -> BitchatMessage? {
         removedMessageIDs.append(messageID)
-        privateMutationLog.append("remove:\(messageID)")
         return nil
     }
-    func hasSentReadReceipt(_ messageID: String) -> Bool {
-        readReceiptMessageIDs.contains(messageID)
-    }
-    func markReadReceiptSent(_ messageID: String) -> Bool {
-        readReceiptMessageIDs.insert(messageID).inserted
-    }
-    func sendMeshReadReceipt(_ receipt: ReadReceipt, to peerID: PeerID) {
-        sentReadReceipts.append((receipt, peerID))
-    }
     func removeMessage(withID messageID: String, cleanupFile: Bool) {
         removedMessageIDs.append(messageID)
     }
@@ -166,29 +151,17 @@ struct ChatLiveVoiceCoordinatorTests {
 
     @Test func absorbsFinalizedNoteIntoLiveBubble() throws {
         let context = MockChatLiveVoiceContext()
-        context.selectedPrivateChatPeer = peer
         let coordinator = ChatLiveVoiceCoordinator(context: context, sweepsOnInit: false)
         let burstID = makeBurstID(0xB2)
         let hex = burstID.hexEncodedString()
-        let fileName = "voice_\(hex).m4a"
-        let stableMessageID = try #require(PrivateMediaMessageIdentity.stableID(
-            senderPeerID: peer,
-            recipientPeerID: context.myPeerID,
-            fileName: fileName
-        ))
 
         send(try #require(VoiceBurstPacket(burstID: burstID, seq: 1, kind: .frames([Data(repeating: 7, count: 50)]))), to: coordinator, from: peer)
         send(try #require(VoiceBurstPacket(burstID: burstID, seq: 2, kind: .end(totalDataPackets: 1, durationMs: 64))), to: coordinator, from: peer)
         let bubble = try #require(context.handledPrivateMessages.first)
-        // The user read the live bubble, then left before the finalized file
-        // arrived. Stable-ID adoption must preserve that read state.
-        #expect(context.markReadReceiptSent(bubble.id))
-        context.selectedPrivateChatPeer = nil
 
         let note = BitchatMessage(
-            id: stableMessageID,
             sender: "alice",
-            content: "[voice] \(fileName)",
+            content: "[voice] voice_\(hex).m4a",
             timestamp: Date(),
             isRelay: false,
             isPrivate: true,
@@ -197,21 +170,12 @@ struct ChatLiveVoiceCoordinatorTests {
         )
         #expect(coordinator.absorbFinalizedVoiceNote(note))
 
-        // The finalized note adopts the sender-correlatable ID, removes the
-        // receiver-local live ID, and emits a fresh READ now that the sender
-        // has created its finalized media row.
+        // The note replaced the live bubble in place: same message ID, new
+        // content, partial capture deleted.
         let replacement = try #require(context.upsertedMessages.last)
-        #expect(replacement.message.id == stableMessageID)
+        #expect(replacement.message.id == bubble.id)
         #expect(replacement.message.content == note.content)
         #expect(replacement.peerID == peer)
-        #expect(context.removedMessageIDs.contains(bubble.id))
-        #expect(Array(context.privateMutationLog.suffix(2)) == [
-            "upsert:\(stableMessageID)",
-            "remove:\(bubble.id)"
-        ])
-        #expect(context.sentReadReceipts.count == 1)
-        #expect(context.sentReadReceipts.first?.receipt.originalMessageID == stableMessageID)
-        #expect(context.sentReadReceipts.first?.peerID == peer)
         // The promoted partial capture is deleted in favor of the note.
         let url = try #require(fallbackFileURL(burstID: burstID, peerID: peer))
         #expect(!FileManager.default.fileExists(atPath: url.path))
@@ -485,8 +449,7 @@ struct ChatLiveVoiceCoordinatorTests {
             isRelay: false, isPrivate: true, recipientNickname: "me", senderPeerID: peer
         )
         #expect(coordinator.absorbFinalizedVoiceNote(dmNote))
-        #expect(try #require(context.upsertedMessages.last).message.id == dmNote.id)
-        #expect(context.removedMessageIDs.contains(dmBubble.id))
+        #expect(try #require(context.upsertedMessages.last).message.id == dmBubble.id)
     }
 
     @Test func finalizedNoteBindsToItsAuthenticatedSender() throws {
@@ -516,9 +479,8 @@ struct ChatLiveVoiceCoordinatorTests {
         )
         #expect(coordinator.absorbFinalizedVoiceNote(note))
         let replacement = try #require(context.upsertedMessages.last)
-        #expect(replacement.message.id == note.id)
+        #expect(replacement.message.id == victimBubble.id)
         #expect(replacement.peerID == peer)
-        #expect(context.removedMessageIDs.contains(victimBubble.id))
 
         // The attacker's note can only ever claim the attacker's own bubble.
         let attackerNote = BitchatMessage(
@@ -527,9 +489,8 @@ struct ChatLiveVoiceCoordinatorTests {
         )
         #expect(coordinator.absorbFinalizedVoiceNote(attackerNote))
         let attackerReplacement = try #require(context.upsertedMessages.last)
-        #expect(attackerReplacement.message.id == attackerNote.id)
+        #expect(attackerReplacement.message.id == attackerBubble.id)
         #expect(attackerReplacement.peerID == attacker)
-        #expect(context.removedMessageIDs.contains(attackerBubble.id))
 
         // Both registry entries are consumed — nothing left to hijack.
         #expect(!coordinator.absorbFinalizedVoiceNote(note))

bitchatTests/ChatPeerListCoordinatorContextTests.swift

@@ -104,20 +104,6 @@ private func makeMessage(id: String, senderPeerID: PeerID? = nil) -> BitchatMess
 /// no `ChatViewModel`.
 struct ChatPeerListCoordinatorContextTests {
 
-    @Test @MainActor
-    func synchronousPeerListUpdate_appliesBeforeReturning() {
-        let context = MockChatPeerListContext()
-        let coordinator = ChatPeerListCoordinator(context: context)
-        let peerID = PeerID(str: "0011223344556677")
-
-        coordinator.didUpdatePeerListSynchronously([peerID])
-
-        #expect(context.isConnected)
-        #expect(context.registeredEphemeralSessions == [peerID])
-        #expect(context.updateEncryptionStatusForPeersCount == 1)
-        #expect(context.cleanupOldReadReceiptsCount == 1)
-    }
-
     @Test @MainActor
     func didUpdatePeerList_updatesConnectionSessionsAndEncryptionStatus() async {
         let context = MockChatPeerListContext()

bitchatTests/ChatTransportEventCoordinatorContextTests.swift

@@ -220,85 +220,26 @@ struct ChatTransportEventCoordinatorContextTests {
     func didReceiveMessage_routesPrivateAndPublic_skipsBlockedAndEmpty() async {
         let context = MockChatTransportEventContext()
         let coordinator = ChatTransportEventCoordinator(context: context)
-        let peerID = PeerID(str: "1122334455667788")
 
         // Blocked messages are dropped before any handling.
-        context.blockedMessageIDs = ["blocked", "blocked-private"]
+        context.blockedMessageIDs = ["blocked"]
         coordinator.didReceiveMessage(makeMessage(id: "blocked"))
-        coordinator.didReceiveMessage(makeMessage(
-            id: "blocked-private",
-            isPrivate: true,
-            senderPeerID: peerID
-        ))
         // Empty public content is dropped too.
         coordinator.didReceiveMessage(makeMessage(id: "empty", content: "   "))
         await drainMainActorTasks()
         #expect(context.handledPublicMessages.isEmpty)
         #expect(context.handledPrivateMessages.isEmpty)
         #expect(context.mentionCheckedMessageIDs.isEmpty)
-        #expect(context.meshDeliveryAcks.isEmpty)
 
         // Private goes to the private handler, public to the public handler;
-        // both get mention checks and haptics. Stable-media ACK authorization
-        // belongs to BLEFileTransferHandler after its durable commit and this
-        // synchronous acceptance result, not to the generic UI coordinator.
-        let stableMediaID = "media-\(String(repeating: "a", count: 32))"
-        coordinator.didReceiveMessage(makeMessage(
-            id: stableMediaID,
-            isPrivate: true,
-            senderPeerID: peerID
-        ))
-        coordinator.didReceiveMessage(makeMessage(
-            id: "legacy-media",
-            isPrivate: true,
-            senderPeerID: peerID
-        ))
-        coordinator.didReceiveMessage(makeMessage(id: "pm-missing-sender", isPrivate: true))
+        // both get mention checks and haptics.
+        coordinator.didReceiveMessage(makeMessage(id: "pm", isPrivate: true))
         coordinator.didReceiveMessage(makeMessage(id: "pub"))
         await drainMainActorTasks()
-        #expect(context.handledPrivateMessages.map(\.id) == [
-            stableMediaID,
-            "legacy-media",
-            "pm-missing-sender"
-        ])
+        #expect(context.handledPrivateMessages.map(\.id) == ["pm"])
         #expect(context.handledPublicMessages.map(\.id) == ["pub"])
-        #expect(context.mentionCheckedMessageIDs == [
-            stableMediaID,
-            "legacy-media",
-            "pm-missing-sender",
-            "pub"
-        ])
-        #expect(context.hapticMessageIDs == [
-            stableMediaID,
-            "legacy-media",
-            "pm-missing-sender",
-            "pub"
-        ])
-        #expect(context.meshDeliveryAcks.isEmpty)
-    }
-
-    @Test @MainActor
-    func synchronousMessageDeliveryReportsAcceptanceForAckGating() {
-        let context = MockChatTransportEventContext()
-        let coordinator = ChatTransportEventCoordinator(context: context)
-        let peerID = PeerID(str: "1122334455667788")
-        let blocked = makeMessage(
-            id: "blocked-private-media",
-            isPrivate: true,
-            senderPeerID: peerID
-        )
-        context.blockedMessageIDs = [blocked.id]
-
-        #expect(coordinator.didReceiveMessageSynchronously(blocked) == false)
-        #expect(context.handledPrivateMessages.isEmpty)
-
-        let accepted = makeMessage(
-            id: "accepted-private-media",
-            isPrivate: true,
-            senderPeerID: peerID
-        )
-        #expect(coordinator.didReceiveMessageSynchronously(accepted) == true)
-        #expect(context.handledPrivateMessages.map(\.id) == [accepted.id])
+        #expect(context.mentionCheckedMessageIDs == ["pm", "pub"])
+        #expect(context.hapticMessageIDs == ["pm", "pub"])
     }
 
     @Test @MainActor
@@ -354,32 +295,6 @@ struct ChatTransportEventCoordinatorContextTests {
         #expect(context.notifyUIChangedCount == 2)
     }
 
-    @Test @MainActor
-    func synchronousConnectAndDisconnect_applyBeforeReturning() {
-        let context = MockChatTransportEventContext()
-        let coordinator = ChatTransportEventCoordinator(context: context)
-        let peerID = PeerID(str: "2233445566778899")
-        let incoming = makeMessage(
-            id: "incoming-receipt",
-            isPrivate: true,
-            senderPeerID: peerID
-        )
-        context.privateChats[peerID] = [incoming]
-
-        coordinator.didConnectToPeerSynchronously(peerID)
-
-        #expect(context.isConnected)
-        #expect(context.registeredEphemeralSessions == [peerID])
-        #expect(context.flushedOutboxPeerIDs == [peerID])
-        #expect(context.courierRetryPeerIDs == [peerID])
-
-        coordinator.didDisconnectFromPeerSynchronously(peerID)
-
-        #expect(context.removedEphemeralSessions == [peerID])
-        #expect(context.unmarkedReadReceiptBatches == [[incoming.id]])
-        #expect(context.notifyUIChangedCount == 2)
-    }
-
     @Test @MainActor
     func didDisconnect_whileViewingChat_migratesConversationToStablePeerID() async {
         let context = MockChatTransportEventContext()

bitchatTests/ChatVerificationCoordinatorContextTests.swift

@@ -97,7 +97,6 @@ private final class MockChatVerificationContext: ChatVerificationContext {
     var noiseSessionKeysByPeerID: [PeerID: Data] = [:]
     private(set) var installedCallbacks: (onPeerAuthenticated: (PeerID, String) -> Void, onHandshakeRequired: (PeerID) -> Void)?
     private(set) var triggeredHandshakes: [PeerID] = []
-    private(set) var privateMediaAuthenticatedPeers: [PeerID] = []
     private(set) var sentChallenges: [(peerID: PeerID, noiseKeyHex: String, nonceA: Data)] = []
     private(set) var sentResponses: [(peerID: PeerID, noiseKeyHex: String, nonceA: Data)] = []
 
@@ -114,9 +113,6 @@ private final class MockChatVerificationContext: ChatVerificationContext {
         establishedNoiseSessions.contains(peerID)
     }
     func triggerHandshake(with peerID: PeerID) { triggeredHandshakes.append(peerID) }
-    func privateMediaPeerDidAuthenticate(_ peerID: PeerID) {
-        privateMediaAuthenticatedPeers.append(peerID)
-    }
 
     func sendVerifyChallenge(to peerID: PeerID, noiseKeyHex: String, nonceA: Data) {
         sentChallenges.append((peerID, noiseKeyHex, nonceA))
@@ -281,7 +277,6 @@ struct ChatVerificationCoordinatorContextTests {
         #expect(context.encryptionStatuses[peerID] == .noiseVerified)
         #expect(context.stablePeerIDCache[peerID] == PeerID(hexData: noiseKey))
         #expect(context.invalidatedEncryptionCachePeers.contains(peerID))
-        #expect(context.privateMediaAuthenticatedPeers == [peerID])
 
         // Handshake required -> handshaking status.
         callbacks?.onHandshakeRequired(peerID)

bitchatTests/ChatViewModelExtensionsTests.swift

@@ -1048,89 +1048,6 @@ struct ChatViewModelMediaTransferTests {
         #expect(viewModel.transferIdToMessageIDs.count == 1)
     }
 
-    @Test @MainActor
-    func legacyPrivateMediaConsentRequestsArePerSendAndQueued() async throws {
-        let (viewModel, _) = makeTestableViewModel()
-        let firstPeer = PeerID(str: "1111111111111111")
-        let secondPeer = PeerID(str: "2222222222222222")
-        var decisions: [Bool] = []
-
-        viewModel.enqueueLegacyPrivateMediaConsent(
-            for: firstPeer,
-            transferId: "transfer-1",
-            messageID: "message-1"
-        ) { decisions.append($0) }
-        viewModel.enqueueLegacyPrivateMediaConsent(
-            for: secondPeer,
-            transferId: "transfer-2",
-            messageID: "message-2"
-        ) { decisions.append($0) }
-
-        #expect(viewModel.legacyPrivateMediaConsentRequest?.peerID == firstPeer)
-        let firstRequestID = try #require(viewModel.legacyPrivateMediaConsentRequest?.id)
-        viewModel.resolveLegacyPrivateMediaConsent(requestID: firstRequestID, approved: true)
-        let showedSecond = await TestHelpers.waitUntil(
-            { viewModel.legacyPrivateMediaConsentRequest?.peerID == secondPeer },
-            timeout: TestConstants.longTimeout
-        )
-        #expect(showedSecond)
-        let secondRequestID = try #require(viewModel.legacyPrivateMediaConsentRequest?.id)
-
-        // A button action and the dialog binding may both resolve the first
-        // ID. The stale second callback must not consume the queued request.
-        viewModel.resolveLegacyPrivateMediaConsent(requestID: firstRequestID, approved: false)
-        #expect(decisions == [true])
-        #expect(viewModel.legacyPrivateMediaConsentRequest?.id == secondRequestID)
-
-        viewModel.resolveLegacyPrivateMediaConsent(requestID: secondRequestID, approved: false)
-
-        #expect(decisions == [true, false])
-        #expect(viewModel.legacyPrivateMediaConsentRequest == nil)
-    }
-
-    @Test @MainActor
-    func invalidatingPresentedLegacyConsentAdvancesQueueAndStaleResolutionNoops() async throws {
-        let (viewModel, _) = makeTestableViewModel()
-        let firstPeer = PeerID(str: "3333333333333333")
-        let secondPeer = PeerID(str: "4444444444444444")
-        var decisions: [String] = []
-
-        viewModel.enqueueLegacyPrivateMediaConsent(
-            for: firstPeer,
-            transferId: "transfer-cancelled",
-            messageID: "message-cancelled"
-        ) { decisions.append("first:\($0)") }
-        viewModel.enqueueLegacyPrivateMediaConsent(
-            for: secondPeer,
-            transferId: "transfer-kept",
-            messageID: "message-kept"
-        ) { decisions.append("second:\($0)") }
-
-        let cancelledRequestID = try #require(viewModel.legacyPrivateMediaConsentRequest?.id)
-        viewModel.invalidateLegacyPrivateMediaConsent(
-            transferId: "transfer-cancelled",
-            messageID: "message-cancelled"
-        )
-        let advanced = await TestHelpers.waitUntil(
-            { viewModel.legacyPrivateMediaConsentRequest?.peerID == secondPeer },
-            timeout: TestConstants.longTimeout
-        )
-        #expect(advanced)
-        #expect(decisions.isEmpty, "Invalidation drops the request rather than resolving its send")
-
-        viewModel.resolveLegacyPrivateMediaConsent(
-            requestID: cancelledRequestID,
-            approved: true
-        )
-        #expect(viewModel.legacyPrivateMediaConsentRequest?.peerID == secondPeer)
-        #expect(decisions.isEmpty)
-
-        let keptRequestID = try #require(viewModel.legacyPrivateMediaConsentRequest?.id)
-        viewModel.resolveLegacyPrivateMediaConsent(requestID: keptRequestID, approved: true)
-        #expect(decisions == ["second:true"])
-        #expect(viewModel.legacyPrivateMediaConsentRequest == nil)
-    }
-
     @Test @MainActor
     func sendVoiceNote_oversizedFileFailsAndDeletesTempFile() async throws {
         let (viewModel, transport) = makeTestableViewModel()

bitchatTests/ChatViewModelTests.swift

@@ -864,80 +864,6 @@ struct ChatViewModelPublicConversationTests {
 
 struct ChatViewModelPeerTests {
 
-    @Test @MainActor
-    func typedPeerLifecycleEvents_applyBeforeReturning() {
-        let (viewModel, _) = makeTestableViewModel()
-        let peerID = PeerID(str: "1122334455667788")
-        let incoming = BitchatMessage(
-            id: "typed-peer-incoming",
-            sender: "Alice",
-            content: "Hello",
-            timestamp: Date(),
-            isRelay: false,
-            isPrivate: true,
-            recipientNickname: viewModel.nickname,
-            senderPeerID: peerID
-        )
-        viewModel.seedPrivateChat([incoming], for: peerID)
-        viewModel.sentReadReceipts.insert(incoming.id)
-
-        viewModel.didReceiveTransportEvent(.peerConnected(peerID))
-
-        #expect(viewModel.isConnected)
-
-        viewModel.didReceiveTransportEvent(.peerDisconnected(peerID))
-
-        #expect(!viewModel.sentReadReceipts.contains(incoming.id))
-    }
-
-    @Test @MainActor
-    func typedPeerListDeliveryAndBluetoothEvents_applyBeforeReturning() {
-        let (viewModel, transport) = makeTestableViewModel()
-        let stalePeer = PeerID(str: "00000000000000a2")
-        let deliveryPeer = PeerID(str: "0102030405060708")
-        let messageID = "typed-delivery-status"
-        let delivered = DeliveryStatus.delivered(
-            to: "Alice",
-            at: Date(timeIntervalSince1970: 1_234)
-        )
-        let outgoing = BitchatMessage(
-            id: messageID,
-            sender: viewModel.nickname,
-            content: "On the way",
-            timestamp: Date(),
-            isRelay: false,
-            isPrivate: true,
-            recipientNickname: "Alice",
-            senderPeerID: transport.myPeerID,
-            deliveryStatus: .sent
-        )
-        viewModel.markPrivateChatUnread(stalePeer)
-        viewModel.seedPrivateChat([outgoing], for: deliveryPeer)
-
-        viewModel.didReceiveTransportEvent(.peerListUpdated([]))
-        #expect(!viewModel.unreadPrivateMessages.contains(stalePeer))
-
-        viewModel.didReceiveTransportEvent(
-            .messageDeliveryStatusUpdated(
-                messageID: messageID,
-                status: delivered
-            )
-        )
-        #expect(
-            viewModel.privateMessages(for: deliveryPeer).first?.deliveryStatus
-                == delivered
-        )
-
-        viewModel.didReceiveTransportEvent(.bluetoothStateUpdated(.poweredOff))
-        #expect(viewModel.bluetoothState == .poweredOff)
-        #expect(viewModel.showBluetoothAlert)
-
-        // Snapshot events belong to TransportPeerEventsDelegate and are
-        // intentionally ignored at this typed sink.
-        viewModel.didReceiveTransportEvent(.peerSnapshotsUpdated([]))
-        #expect(viewModel.bluetoothState == .poweredOff)
-    }
-
     @Test @MainActor
     func didConnectToPeer_notifiesDelegate() async {
         let (_, transport) = makeTestableViewModel()

bitchatTests/ConversationStoreTests.swift

@@ -45,6 +45,154 @@ private func makeDirectConversationID(_ suffix: String) -> ConversationID {
     ))
 }
 
+/// Deliberately simple O(n) model used to differentially test the store's
+/// optimized logical-index bookkeeping. It models observable behavior only;
+/// it has no offset or ID index and therefore cannot reproduce the same bug.
+private struct ReferenceConversationTimeline {
+    struct Message: Equatable {
+        let id: String
+        let timestamp: Date
+        let content: String
+        var deliveryStatus: DeliveryStatus?
+
+        init(_ message: BitchatMessage) {
+            id = message.id
+            timestamp = message.timestamp
+            content = message.content
+            deliveryStatus = message.deliveryStatus
+        }
+    }
+
+    struct AppendResult {
+        let inserted: Bool
+        let trimmedCount: Int
+    }
+
+    let cap: Int
+    private(set) var messages: [Message] = []
+
+    func contains(_ id: String) -> Bool {
+        messages.contains { $0.id == id }
+    }
+
+    mutating func append(_ message: BitchatMessage) -> AppendResult {
+        guard !contains(message.id) else {
+            return AppendResult(inserted: false, trimmedCount: 0)
+        }
+
+        let snapshot = Message(message)
+        var low = 0
+        var high = messages.count
+        while low < high {
+            let mid = (low + high) / 2
+            if messages[mid].timestamp <= snapshot.timestamp {
+                low = mid + 1
+            } else {
+                high = mid
+            }
+        }
+        messages.insert(snapshot, at: low)
+
+        let overflow = max(0, messages.count - cap)
+        if overflow > 0 {
+            messages.removeFirst(overflow)
+        }
+        return AppendResult(inserted: true, trimmedCount: overflow)
+    }
+
+    mutating func upsert(_ message: BitchatMessage) -> Int {
+        if let index = messages.firstIndex(where: { $0.id == message.id }) {
+            messages[index] = Message(message)
+            return 0
+        }
+        return append(message).trimmedCount
+    }
+
+    mutating func applyDeliveryStatus(_ status: DeliveryStatus, to id: String) -> Bool {
+        guard let index = messages.firstIndex(where: { $0.id == id }),
+              messages[index].deliveryStatus != status else {
+            return false
+        }
+        // The differential stream uses only unique `.delivered` values (or
+        // an exact repeat), so no-downgrade policy is intentionally outside
+        // this index-focused reference model.
+        messages[index].deliveryStatus = status
+        return true
+    }
+
+    mutating func remove(at index: Int) -> Message {
+        messages.remove(at: index)
+    }
+
+    mutating func removeAll(where predicate: (Message) -> Bool) {
+        messages.removeAll(where: predicate)
+    }
+
+    mutating func clear() {
+        messages.removeAll()
+    }
+}
+
+private struct ConversationStoreDifferentialRNG {
+    private var state: UInt64
+
+    init(seed: UInt64) {
+        state = seed
+    }
+
+    mutating func next() -> UInt64 {
+        state &+= 0x9E37_79B9_7F4A_7C15
+        var value = state
+        value = (value ^ (value >> 30)) &* 0xBF58_476D_1CE4_E5B9
+        value = (value ^ (value >> 27)) &* 0x94D0_49BB_1331_11EB
+        return value ^ (value >> 31)
+    }
+
+    mutating func index(upperBound: Int) -> Int {
+        precondition(upperBound > 0)
+        return Int(next() % UInt64(upperBound))
+    }
+}
+
+@MainActor
+private func expectStore(
+    _ store: ConversationStore,
+    matches reference: ReferenceConversationTimeline,
+    issuedIDs: [String],
+    checkpoint: String
+) {
+    let conversation = store.conversation(for: .mesh)
+    let actual = conversation.messages.map(ReferenceConversationTimeline.Message.init)
+    #expect(actual == reference.messages, "timeline mismatch at \(checkpoint)")
+
+    let lookupSnapshot = reference.messages.compactMap { expected in
+        conversation.message(withID: expected.id).map(ReferenceConversationTimeline.Message.init)
+    }
+    #expect(lookupSnapshot == reference.messages, "ID lookup mismatch at \(checkpoint)")
+    #expect(
+        Set(conversation.messageIDs) == Set(reference.messages.map(\.id)),
+        "per-conversation ID set mismatch at \(checkpoint)"
+    )
+
+    if !reference.messages.isEmpty {
+        for index in Set([0, reference.messages.count / 2, reference.messages.count - 1]) {
+            let id = reference.messages[index].id
+            #expect(store.conversationIDs(forMessageID: id) == [.mesh], "store ID map mismatch at \(checkpoint)")
+        }
+    }
+
+    let activeIDs = Set(reference.messages.map(\.id))
+    var checkedStaleIDs = 0
+    for id in issuedIDs.reversed() where !activeIDs.contains(id) {
+        #expect(conversation.message(withID: id) == nil, "stale conversation index entry at \(checkpoint)")
+        #expect(store.conversationIDs(forMessageID: id).isEmpty, "stale store ID map entry at \(checkpoint)")
+        checkedStaleIDs += 1
+        if checkedStaleIDs == 16 { break }
+    }
+
+    #expect(store.auditInvariants().isEmpty, "invariant audit failed at \(checkpoint)")
+}
+
 @Suite("ConversationStore")
 struct ConversationStoreTests {
 
@@ -140,6 +288,282 @@ struct ConversationStoreTests {
         #expect(conversation.message(withID: probeID)?.deliveryStatus == .sent)
     }
 
+    @Test("steady-state cap trimming keeps lookups exact across mixed mutations")
+    @MainActor
+    func steadyStateCapTrimmingKeepsLogicalIndexExact() {
+        let store = ConversationStore()
+        let conversation = store.conversation(for: .mesh)
+        let overflow = 64
+
+        for i in 0..<(conversation.cap + overflow) {
+            store.append(makeMessage(id: "m\(i)", timestamp: TimeInterval(i)), to: .mesh)
+        }
+
+        #expect(conversation.messages.first?.id == "m\(overflow)")
+        #expect(conversation.message(withID: "m\(overflow)")?.id == "m\(overflow)")
+
+        // Exercise a suffix reindex after the head offset has advanced, then
+        // trim the old head. The late row becomes the new first element.
+        let late = makeMessage(id: "late", timestamp: TimeInterval(overflow) + 0.5)
+        #expect(store.append(late, to: .mesh))
+        #expect(conversation.messages.first?.id == "late")
+        #expect(conversation.message(withID: "m\(overflow + 1)")?.id == "m\(overflow + 1)")
+
+        // Head and middle removals, an in-place upsert, and a status update
+        // must all resolve through the same logical index representation.
+        #expect(store.removeMessage(withID: "late", from: .mesh)?.id == "late")
+        let middleID = "m\(overflow + conversation.cap / 2)"
+        #expect(store.removeMessage(withID: middleID, from: .mesh)?.id == middleID)
+
+        let probeID = "m\(overflow + 10)"
+        store.upsertByID(
+            makeMessage(id: probeID, timestamp: TimeInterval(overflow + 10), content: "edited"),
+            in: .mesh
+        )
+        #expect(conversation.message(withID: probeID)?.content == "edited")
+        #expect(store.setDeliveryStatus(.sent, forMessageID: probeID, in: .mesh))
+        #expect(conversation.message(withID: probeID)?.deliveryStatus == .sent)
+        #expect(store.auditInvariants().isEmpty)
+
+        // Clearing resets the logical offset as well as the maps.
+        store.clear(.mesh)
+        #expect(store.append(makeMessage(id: "after-clear", timestamp: 10_000), to: .mesh))
+        #expect(conversation.message(withID: "after-clear")?.id == "after-clear")
+        #expect(store.auditInvariants().isEmpty)
+    }
+
+    @Test("logical index offset matches a reference model under adversarial mutations")
+    @MainActor
+    func logicalIndexOffsetDifferentialStress() async {
+        let store = ConversationStore()
+        let cap = store.conversation(for: .mesh).cap
+        var reference = ReferenceConversationTimeline(cap: cap)
+        var rng = ConversationStoreDifferentialRNG(seed: 0xC0FF_EE13_37CA_FE42)
+        var issuedIDs: [String] = []
+        var nextID = 0
+        var nextTailTimestamp: TimeInterval = 1_700_000_000
+        var trimmedCount = 0
+
+        var tailAppendCount = 0
+        var outOfOrderCount = 0
+        var duplicateOrReuseCount = 0
+        var headRemovalCount = 0
+        var middleRemovalCount = 0
+        var upsertCount = 0
+        var deliveryUpdateCount = 0
+        var filterCount = 0
+        var clearCount = 0
+
+        func issueMessage(timestamp: TimeInterval? = nil, tag: String) -> BitchatMessage {
+            let number = nextID
+            nextID += 1
+            let id = "diff-\(number)"
+            issuedIDs.append(id)
+            let resolvedTimestamp: TimeInterval
+            if let timestamp {
+                resolvedTimestamp = timestamp
+            } else {
+                resolvedTimestamp = nextTailTimestamp
+                nextTailTimestamp += 1
+            }
+            let dropMarker = number.isMultiple(of: 11) ? " [drop]" : ""
+            return makeMessage(
+                id: id,
+                timestamp: resolvedTimestamp,
+                content: "\(tag) \(number)\(dropMarker)"
+            )
+        }
+
+        @discardableResult
+        func appendAndCompare(_ message: BitchatMessage, checkpoint: String) -> ReferenceConversationTimeline.AppendResult {
+            let expected = reference.append(message)
+            let actual = store.append(message, to: .mesh)
+            #expect(actual == expected.inserted, "append result mismatch at \(checkpoint)")
+            trimmedCount += expected.trimmedCount
+            return expected
+        }
+
+        func refill(extra: Int, checkpoint: String) async {
+            let appendCount = max(0, cap - reference.messages.count) + extra
+            for index in 0..<appendCount {
+                appendAndCompare(
+                    issueMessage(tag: "refill"),
+                    checkpoint: "\(checkpoint)-\(index)"
+                )
+                if index.isMultiple(of: 64) {
+                    await Task.yield()
+                }
+            }
+            expectStore(store, matches: reference, issuedIDs: issuedIDs, checkpoint: checkpoint)
+        }
+
+        // Start well into steady state so the offset is already non-zero
+        // before any mixed operations begin.
+        await refill(extra: 384, checkpoint: "initial steady-state fill")
+
+        for step in 0..<1_200 {
+            if step == 300 || step == 900 {
+                store.removeMessages(from: .mesh) { $0.content.contains("[drop]") }
+                reference.removeAll { $0.content.contains("[drop]") }
+                filterCount += 1
+                expectStore(
+                    store,
+                    matches: reference,
+                    issuedIDs: issuedIDs,
+                    checkpoint: "filter at step \(step)"
+                )
+            }
+
+            if step == 600 {
+                store.clear(.mesh)
+                reference.clear()
+                clearCount += 1
+                expectStore(
+                    store,
+                    matches: reference,
+                    issuedIDs: issuedIDs,
+                    checkpoint: "clear at step \(step)"
+                )
+            }
+
+            switch rng.index(upperBound: 100) {
+            case 0..<35:
+                appendAndCompare(issueMessage(tag: "tail"), checkpoint: "tail append \(step)")
+                tailAppendCount += 1
+
+            case 35..<55:
+                if reference.messages.isEmpty {
+                    appendAndCompare(issueMessage(tag: "tail-fallback"), checkpoint: "OOO fallback \(step)")
+                } else {
+                    let target = reference.messages[rng.index(upperBound: reference.messages.count)]
+                    let jitter = [-0.25, 0.0, 0.25][rng.index(upperBound: 3)]
+                    let timestamp = target.timestamp.timeIntervalSince1970 + jitter
+                    appendAndCompare(
+                        issueMessage(timestamp: timestamp, tag: "out-of-order"),
+                        checkpoint: "out-of-order append \(step)"
+                    )
+                    outOfOrderCount += 1
+                }
+
+            case 55..<65:
+                if issuedIDs.isEmpty {
+                    appendAndCompare(issueMessage(tag: "reuse-fallback"), checkpoint: "reuse fallback \(step)")
+                } else {
+                    let reusedID = issuedIDs[rng.index(upperBound: issuedIDs.count)]
+                    let message = makeMessage(
+                        id: reusedID,
+                        timestamp: nextTailTimestamp,
+                        content: "duplicate-or-trimmed-reuse \(step)"
+                    )
+                    nextTailTimestamp += 1
+                    appendAndCompare(message, checkpoint: "duplicate or reuse \(step)")
+                    duplicateOrReuseCount += 1
+                }
+
+            case 65..<73:
+                if !reference.messages.isEmpty {
+                    let expected = reference.remove(at: 0)
+                    let actual = store.removeMessage(withID: expected.id, from: .mesh)
+                        .map(ReferenceConversationTimeline.Message.init)
+                    #expect(actual == expected, "head removal mismatch at step \(step)")
+                    headRemovalCount += 1
+                }
+
+            case 73..<81:
+                if !reference.messages.isEmpty {
+                    let middleStart = reference.messages.count / 4
+                    let middleWidth = max(1, reference.messages.count / 2)
+                    let index = min(
+                        reference.messages.count - 1,
+                        middleStart + rng.index(upperBound: middleWidth)
+                    )
+                    let expected = reference.remove(at: index)
+                    let actual = store.removeMessage(withID: expected.id, from: .mesh)
+                        .map(ReferenceConversationTimeline.Message.init)
+                    #expect(actual == expected, "middle removal mismatch at step \(step)")
+                    middleRemovalCount += 1
+                }
+
+            case 81..<90:
+                let message: BitchatMessage
+                if step.isMultiple(of: 4) || reference.messages.isEmpty {
+                    let timestamp = reference.messages.isEmpty
+                        ? nil
+                        : reference.messages[rng.index(upperBound: reference.messages.count)]
+                            .timestamp.timeIntervalSince1970
+                    message = issueMessage(timestamp: timestamp, tag: "upsert-new")
+                } else {
+                    let current = reference.messages[rng.index(upperBound: reference.messages.count)]
+                    message = makeMessage(
+                        id: current.id,
+                        timestamp: current.timestamp.timeIntervalSince1970,
+                        content: "upsert-existing \(step)",
+                        deliveryStatus: current.deliveryStatus
+                    )
+                }
+                trimmedCount += reference.upsert(message)
+                store.upsertByID(message, in: .mesh)
+                upsertCount += 1
+
+            default:
+                let id: String
+                let repeatedStatus: DeliveryStatus?
+                if step.isMultiple(of: 6) || reference.messages.isEmpty {
+                    id = "missing-\(step)"
+                    repeatedStatus = nil
+                } else {
+                    let current = reference.messages[rng.index(upperBound: reference.messages.count)]
+                    id = current.id
+                    repeatedStatus = current.deliveryStatus
+                }
+                let status: DeliveryStatus
+                if step.isMultiple(of: 4), let repeatedStatus {
+                    status = repeatedStatus
+                } else {
+                    status = .delivered(
+                        to: "peer",
+                        at: Date(timeIntervalSince1970: 2_000_000_000 + Double(step))
+                    )
+                }
+                let expected = reference.applyDeliveryStatus(status, to: id)
+                let actual = store.setDeliveryStatus(status, forMessageID: id, in: .mesh)
+                #expect(actual == expected, "delivery update mismatch at step \(step)")
+                deliveryUpdateCount += 1
+            }
+
+            expectStore(
+                store,
+                matches: reference,
+                issuedIDs: issuedIDs,
+                checkpoint: "mixed operation \(step)"
+            )
+
+            // This intentionally expensive MainActor stress test runs beside
+            // async audio/UI tests in SwiftPM's parallel phase. Cooperatively
+            // release the actor so their bounded waits can make progress.
+            await Task.yield()
+
+            if (step + 1).isMultiple(of: 100) {
+                await refill(extra: 32, checkpoint: "periodic refill after step \(step)")
+            }
+        }
+
+        // Guarantee another long run of one-row evictions after every other
+        // mutation family has perturbed and rebuilt the offset/index state.
+        await refill(extra: 512, checkpoint: "final steady-state trim run")
+
+        #expect(trimmedCount > 1_200)
+        #expect(tailAppendCount > 300)
+        #expect(outOfOrderCount > 150)
+        #expect(duplicateOrReuseCount > 75)
+        #expect(headRemovalCount > 50)
+        #expect(middleRemovalCount > 50)
+        #expect(upsertCount > 75)
+        #expect(deliveryUpdateCount > 75)
+        #expect(filterCount == 2)
+        #expect(clearCount == 1)
+    }
+
     // MARK: - Upsert
 
     @Test("upsertByID replaces in place and appends when absent")

bitchatTests/Integration/IntegrationTests.swift

@@ -12,7 +12,6 @@ import Testing
 @testable import BitFoundation // to avoid unnecessary public's
 @testable import bitchat
 
-@Suite("Integration Tests", .serialized)
 struct IntegrationTests {
     
     private var helper = TestNetworkHelper()
@@ -273,18 +272,8 @@ struct IntegrationTests {
         // Re-establish Noise handshake explicitly via managers
         do {
             let m1 = try helper.noiseManagers["Bob"]!.initiateHandshake(with: helper.nodes["Alice"]!.peerID)
-            let m2 = try #require(
-                try helper.noiseManagers["Alice"]!.handleIncomingHandshake(
-                    from: helper.nodes["Bob"]!.peerID,
-                    message: m1
-                )
-            )
-            let m3 = try #require(
-                try helper.noiseManagers["Bob"]!.handleIncomingHandshake(
-                    from: helper.nodes["Alice"]!.peerID,
-                    message: m2
-                )
-            )
+            let m2 = try helper.noiseManagers["Alice"]!.handleIncomingHandshake(from: helper.nodes["Bob"]!.peerID, message: m1)!
+            let m3 = try helper.noiseManagers["Bob"]!.handleIncomingHandshake(from: helper.nodes["Alice"]!.peerID, message: m2)!
             _ = try helper.noiseManagers["Alice"]!.handleIncomingHandshake(from: helper.nodes["Bob"]!.peerID, message: m3)
         } catch {
             Issue.record("Failed to re-establish Noise session after restart: \(error)")

bitchatTests/Integration/TestNetworkHelper.swift

@@ -8,7 +8,6 @@
 
 import Foundation
 import CryptoKit
-import Testing
 @testable import BitFoundation // to avoid unnecessary public's
 @testable import bitchat
 
@@ -28,14 +27,9 @@ final class TestNetworkHelper {
         node.mockNickname = name
         nodes[name] = node
         
-        // This synchronous helper directly drives all three XX messages and
-        // has no transport callback loop for delayed collision recovery.
+        // Create/replace Noise manager for this node
         let key = Curve25519.KeyAgreement.PrivateKey()
-        noiseManagers[name] = NoiseSessionManager(
-            localStaticKey: key,
-            keychain: mockKeychain,
-            recentInitiatorCompletionGracePeriod: 0
-        )
+        noiseManagers[name] = NoiseSessionManager(localStaticKey: key, keychain: mockKeychain)
         return node
     }
     
@@ -114,18 +108,8 @@ final class TestNetworkHelper {
               let peer2ID = nodes[node2]?.peerID else { return }
         
         let msg1 = try manager1.initiateHandshake(with: peer2ID)
-        let msg2 = try #require(
-            try manager2.handleIncomingHandshake(
-                from: peer1ID,
-                message: msg1
-            )
-        )
-        let msg3 = try #require(
-            try manager1.handleIncomingHandshake(
-                from: peer2ID,
-                message: msg2
-            )
-        )
+        let msg2 = try manager2.handleIncomingHandshake(from: peer1ID, message: msg1)!
+        let msg3 = try manager1.handleIncomingHandshake(from: peer2ID, message: msg2)!
         _ = try manager2.handleIncomingHandshake(from: peer1ID, message: msg3)
     }
 }

bitchatTests/Mocks/MockIdentityManager.swift

@@ -14,8 +14,6 @@ final class MockIdentityManager: SecureIdentityStateManagerProtocol {
     private var blockedFingerprints: Set<String> = []
     private var blockedNostrPubkeys: Set<String> = []
     private var socialIdentities: [String: SocialIdentity] = [:]
-    private var privateMediaCapableFingerprints: Set<String> = []
-    private var authenticatedSigningKeys: [String: Data] = [:]
 
     init(_: KeychainManagerProtocol) {}
     
@@ -89,10 +87,7 @@ final class MockIdentityManager: SecureIdentityStateManagerProtocol {
     
     func registerEphemeralSession(peerID: PeerID, handshakeState: HandshakeState) {}
 
-    func clearAllIdentityData() {
-        privateMediaCapableFingerprints.removeAll()
-        authenticatedSigningKeys.removeAll()
-    }
+    func clearAllIdentityData() {}
     
     func removeEphemeralSession(peerID: PeerID) {}
     
@@ -106,22 +101,6 @@ final class MockIdentityManager: SecureIdentityStateManagerProtocol {
         Set()
     }
 
-    func markPrivateMediaCapable(fingerprint: String) {
-        privateMediaCapableFingerprints.insert(fingerprint)
-    }
-
-    func hasObservedPrivateMediaCapability(fingerprint: String) -> Bool {
-        privateMediaCapableFingerprints.contains(fingerprint)
-    }
-
-    func bindAuthenticatedSigningPublicKey(_ signingPublicKey: Data, fingerprint: String) {
-        authenticatedSigningKeys[fingerprint] = signingPublicKey
-    }
-
-    func authenticatedSigningPublicKey(forFingerprint fingerprint: String) -> Data? {
-        authenticatedSigningKeys[fingerprint]
-    }
-
     // MARK: Vouching (transitive verification)
 
     private var vouchesByVouchee: [String: [VouchRecord]] = [:]

bitchatTests/Mocks/MockTransport.swift

@@ -36,7 +36,6 @@ final class MockTransport: Transport {
     private(set) var sentFavoriteNotifications: [(peerID: PeerID, isFavorite: Bool)] = []
     private(set) var sentBroadcastFiles: [(packet: BitchatFilePacket, transferID: String)] = []
     private(set) var sentPrivateFiles: [(packet: BitchatFilePacket, peerID: PeerID, transferID: String)] = []
-    private(set) var sentPrivateFileLegacyAllowances: [Bool] = []
     private(set) var cancelledTransfers: [String] = []
     private(set) var sentVerifyChallenges: [(peerID: PeerID, noiseKeyHex: String, nonceA: Data)] = []
     private(set) var sentVerifyResponses: [(peerID: PeerID, noiseKeyHex: String, nonceA: Data)] = []
@@ -59,7 +58,6 @@ final class MockTransport: Transport {
     var peerNicknames: [PeerID: String] = [:]
     var peerFingerprints: [PeerID: String] = [:]
     var peerNoiseStates: [PeerID: LazyHandshakeState] = [:]
-    var privateMediaPolicies: [PeerID: PrivateMediaSendPolicy] = [:]
     private let mockKeychain = MockKeychain()
 
     // MARK: - Transport Protocol Implementation
@@ -188,29 +186,6 @@ final class MockTransport: Transport {
 
     func sendFilePrivate(_ packet: BitchatFilePacket, to peerID: PeerID, transferId: String) {
         sentPrivateFiles.append((packet, peerID, transferId))
-        sentPrivateFileLegacyAllowances.append(false)
-    }
-
-    func sendFilePrivate(
-        _ packet: BitchatFilePacket,
-        to peerID: PeerID,
-        transferId: String,
-        allowLegacyFallback: Bool
-    ) {
-        sentPrivateFiles.append((packet, peerID, transferId))
-        sentPrivateFileLegacyAllowances.append(allowLegacyFallback)
-    }
-
-    func privateMediaSendPolicy(to peerID: PeerID) -> PrivateMediaSendPolicy {
-        privateMediaPolicies[peerID] ?? .encrypted
-    }
-
-    func resolvePrivateMediaSendPolicy(
-        to peerID: PeerID,
-        completion: @escaping @MainActor (PrivateMediaSendPolicy) -> Void
-    ) {
-        let policy = privateMediaPolicies[peerID] ?? .encrypted
-        Task { @MainActor in completion(policy) }
     }
 
     func cancelTransfer(_ transferId: String) {

bitchatTests/Noise/NoiseCoverageTests.swift

@@ -5,7 +5,7 @@ import BitFoundation
 
 @testable import bitchat
 
-@Suite("Noise Coverage Tests", .serialized)
+@Suite("Noise Coverage Tests")
 struct NoiseCoverageTests {
     private let keychain = MockKeychain()
     private let aliceStaticKey = Curve25519.KeyAgreement.PrivateKey()
@@ -542,12 +542,8 @@ struct NoiseCoverageTests {
         let aliceManager = NoiseSessionManager(localStaticKey: aliceStaticKey, keychain: keychain)
         let bobManager = NoiseSessionManager(localStaticKey: bobStaticKey, keychain: keychain)
 
-        aliceManager.onSessionEstablished = establishedRecorder.recordEstablished(
-            peerID:remoteKey:sessionGeneration:
-        )
-        bobManager.onSessionEstablished = establishedRecorder.recordEstablished(
-            peerID:remoteKey:sessionGeneration:
-        )
+        aliceManager.onSessionEstablished = establishedRecorder.recordEstablished(peerID:remoteKey:)
+        bobManager.onSessionEstablished = establishedRecorder.recordEstablished(peerID:remoteKey:)
 
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
 
@@ -633,16 +629,8 @@ struct NoiseCoverageTests {
         )
         let replacementSession = try #require(manager.getSession(for: alicePeerID))
 
-        let localPeerID = PeerID(
-            publicKey: aliceStaticKey.publicKey.rawRepresentation
-        )
-        if localPeerID < alicePeerID {
-            #expect(replacementResponse == nil)
-            #expect(replacementSession === restartedSession)
-        } else {
-            #expect(replacementResponse != nil)
-            #expect(replacementSession !== restartedSession)
-        }
+        #expect(replacementResponse != nil)
+        #expect(replacementSession !== restartedSession)
 
         let aliceManager = NoiseSessionManager(localStaticKey: aliceStaticKey, keychain: keychain)
         let bobManager = NoiseSessionManager(localStaticKey: bobStaticKey, keychain: keychain)
@@ -662,128 +650,13 @@ struct NoiseCoverageTests {
             try aliceManager.initiateHandshake(with: alicePeerID)
         }
 
-        let rekeyInitiation = try aliceManager.initiateRekey(for: alicePeerID)
-        let rekeyHandshake = try #require(
-            aliceManager.claimHandshakeInitiation(
-                rekeyInitiation,
-                for: alicePeerID
-            )
-        )
-        #expect(!rekeyHandshake.isEmpty)
+        try aliceManager.initiateRekey(for: alicePeerID)
         let rekeyedSession = try #require(aliceManager.getSession(for: alicePeerID))
 
         #expect(rekeyedSession !== establishedSession)
         #expect(rekeyedSession.getState() == .handshaking)
     }
 
-    @Test("A stale decrypt generation cannot commit across session promotion")
-    func staleDecryptGenerationCannotCommitAcrossPromotion() throws {
-        let aliceManager = NoiseSessionManager(
-            localStaticKey: aliceStaticKey,
-            keychain: keychain,
-            recentInitiatorCompletionGracePeriod: 0,
-            sessionFactory: { peerID, role in
-                BlockingDecryptNoiseSession(
-                    peerID: peerID,
-                    role: role,
-                    keychain: self.keychain,
-                    localStaticKey: self.aliceStaticKey
-                )
-            }
-        )
-        let bobManager = NoiseSessionManager(localStaticKey: bobStaticKey, keychain: keychain)
-        try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
-
-        let oldSession = try #require(
-            aliceManager.getSession(for: alicePeerID) as? BlockingDecryptNoiseSession
-        )
-        let oldGeneration = try #require(aliceManager.sessionGeneration(for: alicePeerID))
-
-        // Prepare a fully authenticated responder candidate without promoting
-        // it yet. Its final XX message is the exact operation that replaces
-        // the old `sessions[peerID]` entry.
-        let replacementInitiator = NoiseSession(
-            peerID: bobPeerID,
-            role: .initiator,
-            keychain: keychain,
-            localStaticKey: bobStaticKey
-        )
-        let message1 = try replacementInitiator.startHandshake()
-        let message2 = try #require(
-            try aliceManager.handleIncomingHandshake(from: alicePeerID, message: message1)
-        )
-        let message3 = try #require(try replacementInitiator.processHandshakeMessage(message2))
-
-        let ciphertext = try bobManager.encrypt(Data("old session".utf8), for: bobPeerID)
-        oldSession.pauseNextDecrypt()
-
-        let decryptResult = ConcurrentTestResult<(plaintext: Data, sessionGeneration: UUID)>()
-        var promotionResultForCleanup: ConcurrentTestResult<Data?>?
-        defer {
-            // A failed startup requirement must not strand a late thread in
-            // the blocking test double after the test has returned.
-            oldSession.resumeDecrypt()
-            _ = decryptResult.wait(timeout: 5)
-            if let promotionResultForCleanup {
-                _ = promotionResultForCleanup.wait(timeout: 5)
-            }
-        }
-
-        let decryptThread = Thread {
-            decryptResult.capture {
-                try aliceManager.decryptWithSessionGeneration(ciphertext, from: self.alicePeerID)
-            }
-        }
-        decryptThread.name = "NoiseCoverageTests.staleDecrypt.decrypt"
-        decryptThread.qualityOfService = .userInitiated
-        decryptThread.start()
-        try #require(oldSession.waitForDecryptStart(timeout: 5))
-
-        let promotionStarted = DispatchSemaphore(value: 0)
-        let promotionResult = ConcurrentTestResult<Data?>()
-        promotionResultForCleanup = promotionResult
-        let promotionThread = Thread {
-            promotionStarted.signal()
-            promotionResult.capture {
-                try aliceManager.handleIncomingHandshake(from: self.alicePeerID, message: message3)
-            }
-        }
-        promotionThread.name = "NoiseCoverageTests.staleDecrypt.promote"
-        promotionThread.qualityOfService = .userInitiated
-        promotionThread.start()
-        try #require(promotionStarted.wait(timeout: .now() + 5) == .success)
-        #expect(
-            promotionResult.wait(timeout: 0.05) == nil,
-            "Promotion must wait for the exact decrypting-session lease"
-        )
-
-        oldSession.resumeDecrypt()
-        let decrypted = try #require(decryptResult.wait(timeout: 5)).get()
-        _ = try #require(promotionResult.wait(timeout: 5)).get()
-
-        #expect(decrypted.plaintext == Data("old session".utf8))
-        #expect(decrypted.sessionGeneration == oldGeneration)
-        #expect(aliceManager.sessionGeneration(for: alicePeerID) != oldGeneration)
-        #expect(throws: NoiseEncryptionError.sessionNotEstablished) {
-            try aliceManager.encrypt(
-                Data("stale send".utf8),
-                for: alicePeerID,
-                expectedSessionGeneration: oldGeneration
-            )
-        }
-
-        var staleCommitRan = false
-        let staleCommit = aliceManager.withCurrentSessionGeneration(
-            for: alicePeerID,
-            expected: decrypted.sessionGeneration
-        ) {
-            staleCommitRan = true
-            return true
-        }
-        #expect(staleCommit == nil)
-        #expect(!staleCommitRan)
-    }
-
     @Test("Secure noise sessions enforce limits and renegotiation thresholds")
     func secureNoiseSessionsEnforceLimitsAndThresholds() throws {
         let initiator = SecureNoiseSession(
@@ -978,11 +851,7 @@ private final class SessionCallbackRecorder: @unchecked Sendable {
         return establishedEntries.map(\.0)
     }
 
-    func recordEstablished(
-        peerID: PeerID,
-        remoteKey: Curve25519.KeyAgreement.PublicKey,
-        sessionGeneration _: UUID
-    ) {
+    func recordEstablished(peerID: PeerID, remoteKey: Curve25519.KeyAgreement.PublicKey) {
         lock.lock()
         establishedEntries.append((peerID, remoteKey.rawRepresentation))
         lock.unlock()
@@ -1004,62 +873,3 @@ private final class FailingNoiseSession: NoiseSession {
         throw Error.synthetic
     }
 }
-
-private final class BlockingDecryptNoiseSession: NoiseSession, @unchecked Sendable {
-    private let controlLock = NSLock()
-    private var shouldPauseNextDecrypt = false
-    private let decryptStarted = DispatchSemaphore(value: 0)
-    private let resumeDecryptSemaphore = DispatchSemaphore(value: 0)
-
-    func pauseNextDecrypt() {
-        controlLock.lock()
-        shouldPauseNextDecrypt = true
-        controlLock.unlock()
-    }
-
-    func waitForDecryptStart(timeout: TimeInterval) -> Bool {
-        decryptStarted.wait(timeout: .now() + timeout) == .success
-    }
-
-    func resumeDecrypt() {
-        resumeDecryptSemaphore.signal()
-    }
-
-    override func decrypt(_ ciphertext: Data) throws -> Data {
-        controlLock.lock()
-        let shouldPause = shouldPauseNextDecrypt
-        shouldPauseNextDecrypt = false
-        controlLock.unlock()
-
-        if shouldPause {
-            decryptStarted.signal()
-            resumeDecryptSemaphore.wait()
-        }
-        return try super.decrypt(ciphertext)
-    }
-}
-
-private final class ConcurrentTestResult<Value>: @unchecked Sendable {
-    private let lock = NSLock()
-    private let completed = DispatchGroup()
-    private var storedResult: Result<Value, Error>?
-
-    init() {
-        completed.enter()
-    }
-
-    func capture(_ operation: () throws -> Value) {
-        let result = Result(catching: operation)
-        lock.lock()
-        storedResult = result
-        lock.unlock()
-        completed.leave()
-    }
-
-    func wait(timeout: TimeInterval) -> Result<Value, Error>? {
-        guard completed.wait(timeout: .now() + timeout) == .success else { return nil }
-        lock.lock()
-        defer { lock.unlock() }
-        return storedResult
-    }
-}

bitchatTests/Noise/NoiseProtocolTests.swift

@@ -357,18 +357,8 @@ struct NoiseProtocolTests {
     
     @Test func peerRestartDetection() throws {
         // Establish initial sessions
-        // This test explicitly drives the three synchronous XX messages and
-        // does not exercise the transport's delayed collision recovery.
-        let aliceManager = NoiseSessionManager(
-            localStaticKey: aliceKey,
-            keychain: mockKeychain,
-            recentInitiatorCompletionGracePeriod: 0
-        )
-        let bobManager = NoiseSessionManager(
-            localStaticKey: bobKey,
-            keychain: mockKeychain,
-            recentInitiatorCompletionGracePeriod: 0
-        )
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
         
@@ -387,24 +377,15 @@ struct NoiseProtocolTests {
         let newHandshake1 = try bobManagerRestarted.initiateHandshake(with: bobPeerID)
         
         // Alice should accept the new handshake (clearing old session)
-        let newHandshake2 = try #require(
-            try aliceManager.handleIncomingHandshake(
-                from: alicePeerID,
-                message: newHandshake1
-            )
-        )
+        let newHandshake2 = try aliceManager.handleIncomingHandshake(
+            from: alicePeerID, message: newHandshake1)
+        #expect(newHandshake2 != nil)
         
         // Complete the new handshake
-        let newHandshake3 = try #require(
-            try bobManagerRestarted.handleIncomingHandshake(
-                from: bobPeerID,
-                message: newHandshake2
-            )
-        )
-        _ = try aliceManager.handleIncomingHandshake(
-            from: alicePeerID,
-            message: newHandshake3
-        )
+        let newHandshake3 = try bobManagerRestarted.handleIncomingHandshake(
+            from: bobPeerID, message: newHandshake2!)
+        #expect(newHandshake3 != nil)
+        _ = try aliceManager.handleIncomingHandshake(from: alicePeerID, message: newHandshake3!)
         
         // Should be able to exchange messages with new sessions
         let testMessage = Data("After restart".utf8)
@@ -562,18 +543,8 @@ struct NoiseProtocolTests {
     
     @Test func nonceDesynchronizationCausesRehandshake() throws {
         // Test that nonce desynchronization leads to proper re-handshake
-        // This test explicitly drives the three synchronous XX messages and
-        // does not exercise the transport's delayed collision recovery.
-        let aliceManager = NoiseSessionManager(
-            localStaticKey: aliceKey,
-            keychain: mockKeychain,
-            recentInitiatorCompletionGracePeriod: 0
-        )
-        let bobManager = NoiseSessionManager(
-            localStaticKey: bobKey,
-            keychain: mockKeychain,
-            recentInitiatorCompletionGracePeriod: 0
-        )
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         // Establish sessions
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
@@ -601,25 +572,15 @@ struct NoiseProtocolTests {
         let rehandshake1 = try bobManager.initiateHandshake(with: bobPeerID)
         
         // Alice should accept despite having a "valid" (but desynced) session
-        let rehandshake2 = try #require(
-            try aliceManager.handleIncomingHandshake(
-                from: alicePeerID,
-                message: rehandshake1
-            ),
-            "Alice should accept handshake to fix desync"
-        )
+        let rehandshake2 = try aliceManager.handleIncomingHandshake(
+            from: alicePeerID, message: rehandshake1)
+        #expect(rehandshake2 != nil, "Alice should accept handshake to fix desync")
         
         // Complete handshake
-        let rehandshake3 = try #require(
-            try bobManager.handleIncomingHandshake(
-                from: bobPeerID,
-                message: rehandshake2
-            )
-        )
-        _ = try aliceManager.handleIncomingHandshake(
-            from: alicePeerID,
-            message: rehandshake3
-        )
+        let rehandshake3 = try bobManager.handleIncomingHandshake(
+            from: bobPeerID, message: rehandshake2!)
+        #expect(rehandshake3 != nil)
+        _ = try aliceManager.handleIncomingHandshake(from: alicePeerID, message: rehandshake3!)
         
         // Verify communication works again
         let testResynced = Data("Resynced".utf8)

bitchatTests/Nostr/GeoRelayDirectoryTests.swift

@@ -5,19 +5,25 @@ import XCTest
 
 @MainActor
 final class GeoRelayDirectoryTests: XCTestCase {
-    func test_parseCSV_normalizesRelaySchemesAndDeduplicatesEntries() {
+    private func parse(_ csv: String) -> [GeoRelayDirectory.Entry] {
+        GeoRelayDirectory.validatedEntries(
+            from: Data(csv.utf8),
+            policy: .live,
+            minimumEntries: 1
+        ) ?? []
+    }
+
+    func test_parseCSV_normalizesSecureRelaySchemesAndDeduplicatesEntries() {
         let csv = """
         relay url,lat,lon
         wss://one.example/,10,20
         https://one.example,10,20
         wss://one.example:443/,10,20
-        http://two.example/,11,21
+        two.example,11,21
         wss://two.example:443,11,21
-        invalid row
-        ws://three.example,not-a-lat,22
         """
 
-        let parsed = Set(GeoRelayDirectory.parseCSV(csv))
+        let parsed = Set(parse(csv))
 
         XCTAssertEqual(
             parsed,
@@ -28,6 +34,136 @@ final class GeoRelayDirectoryTests: XCTestCase {
         )
     }
 
+    func test_parseCSV_rejectsWholeDatasetWhenAnyRowOrHeaderIsUnsafe() {
+        let invalidCSVs = [
+            "relay,lat,lon\nrelay.example,1,2\n",
+            "relay url,lat,lon\nrelay.example,1\n",
+            "relay url,lat,lon\nhttp://relay.example,1,2\n",
+            "relay url,lat,lon\nwss://user@relay.example,1,2\n",
+            "relay url,lat,lon\nwss://relay.example/path,1,2\n",
+            "relay url,lat,lon\nwss://relay.example?,1,2\n",
+            "relay url,lat,lon\nwss://relay.example#,1,2\n",
+            "relay url,lat,lon\nrelay.example:0,1,2\n",
+            "relay url,lat,lon\nrelay.example:99999,1,2\n",
+            "relay url,lat,lon\nlocalhost,1,2\n",
+            "relay url,lat,lon\nr\u{00e9}lay.example,1,2\n",
+            "relay url,lat,lon\nrelay\u{202e}.example,1,2\n",
+            "relay url,lat,lon\nrelay.example,NaN,2\n",
+            "relay url,lat,lon\nrelay.example,1_0,2\n",
+            "relay url,lat,lon\nrelay.example,\u{0661}\u{0660},2\n",
+            "relay url,lat,lon\nrelay.example,\u{ff11}\u{ff10},2\n",
+            "relay url,lat,lon\nrelay.example,91,2\n",
+            "relay url,lat,lon\nrelay.example,1,181\n",
+            "relay url,lat,lon\nrelay.example,1,2\nrelay.example,3,4\n"
+        ]
+
+        for csv in invalidCSVs {
+            XCTAssertTrue(parse(csv).isEmpty, csv)
+        }
+    }
+
+    func test_validatedEntries_enforcesByteRowEntryAndRetentionLimits() {
+        let restrictive = GeoRelayDirectoryValidationPolicy(
+            maximumBytes: 100,
+            maximumRows: 2,
+            maximumEntries: 2,
+            minimumRemoteEntries: 1,
+            minimumRetainedFraction: 0.5
+        )
+        let one = Data("relay url,lat,lon\none.example,1,2\n".utf8)
+        let three = Data("relay url,lat,lon\none.example,1,2\ntwo.example,3,4\nthree.example,5,6\n".utf8)
+
+        XCTAssertNil(GeoRelayDirectory.validatedEntries(
+            from: one,
+            policy: restrictive,
+            minimumEntries: 2
+        ))
+        XCTAssertNil(GeoRelayDirectory.validatedEntries(
+            from: Data(repeating: 0x41, count: 101),
+            policy: restrictive,
+            minimumEntries: 1
+        ))
+        XCTAssertNil(GeoRelayDirectory.validatedEntries(
+            from: three,
+            policy: restrictive,
+            minimumEntries: 1
+        ))
+    }
+
+    func test_validatedEntries_requiresExactBaselineEntryOverlap() throws {
+        let policy = GeoRelayDirectoryValidationPolicy(
+            maximumBytes: 1_000,
+            maximumRows: 10,
+            maximumEntries: 10,
+            minimumRemoteEntries: 1,
+            minimumRetainedFraction: 0.5
+        )
+        let baseline = Set(try XCTUnwrap(GeoRelayDirectory.validatedEntries(
+            from: Data("""
+            relay url,lat,lon
+            one.example,1,1
+            two.example,2,2
+            three.example,3,3
+            """.utf8),
+            policy: policy,
+            minimumEntries: 1
+        )))
+        let disjoint = Data("""
+        relay url,lat,lon
+        four.example,1,1
+        five.example,2,2
+        six.example,3,3
+        """.utf8)
+        let rewrittenCoordinates = Data("""
+        relay url,lat,lon
+        one.example,11,11
+        two.example,12,12
+        three.example,13,13
+        """.utf8)
+        let halfRetained = Data("""
+        relay url,lat,lon
+        wss://one.example:443/,1,1
+        https://two.example/,2,2
+        replacement.example,4,4
+        """.utf8)
+
+        XCTAssertNil(GeoRelayDirectory.validatedEntries(
+            from: disjoint,
+            policy: policy,
+            minimumEntries: 1,
+            baselineEntries: baseline
+        ))
+        XCTAssertNil(GeoRelayDirectory.validatedEntries(
+            from: rewrittenCoordinates,
+            policy: policy,
+            minimumEntries: 1,
+            baselineEntries: baseline
+        ))
+        XCTAssertNotNil(GeoRelayDirectory.validatedEntries(
+            from: halfRetained,
+            policy: policy,
+            minimumEntries: 1,
+            baselineEntries: baseline
+        ))
+    }
+
+    func test_bundledReviewedCSV_passesStrictProductionValidation() throws {
+        let repositoryRoot = URL(fileURLWithPath: #filePath)
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+        let data = try Data(
+            contentsOf: repositoryRoot.appendingPathComponent("relays/online_relays_gps.csv")
+        )
+
+        let entries = try XCTUnwrap(GeoRelayDirectory.validatedEntries(
+            from: data,
+            policy: .live,
+            minimumEntries: GeoRelayDirectoryValidationPolicy.live.minimumRemoteEntries
+        ))
+        XCTAssertGreaterThan(entries.count, 250)
+    }
+
     func test_closestRelays_sortsByDistanceForLatLonAndGeohash() {
         let harness = makeHarness(
             cacheCSV: """
@@ -243,6 +379,53 @@ final class GeoRelayDirectoryTests: XCTestCase {
         XCTAssertFalse(directory.debugHasRetryTask)
     }
 
+    func test_prefetchIfNeeded_rejectsSharpValidLookingTruncationBeforeCaching() async {
+        let cached = """
+        relay url,lat,lon
+        old-one.example,1,1
+        old-two.example,2,2
+        old-three.example,3,3
+        """
+        let truncated = """
+        relay url,lat,lon
+        attacker.example,9,9
+        """
+        let recovered = """
+        relay url,lat,lon
+        old-one.example,1,1
+        old-two.example,2,2
+        new-three.example,6,6
+        """
+        let harness = makeHarness(
+            cacheCSV: cached,
+            fetchResults: [
+                .success(Data(truncated.utf8)),
+                .success(Data(recovered.utf8))
+            ],
+            validationPolicy: GeoRelayDirectoryValidationPolicy(
+                maximumBytes: 64 * 1024,
+                maximumRows: 1_000,
+                maximumEntries: 1_000,
+                minimumRemoteEntries: 1,
+                minimumRetainedFraction: 0.5
+            )
+        )
+        let directory = GeoRelayDirectory(dependencies: harness.dependencies)
+
+        directory.prefetchIfNeeded()
+
+        let refreshed = await waitUntil {
+            directory.entries.contains(where: { $0.host == "new-three.example" })
+        }
+        XCTAssertTrue(refreshed)
+        XCTAssertFalse(directory.entries.contains(where: { $0.host == "attacker.example" }))
+        let requestCount = await harness.fetcher.recordedRequestCount()
+        let retryDelays = await harness.retryRecorder.recordedDelays()
+        XCTAssertEqual(requestCount, 2)
+        XCTAssertEqual(retryDelays, [5])
+        XCTAssertEqual(harness.fileStore.dataByURL[harness.cacheURL], Data(recovered.utf8))
+    }
+
     func test_observers_triggerPrefetchesForTorReadyAndAppActivation() async {
         let activeNotification = Notification.Name("GeoRelayDirectoryTests.didBecomeActive")
         let harness = makeHarness(
@@ -289,7 +472,14 @@ final class GeoRelayDirectoryTests: XCTestCase {
         fetchFactoryObserver: (@MainActor @Sendable () -> Void)? = nil,
         fetchObserver: (@Sendable () async -> Void)? = nil,
         autoStart: Bool = false,
-        activeNotificationName: Notification.Name? = nil
+        activeNotificationName: Notification.Name? = nil,
+        validationPolicy: GeoRelayDirectoryValidationPolicy = GeoRelayDirectoryValidationPolicy(
+            maximumBytes: 64 * 1024,
+            maximumRows: 1_000,
+            maximumEntries: 1_000,
+            minimumRemoteEntries: 1,
+            minimumRetainedFraction: 0
+        )
     ) -> GeoRelayHarness {
         let userDefaultsSuite = "GeoRelayDirectoryTests.\(UUID().uuidString)"
         let userDefaults = UserDefaults(suiteName: userDefaultsSuite)!
@@ -347,7 +537,8 @@ final class GeoRelayDirectoryTests: XCTestCase {
                 await retryRecorder.record(delay)
             },
             activeNotificationName: activeNotificationName,
-            autoStart: autoStart
+            autoStart: autoStart,
+            validationPolicy: validationPolicy
         )
 
         return GeoRelayHarness(

bitchatTests/Performance/PerformanceBaselineTests.swift

@@ -501,6 +501,62 @@ final class PerformanceBaselineTests: XCTestCase {
         reportThroughput("store.append", samples: samples, operations: messageCount, unit: "messages")
     }
 
+    // MARK: - 7b. ConversationStore append at the retention cap
+
+    /// Steady-state public timeline traffic after the 1337-message retention
+    /// cap has been reached. Every tail append evicts the oldest row, which is
+    /// the long-lived workload the cold `store.append` benchmark does not
+    /// exercise.
+    func testConversationStoreSteadyStateAppend() {
+        let store = ConversationStore()
+        let cap = TransportConfig.meshTimelineCap
+        let messagesPerPass = 500
+        let base = Date(timeIntervalSince1970: 1_700_000_000)
+
+        for i in 0..<cap {
+            store.append(
+                BitchatMessage(
+                    id: "perf-steady-seed-\(i)",
+                    sender: "perfsender",
+                    content: "steady-state seed \(i)",
+                    timestamp: base.addingTimeInterval(Double(i)),
+                    isRelay: false
+                ),
+                to: .mesh
+            )
+        }
+
+        var pass = 0
+        var samples: [TimeInterval] = []
+        measure {
+            let startIndex = cap + pass * messagesPerPass
+            let start = Date()
+            for offset in 0..<messagesPerPass {
+                let i = startIndex + offset
+                store.append(
+                    BitchatMessage(
+                        id: "perf-steady-\(i)",
+                        sender: "perfsender",
+                        content: "steady-state message \(i)",
+                        timestamp: base.addingTimeInterval(Double(i)),
+                        isRelay: false
+                    ),
+                    to: .mesh
+                )
+            }
+            samples.append(Date().timeIntervalSince(start))
+            pass += 1
+            XCTAssertEqual(store.conversation(for: .mesh).messages.count, cap)
+        }
+
+        reportThroughput(
+            "store.steadyStateAppend",
+            samples: samples,
+            operations: messagesPerPass,
+            unit: "messages"
+        )
+    }
+
     // MARK: - 8. ConversationStore invariant audit (field observability)
 
     /// `ConversationStore.auditInvariants()` over a realistic 5k-message

bitchatTests/Performance/perf-floors.json

@@ -30,6 +30,10 @@
     "store.append": 213201,
     "store.audit": 362
   },
+  "_reference_local_numbers_2026_07": {
+    "store.steadyStateAppend_before": 2315,
+    "store.steadyStateAppend": 53976
+  },
   "floors": {
     "nostrInbound.fresh": 450,
     "nostrInbound.duplicate": 250000,
@@ -41,6 +45,7 @@
     "pipeline.privateIngest": 3000,
     "pipeline.publicIngest": 2400,
     "store.append": 48000,
+    "store.steadyStateAppend": 10000,
     "store.audit": 70
   },
   "_slowest_observed_ci_numbers_2026_06": {

bitchatTests/Protocols/BitchatFilePacketTests.swift

@@ -1,4 +1,3 @@
-import BitFoundation
 import XCTest
 @testable import bitchat
 
@@ -74,85 +73,4 @@ final class BitchatFilePacketTests: XCTestCase {
         XCTAssertEqual(decoded.fileSize, UInt64(content.count))
         XCTAssertEqual(decoded.content, content)
     }
-
-    func testPrivateMediaMessageIdentityConvergesAcrossPeerIDAliases() throws {
-        let senderKey = Data(repeating: 0x11, count: 32)
-        let recipientKey = Data(repeating: 0x22, count: 32)
-        let senderStable = PeerID(hexData: senderKey)
-        let recipientStable = PeerID(hexData: recipientKey)
-        let fileName = "img_20260725_105708_1CC2760D-76AA-40C3-8013-C7FAA6C2EF99.jpg"
-
-        let senderID = try XCTUnwrap(PrivateMediaMessageIdentity.stableID(
-            senderPeerID: senderStable.toShort(),
-            recipientPeerID: PeerID(str: "mesh:\(recipientStable.toShort().bare)"),
-            fileName: fileName
-        ))
-        let receiverID = try XCTUnwrap(PrivateMediaMessageIdentity.stableID(
-            senderPeerID: senderStable,
-            recipientPeerID: recipientStable.toShort(),
-            fileName: fileName
-        ))
-
-        XCTAssertEqual(senderID, receiverID)
-        XCTAssertTrue(senderID.hasPrefix("media-"))
-        XCTAssertEqual(senderID.count, 38)
-        XCTAssertTrue(PrivateMediaMessageIdentity.isStableID(senderID))
-        XCTAssertFalse(PrivateMediaMessageIdentity.isStableID("media-\(String(repeating: "A", count: 32))"))
-        XCTAssertFalse(PrivateMediaMessageIdentity.isStableID("media-\(String(repeating: "a", count: 31))"))
-        XCTAssertFalse(PrivateMediaMessageIdentity.isStableID(UUID().uuidString))
-    }
-
-    func testPrivateMediaMessageIdentitySeparatesDirectionAndFilename() throws {
-        let alice = PeerID(str: "0011223344556677")
-        let bob = PeerID(str: "8899aabbccddeeff")
-        let firstName = "voice_20260725_105708_11111111-1111-1111-1111-111111111111.m4a"
-        let secondName = "voice_20260725_105709_22222222-2222-2222-2222-222222222222.m4a"
-        let first = try XCTUnwrap(PrivateMediaMessageIdentity.stableID(
-            senderPeerID: alice,
-            recipientPeerID: bob,
-            fileName: firstName
-        ))
-
-        XCTAssertNotEqual(first, PrivateMediaMessageIdentity.stableID(
-            senderPeerID: bob,
-            recipientPeerID: alice,
-            fileName: firstName
-        ))
-        XCTAssertNotEqual(first, PrivateMediaMessageIdentity.stableID(
-            senderPeerID: alice,
-            recipientPeerID: bob,
-            fileName: secondName
-        ))
-        XCTAssertNil(PrivateMediaMessageIdentity.stableID(
-            senderPeerID: alice,
-            recipientPeerID: bob,
-            fileName: nil
-        ))
-        XCTAssertNil(PrivateMediaMessageIdentity.stableID(
-            senderPeerID: alice,
-            recipientPeerID: bob,
-            fileName: "photo.jpg"
-        ))
-        XCTAssertNil(PrivateMediaMessageIdentity.stableID(
-            senderPeerID: alice,
-            recipientPeerID: bob,
-            fileName: "img_11111111-1111-1111-1111-111111111111.pdf"
-        ))
-        XCTAssertNotNil(PrivateMediaMessageIdentity.stableID(
-            senderPeerID: alice,
-            recipientPeerID: bob,
-            fileName: "voice_0011223344556677.m4a"
-        ))
-    }
-
-    func testPrivateMediaMessageIdentityMatchesVersionOneGoldenVector() {
-        XCTAssertEqual(
-            PrivateMediaMessageIdentity.stableID(
-                senderPeerID: PeerID(str: "0011223344556677"),
-                recipientPeerID: PeerID(str: "8899aabbccddeeff"),
-                fileName: "img_20260725_105708_1CC2760D-76AA-40C3-8013-C7FAA6C2EF99.jpg"
-            ),
-            "media-910bd42c65060ab76bb6406f220c4516"
-        )
-    }
 }

bitchatTests/Protocols/PacketsTests.swift

@@ -145,39 +145,6 @@ struct PacketsTests {
         #expect(decoded.capabilities?.rawValue == 0x0180)
     }
 
-    @Test
-    func authenticatedPeerStateUsesVersionedCanonicalTLVs() throws {
-        let signingKey = Data(repeating: 0xA5, count: 32)
-        let packet = AuthenticatedPeerStatePacket(
-            capabilities: [.privateMedia, .vouch],
-            signingPublicKey: signingKey
-        )
-
-        var encoded = try #require(packet.encode())
-        #expect(encoded.prefix(5) == Data([0x01, 0x01, 0x02, 0x20, 0x01]))
-        // Unknown TLVs are forward-compatible and do not alter v1 state.
-        encoded.append(makeTLV(type: 0x7F, value: Data([0xCA, 0xFE])))
-
-        #expect(AuthenticatedPeerStatePacket.decode(from: encoded) == packet)
-    }
-
-    @Test
-    func authenticatedPeerStateRejectsMalformedAmbiguousOrUnknownVersion() {
-        let key = Data(repeating: 0x44, count: 32)
-        let capabilities = makeTLV(type: 0x01, value: Data([0x00, 0x01]))
-        let signing = makeTLV(type: 0x02, value: key)
-
-        #expect(AuthenticatedPeerStatePacket.decode(from: Data([0x02]) + capabilities + signing) == nil)
-        #expect(AuthenticatedPeerStatePacket.decode(from: Data([0x01]) + signing) == nil)
-        #expect(AuthenticatedPeerStatePacket.decode(from: Data([0x01]) + capabilities + capabilities + signing) == nil)
-        #expect(AuthenticatedPeerStatePacket.decode(from: Data([0x01, 0x01, 0x00]) + signing) == nil)
-        // 0x0001 is non-minimal little endian; the canonical form is [0x01].
-        #expect(AuthenticatedPeerStatePacket.decode(from: Data([0x01]) + makeTLV(type: 0x01, value: Data([0x01, 0x00])) + signing) == nil)
-        #expect(AuthenticatedPeerStatePacket.decode(from: Data([0x01]) + capabilities + makeTLV(type: 0x02, value: Data(key.dropLast()))) == nil)
-        #expect(AuthenticatedPeerStatePacket.decode(from: Data([0x01]) + capabilities + Data(signing.dropLast())) == nil)
-        #expect(AuthenticatedPeerStatePacket.decode(from: Data([0x01]) + makeTLV(type: 0x01, value: Data(repeating: 0x01, count: 9)) + signing) == nil)
-    }
-
     @Test
     func privateMessagePacketRejectsUnknownTypeAndTruncation() {
         let unknownTLV = Data([0x7F, 0x01, 0x41])

bitchatTests/Services/BLEAnnounceHandlerTests.swift

@@ -6,7 +6,6 @@ import Testing
 struct BLEAnnounceHandlerTests {
     private final class Recorder {
         var existingNoisePublicKey: Data?
-        var authenticatedSigningPublicKey: Data?
         var signatureValid = true
         var linkState: (hasPeripheral: Bool, hasCentral: Bool) = (false, false)
         var linkBoundToOtherPeer = false
@@ -38,7 +37,6 @@ struct BLEAnnounceHandlerTests {
             messageTTL: TransportConfig.messageTTLDefault,
             now: { now },
             existingNoisePublicKey: { _ in recorder.existingNoisePublicKey },
-            authenticatedSigningPublicKey: { _ in recorder.authenticatedSigningPublicKey },
             verifySignature: { packet, signingPublicKey in
                 recorder.verifySignatureCalls.append((packet, signingPublicKey))
                 return recorder.signatureValid

bitchatTests/Services/BLEAnnounceHandlingPolicyTests.swift

@@ -169,23 +169,6 @@ struct BLEAnnounceHandlingPolicyTests {
         #expect(decision.isVerified)
     }
 
-    @Test
-    func trustPolicyRejectsSigningKeyReplacementAfterNoiseBinding() {
-        let noiseKey = Data(repeating: 0xCC, count: 32)
-        let boundSigningKey = Data(repeating: 0x11, count: 32)
-
-        let decision = BLEAnnounceTrustPolicy.evaluate(
-            hasSignature: true,
-            signatureValid: true,
-            existingNoisePublicKey: noiseKey,
-            announcedNoisePublicKey: noiseKey,
-            authenticatedSigningPublicKey: boundSigningKey,
-            announcedSigningPublicKey: Data(repeating: 0x22, count: 32)
-        )
-
-        #expect(decision == .reject(.authenticatedSigningKeyMismatch))
-    }
-
     @Test
     func responsePolicyConnectsOnlyForDirectNewOrReconnectedPeers() {
         let directNew = BLEAnnounceResponsePolicy.plan(

bitchatTests/Services/BLEFileTransferHandlerTests.swift

@@ -13,27 +13,11 @@ struct BLEFileTransferHandlerTests {
 
         var signatureVerifyCount = 0
         var signedNameQueries: [PeerID] = []
-        var blockedPeers: Set<PeerID> = []
         var trackedPackets: [BitchatPacket] = []
         var quotaReservations: [Int] = []
         var saveCalls: [(data: Data, preferredName: String?, subdirectory: String, fallbackExtension: String?, defaultPrefix: String)] = []
-        var receiptStates: [String: BLEPrivateMediaReceiptState] = [:]
-        var receiptCommits: [(messageID: String, storedURL: URL)] = []
-        var receiptCommitSucceeds = true
-        var removedIncomingFiles: [URL] = []
         var lastSeenUpdates: [PeerID] = []
-        var deliveryAcks: [(messageID: String, peerID: PeerID)] = []
         var deliveredMessages: [BitchatMessage] = []
-        var saveOverride: ((
-            _ data: Data,
-            _ preferredName: String?,
-            _ subdirectory: String,
-            _ fallbackExtension: String?,
-            _ defaultPrefix: String
-        ) -> URL?)?
-        var receiptStateOverride: ((String) -> BLEPrivateMediaReceiptState)?
-        var receiptCommitOverride: ((String, URL) -> Bool)?
-        var removeIncomingFileOverride: ((URL) -> Void)?
     }
 
     private let localPeerID = PeerID(str: "0102030405060708")
@@ -49,7 +33,6 @@ struct BLEFileTransferHandlerTests {
                 recorder.signatureVerifyCount += 1
                 return recorder.signatureVerifies
             },
-            localSigningPublicKey: { [sampleSigningKey] in sampleSigningKey },
             signedSenderDisplayName: { _, peerID in
                 recorder.signedNameQueries.append(peerID)
                 return recorder.signedName
@@ -62,44 +45,13 @@ struct BLEFileTransferHandlerTests {
             },
             saveIncomingFile: { data, preferredName, subdirectory, fallbackExtension, defaultPrefix in
                 recorder.saveCalls.append((data, preferredName, subdirectory, fallbackExtension, defaultPrefix))
-                if let saveOverride = recorder.saveOverride {
-                    return saveOverride(data, preferredName, subdirectory, fallbackExtension, defaultPrefix)
-                }
                 return recorder.saveResult
             },
-            privateMediaReceiptState: { messageID in
-                if let receiptStateOverride = recorder.receiptStateOverride {
-                    return receiptStateOverride(messageID)
-                }
-                return recorder.receiptStates[messageID] ?? .absent
-            },
-            commitPrivateMediaFile: { messageID, storedURL in
-                recorder.receiptCommits.append((messageID, storedURL))
-                if let receiptCommitOverride = recorder.receiptCommitOverride {
-                    return receiptCommitOverride(messageID, storedURL)
-                }
-                guard recorder.receiptCommitSucceeds else { return false }
-                recorder.receiptStates[messageID] = .accepted(storedURL)
-                return true
-            },
-            removeIncomingFile: { storedURL in
-                recorder.removedIncomingFiles.append(storedURL)
-                recorder.removeIncomingFileOverride?(storedURL)
-            },
-            isPrivateMediaSenderBlocked: { peerID in
-                recorder.blockedPeers.contains(peerID)
-            },
             updatePeerLastSeen: { peerID in
                 recorder.lastSeenUpdates.append(peerID)
             },
-            acknowledgePrivateMedia: { messageID, peerID in
-                recorder.deliveryAcks.append((messageID, peerID))
-            },
-            deliverMessage: { message, shouldDeliver, completion in
-                guard shouldDeliver() else { return }
+            deliverMessage: { message in
                 recorder.deliveredMessages.append(message)
-                guard shouldDeliver() else { return }
-                completion()
             }
         )
         return BLEFileTransferHandler(environment: environment)
@@ -140,11 +92,12 @@ struct BLEFileTransferHandlerTests {
     @Test
     func selfEchoIsDropped() throws {
         let recorder = Recorder()
-        recorder.signatureVerifies = true
         let handler = makeHandler(recorder: recorder)
         let packet = try makeFileTransferPacket(sender: localPeerID, mimeType: "application/pdf", content: Data("%PDF-1.7".utf8), ttl: 3)
 
-        #expect(!handler.handle(packet, from: localPeerID))
+        // The relay pipeline already suppresses self-originated packets, so the
+        // handler reports "relayable" rather than treating the echo as forged.
+        #expect(handler.handle(packet, from: localPeerID))
 
         expectNoSideEffects(recorder)
     }
@@ -167,12 +120,7 @@ struct BLEFileTransferHandlerTests {
         let recorder = Recorder()
         recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Bob", isVerified: false, isConnected: true)]
         let handler = makeHandler(recorder: recorder)
-        let packet = try makeFileTransferPacket(
-            sender: remotePeerID,
-            mimeType: "application/pdf",
-            content: Data("%PDF-1.7".utf8),
-            hasSignature: false
-        )
+        let packet = try makeFileTransferPacket(sender: remotePeerID, mimeType: "application/pdf", content: Data("%PDF-1.7".utf8))
 
         // Failed sender authentication must also stop the packet from being
         // relayed to downstream nodes.
@@ -181,7 +129,7 @@ struct BLEFileTransferHandlerTests {
         // Broadcast files carry an attacker-controllable senderID, so — like
         // public messages — a connected-but-unverified peer must present a valid
         // packet signature. No signing key + no signed identity means dropped.
-        #expect(recorder.signedNameQueries.isEmpty)
+        #expect(recorder.signedNameQueries == [remotePeerID])
         #expect(recorder.trackedPackets.isEmpty)
         #expect(recorder.deliveredMessages.isEmpty)
     }
@@ -205,11 +153,12 @@ struct BLEFileTransferHandlerTests {
     }
 
     @Test
-    func signedSelfBroadcastReplayIsDelivered() throws {
-        // Our own broadcast file replayed via gossip sync arrives with ttl==0;
-        // it is verified against our local signing key before delivery.
+    func selfBroadcastReplayIsDeliveredWithoutSignatureCheck() throws {
+        // Our own broadcast file replayed via gossip sync arrives with ttl==0
+        // (so it is not treated as a self-echo) and cannot be verified against
+        // the peer registry — it must still be accepted, matching
+        // BLEPublicMessageHandler's self exemption.
         let recorder = Recorder()
-        recorder.signatureVerifies = true
         let handler = makeHandler(recorder: recorder)
         let packet = try makeFileTransferPacket(
             sender: localPeerID,
@@ -220,7 +169,7 @@ struct BLEFileTransferHandlerTests {
 
         #expect(handler.handle(packet, from: localPeerID))
 
-        #expect(recorder.signatureVerifyCount == 1)
+        #expect(recorder.signatureVerifyCount == 0)
         #expect(recorder.signedNameQueries.isEmpty)
         #expect(recorder.deliveredMessages.count == 1)
         #expect(recorder.deliveredMessages.first?.sender == "Me")
@@ -256,8 +205,7 @@ struct BLEFileTransferHandlerTests {
             sender: remotePeerID,
             mimeType: "audio/mp4",
             content: m4a,
-            fileName: "voice_1122334455667788",
-            hasSignature: false
+            fileName: "voice_1122334455667788"
         )
 
         // The spoofed note must be dropped locally AND not relayed onward.
@@ -267,7 +215,7 @@ struct BLEFileTransferHandlerTests {
     }
 
     @Test
-    func rawDirectedFileWithoutVerifiableSignatureIsDroppedWithoutWriteOrRelay() throws {
+    func privateFileFromConnectedUnverifiedPeerIsAccepted() throws {
         let recorder = Recorder()
         recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Bob", isVerified: false, isConnected: true)]
         let handler = makeHandler(recorder: recorder)
@@ -275,25 +223,23 @@ struct BLEFileTransferHandlerTests {
             sender: remotePeerID,
             mimeType: "application/pdf",
             content: Data("%PDF-1.7".utf8),
-            recipientID: Data(hexString: localPeerID.id),
-            hasSignature: false
+            recipientID: Data(hexString: localPeerID.id)
         )
 
-        #expect(!handler.handle(packet, from: remotePeerID))
+        #expect(handler.handle(packet, from: remotePeerID))
 
+        // Directed transfers keep the lenient connected-peer path (no broadcast
+        // exposure); no signature check is required.
         #expect(recorder.signatureVerifyCount == 0)
         #expect(recorder.signedNameQueries.isEmpty)
-        #expect(recorder.trackedPackets.isEmpty)
-        #expect(recorder.quotaReservations.isEmpty)
-        #expect(recorder.saveCalls.isEmpty)
-        #expect(recorder.deliveredMessages.isEmpty)
+        #expect(recorder.deliveredMessages.count == 1)
+        #expect(recorder.deliveredMessages.first?.isPrivate == true)
     }
 
     @Test
     func fileDirectedToAnotherPeerIsIgnored() throws {
         let recorder = Recorder()
-        recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true, signingPublicKey: sampleSigningKey)]
-        recorder.signatureVerifies = true
+        recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true)]
         let handler = makeHandler(recorder: recorder)
         let packet = try makeFileTransferPacket(
             sender: remotePeerID,
@@ -314,8 +260,7 @@ struct BLEFileTransferHandlerTests {
     @Test
     func privateFileUpdatesLastSeenAndDeliversPrivateMessage() throws {
         let recorder = Recorder()
-        recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true, signingPublicKey: sampleSigningKey)]
-        recorder.signatureVerifies = true
+        recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true)]
         let handler = makeHandler(recorder: recorder)
         let packet = try makeFileTransferPacket(
             sender: remotePeerID,
@@ -331,416 +276,12 @@ struct BLEFileTransferHandlerTests {
         #expect(recorder.lastSeenUpdates == [remotePeerID])
         #expect(recorder.deliveredMessages.count == 1)
         #expect(recorder.deliveredMessages.first?.isPrivate == true)
-        #expect(recorder.deliveredMessages.first?.id.hasPrefix("media-") == false)
         // Must be explicit: BitchatMessage defaults private messages to
         // .sending, which the media views render as an in-flight send
         // (empty reveal mask, disabled reveal tap).
         #expect(recorder.deliveredMessages.first?.deliveryStatus == .delivered(to: "Me", at: Date(timeIntervalSince1970: 900)))
     }
 
-    @Test
-    func bit8EncryptedPrivateFileKeepsStableIDAndAckWithoutBit9Proof() throws {
-        let recorder = Recorder()
-        recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true)]
-        let handler = makeHandler(recorder: recorder)
-        let content = Data([0xFF, 0xD8, 0xFF]) + Data(repeating: 0x41, count: 128)
-        let fileName = "img_20260725_105708_1CC2760D-76AA-40C3-8013-C7FAA6C2EF99.jpg"
-        let file = BitchatFilePacket(
-            fileName: fileName,
-            fileSize: UInt64(content.count),
-            mimeType: "image/jpeg",
-            content: content
-        )
-        let payload = try #require(file.encode())
-        let timestamp = Date(timeIntervalSince1970: 1_234)
-
-        #expect(handler.handlePrivatePayload(payload, from: remotePeerID, timestamp: timestamp))
-
-        #expect(recorder.signatureVerifyCount == 0)
-        #expect(recorder.signedNameQueries.isEmpty)
-        #expect(recorder.trackedPackets.isEmpty)
-        #expect(recorder.quotaReservations == [content.count])
-        #expect(recorder.saveCalls.first?.data == content)
-        #expect(recorder.lastSeenUpdates == [remotePeerID])
-        #expect(recorder.deliveredMessages.count == 1)
-        #expect(recorder.deliveredMessages.first?.isPrivate == true)
-        #expect(recorder.deliveredMessages.first?.timestamp == timestamp)
-        #expect(recorder.deliveredMessages.first?.id == PrivateMediaMessageIdentity.stableID(
-            senderPeerID: remotePeerID,
-            recipientPeerID: localPeerID,
-            fileName: fileName
-        ))
-        #expect(recorder.receiptCommits.count == 1)
-        #expect(recorder.deliveryAcks.count == 1)
-        #expect(recorder.deliveryAcks.first?.messageID == recorder.deliveredMessages.first?.id)
-    }
-
-    @Test
-    func rawLegacyPrivateFileWithRetryShapedNameNeverUsesReceiptLedger() throws {
-        let recorder = Recorder()
-        recorder.peers = [remotePeerID: makePeerInfo(
-            remotePeerID,
-            nickname: "Alice",
-            isVerified: true,
-            signingPublicKey: sampleSigningKey
-        )]
-        recorder.signatureVerifies = true
-        let handler = makeHandler(recorder: recorder)
-        let content = Data([0xFF, 0xD8, 0xFF, 0xD9])
-        let packet = try makeFileTransferPacket(
-            sender: remotePeerID,
-            mimeType: "image/jpeg",
-            content: content,
-            recipientID: Data(hexString: localPeerID.id),
-            fileName: "img_20260725_105708_1CC2760D-76AA-40C3-8013-C7FAA6C2EF99.jpg"
-        )
-
-        #expect(handler.handle(packet, from: remotePeerID))
-        #expect(recorder.receiptCommits.isEmpty)
-        #expect(recorder.deliveryAcks.isEmpty)
-        #expect(recorder.deliveredMessages.count == 1)
-        #expect(recorder.deliveredMessages.first?.id.hasPrefix("media-") == false)
-    }
-
-    @Test
-    func repeatedLegacyPrivateImageNamesKeepDistinctRandomMessageIDs() throws {
-        let recorder = Recorder()
-        recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true)]
-        let handler = makeHandler(recorder: recorder)
-        let content = Data([0xFF, 0xD8, 0xFF]) + Data(repeating: 0x41, count: 128)
-        let file = BitchatFilePacket(
-            fileName: "photo.jpg",
-            fileSize: UInt64(content.count),
-            mimeType: "image/jpeg",
-            content: content
-        )
-        let payload = try #require(file.encode())
-
-        #expect(handler.handlePrivatePayload(
-            payload,
-            from: remotePeerID,
-            timestamp: Date(timeIntervalSince1970: 1_234)
-        ))
-        #expect(handler.handlePrivatePayload(
-            payload,
-            from: remotePeerID,
-            timestamp: Date(timeIntervalSince1970: 1_235)
-        ))
-
-        #expect(recorder.deliveredMessages.count == 2)
-        #expect(recorder.deliveredMessages[0].id != recorder.deliveredMessages[1].id)
-        #expect(recorder.deliveredMessages.allSatisfy { !$0.id.hasPrefix("media-") })
-    }
-
-    @Test
-    func lostCapabilityProofThenStableRetryReusesDurableIDWithoutSecondDiskWrite() throws {
-        let recorder = Recorder()
-        recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true)]
-        let handler = makeHandler(recorder: recorder)
-        let content = Data([0xFF, 0xD8, 0xFF]) + Data(repeating: 0x41, count: 128)
-        let fileName = "img_20260725_105708_1CC2760D-76AA-40C3-8013-C7FAA6C2EF99.jpg"
-        let file = BitchatFilePacket(
-            fileName: fileName,
-            fileSize: UInt64(content.count),
-            mimeType: "image/jpeg",
-            content: content
-        )
-        let payload = try #require(file.encode())
-        let expectedID = try #require(PrivateMediaMessageIdentity.stableID(
-            senderPeerID: remotePeerID,
-            recipientPeerID: localPeerID,
-            fileName: fileName
-        ))
-
-        // First encrypted arrival may precede the sender's authenticated bit-9
-        // proof. It still uses the bit-8 stable ID/ACK contract.
-        #expect(handler.handlePrivatePayload(
-            payload,
-            from: remotePeerID,
-            timestamp: Date(timeIntervalSince1970: 1_234)
-        ))
-        // A later automatic retry after proof must resolve the same durable ID
-        // rather than create a legacy random-ID bubble.
-        #expect(handler.handlePrivatePayload(
-            payload,
-            from: remotePeerID,
-            timestamp: Date(timeIntervalSince1970: 1_235)
-        ))
-
-        #expect(recorder.quotaReservations == [content.count])
-        #expect(recorder.saveCalls.count == 1)
-        // The handler re-offers a durable duplicate so a relaunched UI can
-        // restore its bubble; the synchronous conversation sink deduplicates.
-        #expect(recorder.deliveredMessages.count == 2)
-        #expect(recorder.lastSeenUpdates == [remotePeerID, remotePeerID])
-        #expect(recorder.deliveryAcks.count == 2)
-        #expect(recorder.deliveryAcks.allSatisfy {
-            $0.messageID == expectedID && $0.peerID == remotePeerID
-        })
-    }
-
-    @Test
-    func acceptedPrivateMediaAfterRelaunchRedeliversDurableURLBeforeAck() throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(
-            "private-media-handler-relaunch-\(UUID().uuidString)",
-            isDirectory: true
-        )
-        defer { try? FileManager.default.removeItem(at: root) }
-        let store = BLEIncomingFileStore(baseDirectory: root)
-        let content = Data([0xFF, 0xD8, 0xFF, 0xD9])
-        let file = BitchatFilePacket(
-            fileName: "img_20260725_105708_1CC2760D-76AA-40C3-8013-C7FAA6C2EF99.jpg",
-            fileSize: UInt64(content.count),
-            mimeType: "image/jpeg",
-            content: content
-        )
-        let payload = try #require(file.encode())
-
-        func configure(_ recorder: Recorder) {
-            recorder.peers = [remotePeerID: makePeerInfo(
-                remotePeerID,
-                nickname: "Alice",
-                isVerified: true
-            )]
-            recorder.saveOverride = {
-                data,
-                preferredName,
-                subdirectory,
-                fallbackExtension,
-                defaultPrefix in
-                store.save(
-                    data: data,
-                    preferredName: preferredName,
-                    subdirectory: subdirectory,
-                    fallbackExtension: fallbackExtension,
-                    defaultPrefix: defaultPrefix
-                )
-            }
-            recorder.receiptStateOverride = {
-                store.privateMediaReceiptState(messageID: $0)
-            }
-            recorder.receiptCommitOverride = {
-                store.commitPrivateMediaFile(messageID: $0, storedURL: $1)
-            }
-            recorder.removeIncomingFileOverride = {
-                store.removeIncomingFile(at: $0)
-            }
-        }
-
-        let first = Recorder()
-        configure(first)
-        #expect(makeHandler(recorder: first).handlePrivatePayload(
-            payload,
-            from: remotePeerID,
-            timestamp: Date(timeIntervalSince1970: 1_234)
-        ))
-        let originalMessage = try #require(first.deliveredMessages.first)
-        #expect(first.deliveryAcks.count == 1)
-
-        // A fresh handler models process relaunch: its in-memory reservation
-        // cache is empty, so only the durable receipt can suppress disk work.
-        let relaunched = Recorder()
-        configure(relaunched)
-        #expect(makeHandler(recorder: relaunched).handlePrivatePayload(
-            payload,
-            from: remotePeerID,
-            timestamp: Date(timeIntervalSince1970: 1_235)
-        ))
-
-        #expect(relaunched.quotaReservations.isEmpty)
-        #expect(relaunched.saveCalls.isEmpty)
-        #expect(relaunched.receiptCommits.isEmpty)
-        #expect(relaunched.deliveredMessages.count == 1)
-        #expect(relaunched.deliveredMessages.first?.id == originalMessage.id)
-        #expect(relaunched.deliveredMessages.first?.content == originalMessage.content)
-        #expect(relaunched.deliveryAcks.count == 1)
-        #expect(relaunched.deliveryAcks.first?.messageID == originalMessage.id)
-    }
-
-    @Test
-    func inFlightStableDuplicateIsNotAcknowledgedAndFailedSaveRemainsRetryable() throws {
-        let recorder = Recorder()
-        recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true)]
-        let content = Data([0xFF, 0xD8, 0xFF]) + Data(repeating: 0x41, count: 128)
-        let file = BitchatFilePacket(
-            fileName: "img_20260725_105708_1CC2760D-76AA-40C3-8013-C7FAA6C2EF99.jpg",
-            fileSize: UInt64(content.count),
-            mimeType: "image/jpeg",
-            content: content
-        )
-        let payload = try #require(file.encode())
-        var handler: BLEFileTransferHandler!
-        var nestedResult: Bool?
-        var failFirstSave = true
-        recorder.saveOverride = { _, _, _, _, _ in
-            if failFirstSave {
-                failFirstSave = false
-                nestedResult = handler.handlePrivatePayload(
-                    payload,
-                    from: self.remotePeerID,
-                    timestamp: Date(timeIntervalSince1970: 1_235)
-                )
-                return nil
-            }
-            return recorder.saveResult
-        }
-        handler = makeHandler(recorder: recorder)
-
-        // The nested arrival sees the first reservation as pending. It is
-        // coalesced without an ACK; then the first durable save fails.
-        #expect(!handler.handlePrivatePayload(
-            payload,
-            from: remotePeerID,
-            timestamp: Date(timeIntervalSince1970: 1_234)
-        ))
-        #expect(nestedResult == true)
-        #expect(recorder.saveCalls.count == 1)
-        #expect(recorder.deliveryAcks.isEmpty)
-        #expect(recorder.deliveredMessages.isEmpty)
-
-        // Failure released the reservation, so the sender's later retry can
-        // persist and deliver normally.
-        #expect(handler.handlePrivatePayload(
-            payload,
-            from: remotePeerID,
-            timestamp: Date(timeIntervalSince1970: 1_236)
-        ))
-        #expect(recorder.saveCalls.count == 2)
-        #expect(recorder.deliveryAcks.count == 1)
-        #expect(recorder.deliveredMessages.count == 1)
-    }
-
-    @Test
-    func unavailableDurableReceiptStateWithholdsDiskDeliveryAndAck() throws {
-        let recorder = Recorder()
-        recorder.peers = [remotePeerID: makePeerInfo(
-            remotePeerID,
-            nickname: "Alice",
-            isVerified: true
-        )]
-        let fileName =
-            "img_20260725_105708_1CC2760D-76AA-40C3-8013-C7FAA6C2EF99.jpg"
-        let messageID = try #require(PrivateMediaMessageIdentity.stableID(
-            senderPeerID: remotePeerID,
-            recipientPeerID: localPeerID,
-            fileName: fileName
-        ))
-        recorder.receiptStates[messageID] = .unavailable
-        let handler = makeHandler(recorder: recorder)
-        let content = Data([0xFF, 0xD8, 0xFF, 0xD9])
-        let payload = try #require(BitchatFilePacket(
-            fileName: fileName,
-            fileSize: UInt64(content.count),
-            mimeType: "image/jpeg",
-            content: content
-        ).encode())
-
-        #expect(handler.handlePrivatePayload(
-            payload,
-            from: remotePeerID,
-            timestamp: Date(timeIntervalSince1970: 1_234)
-        ))
-        #expect(recorder.quotaReservations.isEmpty)
-        #expect(recorder.saveCalls.isEmpty)
-        #expect(recorder.receiptCommits.isEmpty)
-        #expect(recorder.deliveredMessages.isEmpty)
-        #expect(recorder.deliveryAcks.isEmpty)
-    }
-
-    @Test
-    func durableReceiptCommitFailureRollsBackAndWithholdsDeliveryAck() throws {
-        let recorder = Recorder()
-        recorder.peers = [remotePeerID: makePeerInfo(
-            remotePeerID,
-            nickname: "Alice",
-            isVerified: true
-        )]
-        recorder.receiptCommitSucceeds = false
-        let handler = makeHandler(recorder: recorder)
-        let content = Data([0xFF, 0xD8, 0xFF, 0xD9])
-        let payload = try #require(BitchatFilePacket(
-            fileName: "img_20260725_105708_1CC2760D-76AA-40C3-8013-C7FAA6C2EF99.jpg",
-            fileSize: UInt64(content.count),
-            mimeType: "image/jpeg",
-            content: content
-        ).encode())
-
-        #expect(!handler.handlePrivatePayload(
-            payload,
-            from: remotePeerID,
-            timestamp: Date(timeIntervalSince1970: 1_234)
-        ))
-        #expect(recorder.saveCalls.count == 1)
-        #expect(recorder.receiptCommits.count == 1)
-        #expect(recorder.removedIncomingFiles.count == 1)
-        #expect(recorder.removedIncomingFiles.first == recorder.saveResult)
-        #expect(recorder.deliveredMessages.isEmpty)
-        #expect(recorder.deliveryAcks.isEmpty)
-    }
-
-    @Test
-    func blockedPrivateMediaIsDroppedBeforeQuotaDiskAndDedupState() throws {
-        let recorder = Recorder()
-        recorder.blockedPeers = [remotePeerID]
-        recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true)]
-        let handler = makeHandler(recorder: recorder)
-        let content = Data([0xFF, 0xD8, 0xFF]) + Data(repeating: 0x41, count: 128)
-        let file = BitchatFilePacket(
-            fileName: "img_20260725_105708_1CC2760D-76AA-40C3-8013-C7FAA6C2EF99.jpg",
-            fileSize: UInt64(content.count),
-            mimeType: "image/jpeg",
-            content: content
-        )
-        let payload = try #require(file.encode())
-
-        #expect(handler.handlePrivatePayload(
-            payload,
-            from: remotePeerID,
-            timestamp: Date(timeIntervalSince1970: 1_234)
-        ))
-
-        #expect(recorder.quotaReservations.isEmpty)
-        #expect(recorder.saveCalls.isEmpty)
-        #expect(recorder.lastSeenUpdates.isEmpty)
-        #expect(recorder.deliveryAcks.isEmpty)
-        #expect(recorder.deliveredMessages.isEmpty)
-
-        // Unblocking must allow a retry through; the blocked attempt cannot
-        // poison the stable-ID dedup reservation.
-        recorder.blockedPeers = []
-        #expect(handler.handlePrivatePayload(
-            payload,
-            from: remotePeerID,
-            timestamp: Date(timeIntervalSince1970: 1_235)
-        ))
-        #expect(recorder.saveCalls.count == 1)
-        #expect(recorder.deliveredMessages.count == 1)
-        #expect(recorder.deliveryAcks.count == 1)
-    }
-
-    @Test
-    func decryptedPrivateFileOverPayloadCapIsRejectedBeforeQuotaOrDiskWrite() {
-        let recorder = Recorder()
-        let handler = makeHandler(recorder: recorder)
-        let oversizedCount = FileTransferLimits.maxPayloadBytes + 1
-        var length = UInt32(oversizedCount).bigEndian
-        var payload = Data([0x04]) // BitchatFilePacket CONTENT TLV
-        withUnsafeBytes(of: &length) { payload.append(contentsOf: $0) }
-        payload.append(Data(repeating: 0x41, count: oversizedCount))
-
-        #expect(!handler.handlePrivatePayload(
-            payload,
-            from: remotePeerID,
-            timestamp: Date(timeIntervalSince1970: 1_234)
-        ))
-
-        #expect(recorder.quotaReservations.isEmpty)
-        #expect(recorder.saveCalls.isEmpty)
-        #expect(recorder.lastSeenUpdates.isEmpty)
-        #expect(recorder.deliveryAcks.isEmpty)
-        #expect(recorder.deliveredMessages.isEmpty)
-    }
-
     @Test
     func malformedPayloadIsTrackedForSyncButDropped() {
         let recorder = Recorder()
@@ -753,7 +294,7 @@ struct BLEFileTransferHandlerTests {
             recipientID: nil,
             timestamp: 900_000,
             payload: Data([0x01, 0x02, 0x03]),
-            signature: Data(repeating: 0x5A, count: 64),
+            signature: nil,
             ttl: TransportConfig.messageTTLDefault
         )
 
@@ -869,33 +410,6 @@ struct BLEFileTransferHandlerTests {
         }
     }
 
-    @Test
-    func panicWipeClearsCachedPrivateMediaReceiptDecisions() throws {
-        let base = FileManager.default.temporaryDirectory
-            .appendingPathComponent(
-                "panic-receipt-cache-\(UUID().uuidString)",
-                isDirectory: true
-            )
-        defer { try? FileManager.default.removeItem(at: base) }
-        let messageID = "media-00112233445566778899aabbccddeeff"
-
-        let seed = BLEPrivateMediaReceiptStore(baseDirectory: base)
-        #expect(seed.recordDeleted(messageID: messageID))
-
-        let store = BLEIncomingFileStore(baseDirectory: base)
-        #expect(
-            store.privateMediaReceiptState(messageID: messageID)
-                == .tombstoned
-        )
-
-        try store.panicWipe()
-
-        #expect(
-            store.privateMediaReceiptState(messageID: messageID)
-                == .absent
-        )
-    }
-
     @Test
     func panicWipeAttemptsDeletionWhenMarkerPersistenceFails() throws {
         enum MarkerFailure: Error { case unavailable }
@@ -1015,8 +529,7 @@ struct BLEFileTransferHandlerTests {
         content: Data,
         ttl: UInt8 = TransportConfig.messageTTLDefault,
         recipientID: Data? = nil,
-        fileName: String = "sample",
-        hasSignature: Bool = true
+        fileName: String = "sample"
     ) throws -> BitchatPacket {
         let filePacket = BitchatFilePacket(
             fileName: fileName,
@@ -1031,7 +544,7 @@ struct BLEFileTransferHandlerTests {
             recipientID: recipientID,
             timestamp: 900_000,
             payload: payload,
-            signature: hasSignature ? Data(repeating: 0x5A, count: 64) : nil,
+            signature: nil,
             ttl: ttl
         )
     }

bitchatTests/Services/BLEFragmentAssemblyBufferTests.swift

@@ -117,35 +117,6 @@ struct BLEFragmentAssemblyBufferTests {
         }
     }
 
-    @Test
-    func encryptedPrivateFileAssemblyGetsFramedFileHeadroom() throws {
-        var buffer = BLEFragmentAssemblyBuffer()
-        let fragmentID = Data(repeating: 0x15, count: 8)
-        let first = try #require(BLEFragmentHeader(packet: makeFragmentPacket(
-            fragmentID: fragmentID,
-            index: 0,
-            total: 2,
-            originalType: MessageType.noiseEncrypted.rawValue,
-            fragmentData: Data(repeating: 0x01, count: FileTransferLimits.maxPayloadBytes)
-        )))
-        let second = try #require(BLEFragmentHeader(packet: makeFragmentPacket(
-            fragmentID: fragmentID,
-            index: 1,
-            total: 2,
-            originalType: MessageType.noiseEncrypted.rawValue,
-            fragmentData: Data([0x02])
-        )))
-
-        _ = buffer.append(first, maxInFlightAssemblies: 8)
-        let result = buffer.append(second, maxInFlightAssemblies: 8)
-
-        if case let .complete(_, data, _) = result {
-            #expect(data.count == FileTransferLimits.maxPayloadBytes + 1)
-        } else {
-            Issue.record("Expected encrypted private-file assembly to use framed-file limit")
-        }
-    }
-
     @Test
     func removeExpiredDropsOldAssemblies() throws {
         var buffer = BLEFragmentAssemblyBuffer()

bitchatTests/Services/BLENoisePayloadFactoryTests.swift

@@ -1,6 +1,5 @@
 import Foundation
 import Testing
-import BitFoundation
 @testable import bitchat
 
 struct BLENoisePayloadFactoryTests {
@@ -32,63 +31,4 @@ struct BLENoisePayloadFactoryTests {
 
         #expect(payload == Data([NoisePayloadType.verifyChallenge.rawValue, 0xCA, 0xFE]))
     }
-
-    @Test
-    func privateFilePayloadPrefixesCanonicalFilePacket() throws {
-        let content = Data("%PDF-secret".utf8)
-        let file = BitchatFilePacket(
-            fileName: "secret.pdf",
-            fileSize: UInt64(content.count),
-            mimeType: "application/pdf",
-            content: content
-        )
-
-        let payload = try #require(BLENoisePayloadFactory.privateFile(file))
-
-        #expect(payload.first == 0x20, "Encrypted files must use Android's deployed wire value")
-        let decoded = try #require(BitchatFilePacket.decode(Data(payload.dropFirst())))
-        #expect(decoded.fileName == "secret.pdf")
-        #expect(decoded.mimeType == "application/pdf")
-        #expect(decoded.content == content)
-    }
-
-    @Test
-    func androidB7f0b33PrivateFilePlaintextFixtureIsByteCompatible() throws {
-        // Runtime-emitted by Android commit b7f0b33d from
-        // BitchatFilePacket("a.txt", 3, "text/plain", [01, 02, 03]) and
-        // NoisePayload(type = FILE_TRANSFER, data = file.encode()).encode().
-        let fixtureHex = "20010005612e7478740200040000000303000a746578742f706c61696e0400000003010203"
-        let fixture = try #require(Data(hexString: fixtureHex))
-
-        let typed = try #require(NoisePayload.decode(fixture))
-        #expect(typed.type == .privateFile)
-        let file = try #require(BitchatFilePacket.decode(typed.data))
-        #expect(file.fileName == "a.txt")
-        #expect(file.fileSize == 3)
-        #expect(file.mimeType == "text/plain")
-        #expect(file.content == Data([0x01, 0x02, 0x03]))
-        #expect(BLENoisePayloadFactory.privateFile(file) == fixture)
-    }
-
-    @Test
-    func prereleasePrivateFileTypeCanonicalizesOnDecode() throws {
-        let encoded = Data([NoisePayloadType.prereleasePrivateFileRawValue, 0xCA, 0xFE])
-        let decoded = try #require(NoisePayload.decode(encoded))
-
-        #expect(decoded.type == .privateFile)
-        #expect(decoded.data == Data([0xCA, 0xFE]))
-        #expect(decoded.encode().first == 0x20)
-    }
-
-    @Test
-    func authenticatedPeerStateUsesPermanent0x21Type() throws {
-        let state = AuthenticatedPeerStatePacket(
-            capabilities: .privateMedia,
-            signingPublicKey: Data(repeating: 0x77, count: 32)
-        )
-        let encoded = try #require(BLENoisePayloadFactory.authenticatedPeerState(state))
-
-        #expect(encoded.first == 0x21)
-        #expect(AuthenticatedPeerStatePacket.decode(from: Data(encoded.dropFirst())) == state)
-    }
 }

bitchatTests/Services/BLENoiseReconnectPolicyTests.swift

@@ -1,118 +0,0 @@
-import BitFoundation
-import Foundation
-import Testing
-@testable import bitchat
-
-@Suite("BLE Noise reconnect policy")
-struct BLENoiseReconnectPolicyTests {
-    @Test("Revalidation requires a cached session and no authenticated link")
-    func revalidationPreconditions() {
-        var policy = BLENoiseReconnectPolicy()
-        let link = BLEIngressLinkID.peripheral("peripheral-a")
-        let now = Date(timeIntervalSince1970: 1_000)
-
-        let withoutSession = policy.shouldRevalidate(
-            on: link,
-            hasEstablishedSession: false,
-            isNoiseAuthenticatedLink: false,
-            hasAuthenticatedPeerLink: false,
-            now: now
-        )
-        #expect(!withoutSession)
-        let authenticated = policy.shouldRevalidate(
-            on: link,
-            hasEstablishedSession: true,
-            isNoiseAuthenticatedLink: true,
-            hasAuthenticatedPeerLink: true,
-            now: now
-        )
-        #expect(!authenticated)
-        let eligible = policy.shouldRevalidate(
-            on: link,
-            hasEstablishedSession: true,
-            isNoiseAuthenticatedLink: false,
-            hasAuthenticatedPeerLink: false,
-            now: now
-        )
-        #expect(eligible)
-    }
-
-    @Test("Revalidation is once per link epoch or after sixty seconds")
-    func revalidationIsBoundPerLinkEpoch() {
-        var policy = BLENoiseReconnectPolicy()
-        let link = BLEIngressLinkID.central("central-a")
-        let start = Date(timeIntervalSince1970: 2_000)
-
-        let initial = policy.shouldRevalidate(
-            on: link,
-            hasEstablishedSession: true,
-            isNoiseAuthenticatedLink: false,
-            hasAuthenticatedPeerLink: false,
-            now: start
-        )
-        #expect(initial)
-        let duringCooldown = policy.shouldRevalidate(
-            on: link,
-            hasEstablishedSession: true,
-            isNoiseAuthenticatedLink: false,
-            hasAuthenticatedPeerLink: false,
-            now: start.addingTimeInterval(59.999)
-        )
-        #expect(!duringCooldown)
-        let afterCooldown = policy.shouldRevalidate(
-            on: link,
-            hasEstablishedSession: true,
-            isNoiseAuthenticatedLink: false,
-            hasAuthenticatedPeerLink: false,
-            now: start.addingTimeInterval(60)
-        )
-        #expect(afterCooldown)
-
-        policy.endLinkEpoch(link)
-        let nextEpoch = policy.shouldRevalidate(
-            on: link,
-            hasEstablishedSession: true,
-            isNoiseAuthenticatedLink: false,
-            hasAuthenticatedPeerLink: false,
-            now: start.addingTimeInterval(60.001)
-        )
-        #expect(nextEpoch)
-    }
-
-    @Test("An authenticated sibling suppresses redundant reconnect")
-    func authenticatedSiblingSuppressesReconnect() {
-        var policy = BLENoiseReconnectPolicy()
-        let link = BLEIngressLinkID.peripheral("unproven-sibling")
-        let start = Date(timeIntervalSince1970: 3_000)
-
-        let suppressed = policy.shouldRevalidate(
-            on: link,
-            hasEstablishedSession: true,
-            isNoiseAuthenticatedLink: false,
-            hasAuthenticatedPeerLink: true,
-            now: start
-        )
-        #expect(!suppressed)
-        let eligible = policy.shouldRevalidate(
-            on: link,
-            hasEstablishedSession: true,
-            isNoiseAuthenticatedLink: false,
-            hasAuthenticatedPeerLink: false,
-            now: start
-        )
-        #expect(eligible)
-    }
-
-    @Test("Reserved replacement bit is not advertised")
-    func reservedReplacementBitIsNotAdvertised() {
-        #expect(
-            !PeerCapabilities.localSupported.contains(
-                .nonDestructiveNoiseReplacement
-            )
-        )
-        #expect(PeerCapabilities.localSupported.contains(.privateMedia))
-        #expect(
-            PeerCapabilities.localSupported.contains(.privateMediaReceipts)
-        )
-    }
-}

bitchatTests/Services/BLENoiseSessionQueuesTests.swift

@@ -48,10 +48,7 @@ struct BLENoiseSessionQueuesTests {
         queues.appendTypedPayload(Data([0x01]), for: peerID)
         queues.appendTypedPayload(Data([0x02]), for: peerID)
 
-        #expect(queues.takeTypedPayloads(for: peerID) == [
-            BLEPendingTypedPayload(payload: Data([0x01]), transferId: nil),
-            BLEPendingTypedPayload(payload: Data([0x02]), transferId: nil)
-        ])
+        #expect(queues.takeTypedPayloads(for: peerID) == [Data([0x01]), Data([0x02])])
         #expect(queues.takeTypedPayloads(for: peerID).isEmpty)
         #expect(queues.takePrivateMessages(for: peerID).map(\.messageID) == ["m1"])
     }
@@ -67,21 +64,4 @@ struct BLENoiseSessionQueuesTests {
 
         #expect(queues.isEmpty)
     }
-
-    @Test
-    func transferIDSurvivesHandshakeQueueAndCanBeCancelledBeforeDrain() {
-        let peerID = PeerID(str: "aaaaaaaaaaaaaaaa")
-        var queues = BLENoiseSessionQueues()
-
-        queues.appendTypedPayload(Data([0x20, 0xAA]), transferId: "media-1", for: peerID)
-        queues.appendTypedPayload(Data([0x01, 0xBB]), for: peerID)
-
-        let removed = queues.removeTypedPayload(transferId: "media-1")
-        let removedAgain = queues.removeTypedPayload(transferId: "media-1")
-        #expect(removed)
-        #expect(!removedAgain)
-        #expect(queues.takeTypedPayloads(for: peerID) == [
-            BLEPendingTypedPayload(payload: Data([0x01, 0xBB]), transferId: nil)
-        ])
-    }
 }

bitchatTests/Services/BLEOutboundFragmentPlannerTests.swift

@@ -108,58 +108,6 @@ struct BLEOutboundFragmentPlannerTests {
         ) == nil)
     }
 
-    @Test("private media v1 accepts exactly 256 fragments and rejects 257")
-    func privateMediaCrossPlatformFragmentBoundary() throws {
-        let maxPayload = makePayload(count: 160 * 1024, seed: 0xFACE_CAFE)
-
-        func plan(payloadCount: Int) throws -> BLEOutboundFragmentPlan {
-            let packet = BitchatPacket(
-                type: MessageType.noiseEncrypted.rawValue,
-                senderID: Data(hexString: "0011223344556677") ?? Data(),
-                recipientID: Data(hexString: "8877665544332211"),
-                timestamp: 0x0102030405,
-                payload: Data(maxPayload.prefix(payloadCount)),
-                signature: nil,
-                ttl: 3,
-                version: 2
-            )
-            return try #require(BLEOutboundFragmentPlanner.makePlan(
-                for: BLEOutboundFragmentTransferRequest(
-                    packet: packet,
-                    pad: false,
-                    maxChunk: nil,
-                    directedPeer: PeerID(str: "8877665544332211"),
-                    transferId: "boundary"
-                ),
-                defaultChunkSize: TransportConfig.bleDefaultFragmentSize,
-                bleMaxMTU: 512,
-                fragmentID: Data(repeating: 0xD4, count: 8)
-            ))
-        }
-
-        func firstPlan(withAtLeast target: Int) throws -> BLEOutboundFragmentPlan {
-            var low = 1
-            var high = maxPayload.count
-            while low < high {
-                let mid = low + (high - low) / 2
-                if try plan(payloadCount: mid).totalFragments >= target {
-                    high = mid
-                } else {
-                    low = mid + 1
-                }
-            }
-            return try plan(payloadCount: low)
-        }
-
-        let at256 = try firstPlan(withAtLeast: 256)
-        let at257 = try firstPlan(withAtLeast: 257)
-
-        #expect(at256.totalFragments == 256)
-        #expect(BLEOutboundFragmentPlanner.isPrivateMediaV1Compatible(at256))
-        #expect(at257.totalFragments == 257)
-        #expect(!BLEOutboundFragmentPlanner.isPrivateMediaV1Compatible(at257))
-    }
-
     private func makePacket(
         payload: Data,
         route: [Data]? = nil,

bitchatTests/Services/BLEOutboundFragmentTransferSchedulerTests.swift

@@ -20,24 +20,6 @@ struct BLEOutboundFragmentTransferSchedulerTests {
         }
     }
 
-    @Test
-    func explicitTransferIDReservesEncryptedPrivateFileFragments() {
-        var scheduler = BLEOutboundFragmentTransferScheduler()
-        let request = makeRequest(
-            type: MessageType.noiseEncrypted.rawValue,
-            transferId: "private-media"
-        )
-
-        let result = scheduler.submit(request, maxConcurrentTransfers: 1)
-
-        if case let .start(_, reservedTransferId) = result {
-            #expect(reservedTransferId == "private-media")
-            #expect(scheduler.activeCount == 1)
-        } else {
-            Issue.record("Expected encrypted private media to reserve its progress slot")
-        }
-    }
-
     @Test
     func submitQueuesFileTransferWhenSlotsAreFull() {
         var scheduler = BLEOutboundFragmentTransferScheduler()

bitchatTests/Services/BLEPeerRegistryTests.swift

@@ -42,37 +42,6 @@ struct BLEPeerRegistryTests {
         #expect(registry.info(for: peerID)?.nickname == "alice-renamed")
     }
 
-    @Test("registry preserves absent versus explicit empty capabilities")
-    func capabilitiesPresenceIsPreserved() {
-        var registry = BLEPeerRegistry()
-        let oldPeer = PeerID(str: "1122334455667788")
-        let modernPeer = PeerID(str: "8877665544332211")
-
-        _ = registry.upsertVerifiedAnnounce(
-            peerID: oldPeer,
-            nickname: "old",
-            noisePublicKey: Data(repeating: 0x11, count: 32),
-            signingPublicKey: Data(repeating: 0x12, count: 32),
-            isConnected: true,
-            now: Date(),
-            capabilities: nil
-        )
-        _ = registry.upsertVerifiedAnnounce(
-            peerID: modernPeer,
-            nickname: "modern",
-            noisePublicKey: Data(repeating: 0x21, count: 32),
-            signingPublicKey: Data(repeating: 0x22, count: 32),
-            isConnected: true,
-            now: Date(),
-            capabilities: []
-        )
-
-        #expect(registry.capabilities(for: oldPeer).isEmpty)
-        #expect(!registry.capabilitiesWereExplicitlyAdvertised(for: oldPeer))
-        #expect(registry.capabilities(for: modernPeer).isEmpty)
-        #expect(registry.capabilitiesWereExplicitlyAdvertised(for: modernPeer))
-    }
-
     @Test("reachability keeps recent verified offline peers only when mesh is attached")
     func reachabilityRequiresMeshAttachmentForOfflinePeers() {
         let offlinePeer = PeerID(str: "1122334455667788")

bitchatTests/Services/BLEPrivateMediaReceiptStoreTests.swift

@@ -1,206 +0,0 @@
-import Foundation
-import Testing
-@testable import bitchat
-
-struct BLEPrivateMediaReceiptStoreTests {
-    private struct TestError: Error {}
-
-    private let messageID = "media-00112233445566778899aabbccddeeff"
-
-    @Test
-    func acceptedReceiptPersistsAcrossStoreInstances() throws {
-        let root = makeRoot("persist")
-        defer { try? FileManager.default.removeItem(at: root) }
-        let payload = try makePayload(in: root)
-
-        let first = BLEPrivateMediaReceiptStore(baseDirectory: root)
-        #expect(first.commitAccepted(messageID: messageID, storedURL: payload))
-        #expect(first.state(for: messageID) == .accepted(payload))
-
-        let relaunched = BLEPrivateMediaReceiptStore(baseDirectory: root)
-        #expect(relaunched.state(for: messageID) == .accepted(payload))
-    }
-
-    @Test
-    func directoryEnumerationFailureIsUnavailableAndRetriesWithoutCachingEmpty() throws {
-        let root = makeRoot("list-failure")
-        defer { try? FileManager.default.removeItem(at: root) }
-        let payload = try makePayload(in: root)
-        #expect(BLEPrivateMediaReceiptStore(baseDirectory: root).commitAccepted(
-            messageID: messageID,
-            storedURL: payload
-        ))
-        let record = receiptRecord(in: root)
-        #expect(FileManager.default.fileExists(atPath: record.path))
-
-        var shouldFail = true
-        let store = BLEPrivateMediaReceiptStore(
-            baseDirectory: root,
-            directoryReader: { directory in
-                if shouldFail {
-                    shouldFail = false
-                    throw TestError()
-                }
-                return try FileManager.default.contentsOfDirectory(
-                    at: directory,
-                    includingPropertiesForKeys: nil
-                )
-            }
-        )
-
-        #expect(store.state(for: messageID) == .unavailable)
-        #expect(FileManager.default.fileExists(atPath: record.path))
-        #expect(store.state(for: messageID) == .accepted(payload))
-    }
-
-    @Test
-    func recordReadFailureIsUnavailableAndPreservesReceiptForRetry() throws {
-        let root = makeRoot("read-failure")
-        defer { try? FileManager.default.removeItem(at: root) }
-        let payload = try makePayload(in: root)
-        #expect(BLEPrivateMediaReceiptStore(baseDirectory: root).commitAccepted(
-            messageID: messageID,
-            storedURL: payload
-        ))
-        let record = receiptRecord(in: root)
-
-        var shouldFail = true
-        let store = BLEPrivateMediaReceiptStore(
-            baseDirectory: root,
-            dataReader: { url in
-                if shouldFail {
-                    shouldFail = false
-                    throw TestError()
-                }
-                return try Data(contentsOf: url)
-            }
-        )
-
-        #expect(store.state(for: messageID) == .unavailable)
-        #expect(FileManager.default.fileExists(atPath: record.path))
-        #expect(store.state(for: messageID) == .accepted(payload))
-    }
-
-    @Test
-    func decodeFailureIsUnavailableAndDoesNotDeleteOrCachePastRepair() throws {
-        let root = makeRoot("decode-failure")
-        defer { try? FileManager.default.removeItem(at: root) }
-        let payload = try makePayload(in: root)
-        #expect(BLEPrivateMediaReceiptStore(baseDirectory: root).commitAccepted(
-            messageID: messageID,
-            storedURL: payload
-        ))
-        let record = receiptRecord(in: root)
-        let durableBytes = try Data(contentsOf: record)
-        let corruptBytes = Data("{not-json".utf8)
-        try corruptBytes.write(to: record, options: .atomic)
-
-        let store = BLEPrivateMediaReceiptStore(baseDirectory: root)
-        #expect(store.state(for: messageID) == .unavailable)
-        #expect(!store.commitAccepted(messageID: messageID, storedURL: payload))
-        #expect(FileManager.default.fileExists(atPath: record.path))
-        #expect(try Data(contentsOf: record) == corruptBytes)
-
-        try durableBytes.write(to: record, options: .atomic)
-        #expect(store.state(for: messageID) == .accepted(payload))
-    }
-
-    @Test
-    func unreadableTombstoneNeverBecomesAbsentOrGetsDeleted() throws {
-        let root = makeRoot("tombstone-decode")
-        defer { try? FileManager.default.removeItem(at: root) }
-        let payload = try makePayload(in: root)
-        let seed = BLEPrivateMediaReceiptStore(baseDirectory: root)
-        #expect(seed.commitAccepted(messageID: messageID, storedURL: payload))
-        #expect(seed.recordDeleted(messageID: messageID))
-        #expect(!FileManager.default.fileExists(atPath: payload.path))
-
-        let record = receiptRecord(in: root)
-        let durableBytes = try Data(contentsOf: record)
-        try Data([0xFF, 0x00, 0x7B]).write(to: record, options: .atomic)
-
-        let relaunched = BLEPrivateMediaReceiptStore(baseDirectory: root)
-        #expect(relaunched.state(for: messageID) == .unavailable)
-        #expect(FileManager.default.fileExists(atPath: record.path))
-
-        try durableBytes.write(to: record, options: .atomic)
-        #expect(relaunched.state(for: messageID) == .tombstoned)
-    }
-
-    @Test
-    func failedTombstonePersistenceDoesNotPoisonVolatileState() throws {
-        let root = makeRoot("failed-tombstone-write")
-        defer { try? FileManager.default.removeItem(at: root) }
-        let store = BLEPrivateMediaReceiptStore(baseDirectory: root)
-        #expect(store.state(for: messageID) == .absent)
-
-        // Force the atomic record write itself to fail after the store has
-        // successfully loaded its empty index.
-        let record = receiptRecord(in: root)
-        try FileManager.default.createDirectory(
-            at: record,
-            withIntermediateDirectories: true
-        )
-        #expect(!store.recordDeleted(messageID: messageID))
-        try FileManager.default.removeItem(at: record)
-
-        // The UI must be able to report the deletion failure without a
-        // process-lifetime tombstone silently hiding a later retry.
-        #expect(store.state(for: messageID) == .absent)
-    }
-
-    @Test
-    func unreleasedAggregateLedgerIsIgnoredAndLeftUntouched() throws {
-        let root = makeRoot("no-legacy-migration")
-        defer { try? FileManager.default.removeItem(at: root) }
-        let files = root.appendingPathComponent("files", isDirectory: true)
-        try FileManager.default.createDirectory(
-            at: files,
-            withIntermediateDirectories: true
-        )
-        let legacy = files.appendingPathComponent(
-            ".private-media-receipts.json",
-            isDirectory: false
-        )
-        let bytes = Data(
-            #"{"entries":{"media-00112233445566778899aabbccddeeff":{"relativePath":"images/incoming/old.jpg","acceptedAt":0}}}"#
-                .utf8
-        )
-        try bytes.write(to: legacy, options: .atomic)
-
-        let store = BLEPrivateMediaReceiptStore(baseDirectory: root)
-        #expect(store.state(for: messageID) == .absent)
-        #expect(try Data(contentsOf: legacy) == bytes)
-    }
-
-    private func makeRoot(_ label: String) -> URL {
-        FileManager.default.temporaryDirectory.appendingPathComponent(
-            "private-media-receipt-\(label)-\(UUID().uuidString)",
-            isDirectory: true
-        )
-    }
-
-    private func makePayload(in root: URL) throws -> URL {
-        let directory = root.appendingPathComponent(
-            "files/images/incoming",
-            isDirectory: true
-        )
-        try FileManager.default.createDirectory(
-            at: directory,
-            withIntermediateDirectories: true
-        )
-        let payload = directory.appendingPathComponent("image.jpg")
-        try Data([0xFF, 0xD8, 0xFF, 0xD9]).write(to: payload)
-        return payload
-    }
-
-    private func receiptRecord(in root: URL) -> URL {
-        root
-            .appendingPathComponent(
-                "files/.private-media-receipts",
-                isDirectory: true
-            )
-            .appendingPathComponent(messageID)
-            .appendingPathExtension("json")
-    }
-}

bitchatTests/Services/SecureIdentityStateManagerTests.swift

@@ -399,59 +399,6 @@ final class SecureIdentityStateManagerTests: XCTestCase {
         XCTAssertTrue(cleared)
     }
 
-    func test_privateMediaCapabilityPinPersistsMonotonicallyAndPanicClearRemovesIt() async {
-        let keychain = MockKeychain()
-        let fingerprint = Data(repeating: 0x42, count: 32).sha256Fingerprint()
-        let manager = SecureIdentityStateManager(keychain)
-
-        XCTAssertFalse(manager.hasObservedPrivateMediaCapability(fingerprint: fingerprint))
-        manager.markPrivateMediaCapable(fingerprint: fingerprint)
-        XCTAssertTrue(
-            manager.hasObservedPrivateMediaCapability(fingerprint: fingerprint),
-            "pin insertion must be synchronously visible to the next downgrade decision"
-        )
-
-        // Re-marking is idempotent, and the encrypted cache carries the pin
-        // across launches.
-        manager.markPrivateMediaCapable(fingerprint: fingerprint)
-        manager.forceSave()
-        let reloaded = SecureIdentityStateManager(keychain)
-        XCTAssertTrue(reloaded.hasObservedPrivateMediaCapability(fingerprint: fingerprint))
-
-        // ChatViewModel's panic path calls this same wipe after deleting
-        // keychain data; the in-memory pin must disappear immediately too.
-        reloaded.clearAllIdentityData()
-        let cleared = await waitUntil {
-            !reloaded.hasObservedPrivateMediaCapability(fingerprint: fingerprint)
-        }
-        XCTAssertTrue(cleared)
-    }
-
-    func test_noiseAuthenticatedSigningKeyBindingPersistsAndPanicClearRemovesIt() async {
-        let keychain = MockKeychain()
-        let fingerprint = Data(repeating: 0x31, count: 32).sha256Fingerprint()
-        let firstKey = Data(repeating: 0x41, count: 32)
-        let rotatedKey = Data(repeating: 0x42, count: 32)
-        let manager = SecureIdentityStateManager(keychain)
-
-        manager.bindAuthenticatedSigningPublicKey(firstKey, fingerprint: fingerprint)
-        XCTAssertEqual(manager.authenticatedSigningPublicKey(forFingerprint: fingerprint), firstKey)
-        // A later authenticated Noise session may legitimately rotate the
-        // announcement signing key.
-        manager.bindAuthenticatedSigningPublicKey(rotatedKey, fingerprint: fingerprint)
-        XCTAssertEqual(manager.authenticatedSigningPublicKey(forFingerprint: fingerprint), rotatedKey)
-
-        manager.forceSave()
-        let reloaded = SecureIdentityStateManager(keychain)
-        XCTAssertEqual(reloaded.authenticatedSigningPublicKey(forFingerprint: fingerprint), rotatedKey)
-
-        reloaded.clearAllIdentityData()
-        let cleared = await waitUntil {
-            reloaded.authenticatedSigningPublicKey(forFingerprint: fingerprint) == nil
-        }
-        XCTAssertTrue(cleared)
-    }
-
     func test_forceSave_withFailingCacheWriteDoesNotPersistCache() async {
         let keychain = FailingCacheSaveKeychain()
         let manager = SecureIdentityStateManager(keychain)

bitchatTests/Services/TransferProgressManagerTests.swift

@@ -49,7 +49,7 @@ struct TransferProgressManagerTests {
                 recorder.append("updated:\(id):\(sent):\(total)")
             case .completed(let id, let total):
                 recorder.append("completed:\(id):\(total)")
-            case .cancelled, .rejected:
+            case .cancelled:
                 break
             }
         }
@@ -85,7 +85,7 @@ struct TransferProgressManagerTests {
                 recorder.append("started:\(id):\(total)")
             case .cancelled(let id, let sent, let total):
                 recorder.append("cancelled:\(id):\(sent):\(total)")
-            case .updated, .completed, .rejected:
+            case .updated, .completed:
                 break
             }
         }
@@ -105,28 +105,6 @@ struct TransferProgressManagerTests {
         #expect(manager.snapshot(id: transferID) == nil)
         _ = cancellable
     }
-
-    @Test("Preflight policy rejection publishes a visible failure reason")
-    @MainActor
-    func rejectBeforeStartPublishesReason() async {
-        let manager = TransferProgressManager()
-        let transferID = "transfer-visible-reject"
-        let recorder = EventRecorder()
-        let cancellable = manager.publisher.sink { event in
-            if case .rejected(let id, let reason) = event {
-                recorder.append("rejected:\(id):\(reason)")
-            }
-        }
-
-        manager.rejectBeforeStart(id: transferID, reason: "upgrade required")
-
-        let didReceive = await TestHelpers.waitUntil({
-            recorder.values == ["rejected:\(transferID):upgrade required"]
-        }, timeout: 5.0)
-        #expect(didReceive)
-        #expect(manager.snapshot(id: transferID) == nil)
-        _ = cancellable
-    }
 }
 
 private final class EventRecorder: @unchecked Sendable {

bitchatTests/Services/UnifiedPeerServiceTests.swift

@@ -266,11 +266,6 @@ private final class TestIdentityManager: SecureIdentityStateManagerProtocol {
         verified.removeAll()
     }
 
-    func markPrivateMediaCapable(fingerprint: String) {}
-    func hasObservedPrivateMediaCapability(fingerprint: String) -> Bool { false }
-    func bindAuthenticatedSigningPublicKey(_ signingPublicKey: Data, fingerprint: String) {}
-    func authenticatedSigningPublicKey(forFingerprint fingerprint: String) -> Data? { nil }
-
     func removeEphemeralSession(peerID: PeerID) {}
 
     func setVerified(fingerprint: String, verified: Bool) {

bitchatTests/SharedContentHandoffTests.swift

@@ -0,0 +1,173 @@
+import BitFoundation
+import Foundation
+import Testing
+@testable import bitchat
+
+@Suite("Share extension handoff", .serialized)
+struct SharedContentHandoffTests {
+    private func makeStore() -> (suite: String, defaults: UserDefaults, store: SharedContentStore) {
+        let suite = "SharedContentHandoffTests.\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        return (suite, defaults, SharedContentStore(defaults: defaults))
+    }
+
+    @Test("A staged share survives an inactive app and a late open")
+    func stagedShareSurvivesLateOpen() throws {
+        let context = makeStore()
+        defer { context.defaults.removePersistentDomain(forName: context.suite) }
+        let stagedAt = Date(timeIntervalSince1970: 1_000_000)
+        let payload = SharedContentPayload.text("review me later", createdAt: stagedAt)
+
+        try context.store.stage(payload, now: stagedAt)
+
+        #expect(context.store.pending(now: stagedAt.addingTimeInterval(60 * 60)) == payload)
+        #expect(context.defaults.data(forKey: SharedContentStore.storageKey) != nil)
+    }
+
+    @Test("Malformed, oversized, unsupported, and expired payloads are rejected and cleared")
+    func invalidPayloadsAreRejectedAndCleared() throws {
+        let context = makeStore()
+        defer { context.defaults.removePersistentDomain(forName: context.suite) }
+        let now = Date(timeIntervalSince1970: 2_000_000)
+
+        context.defaults.set(Data("not-json".utf8), forKey: SharedContentStore.storageKey)
+        #expect(context.store.pending(now: now) == nil)
+        #expect(context.defaults.object(forKey: SharedContentStore.storageKey) == nil)
+
+        context.defaults.set(
+            Data(repeating: 0x41, count: SharedContentPayload.maxEnvelopeBytes + 1),
+            forKey: SharedContentStore.storageKey
+        )
+        #expect(context.store.pending(now: now) == nil)
+        #expect(context.defaults.object(forKey: SharedContentStore.storageKey) == nil)
+
+        let oversized = SharedContentPayload.text(
+            String(repeating: "x", count: SharedContentPayload.maxContentBytes + 1),
+            createdAt: now
+        )
+        #expect(throws: SharedContentHandoffError.contentTooLarge) {
+            try context.store.stage(oversized, now: now)
+        }
+        #expect(context.defaults.object(forKey: SharedContentStore.storageKey) == nil)
+
+        let unsupportedURL = SharedContentPayload(
+            kind: .url,
+            content: "file:///private/tmp/secret.txt",
+            createdAt: now
+        )
+        #expect(throws: SharedContentHandoffError.unsupportedURL) {
+            try context.store.stage(unsupportedURL, now: now)
+        }
+
+        let misleadingControl = SharedContentPayload.text("safe\u{202E}txt", createdAt: now)
+        #expect(throws: SharedContentHandoffError.invalidCharacters) {
+            try context.store.stage(misleadingControl, now: now)
+        }
+
+        let expired = SharedContentPayload.text(
+            "too old",
+            createdAt: now.addingTimeInterval(-SharedContentPayload.retentionSeconds - 1)
+        )
+        context.defaults.set(try JSONEncoder().encode(expired), forKey: SharedContentStore.storageKey)
+        #expect(context.store.pending(now: now) == nil)
+        #expect(context.defaults.object(forKey: SharedContentStore.storageKey) == nil)
+    }
+
+    @Test("Mesh, geohash, and stale private selections resolve to explicit destinations")
+    func destinationsAreExplicit() {
+        let geohashChannel = ChannelID.location(
+            GeohashChannel(level: .city, geohash: "9Q8YY")
+        )
+        let stalePeer = PeerID(str: "0011223344556677")
+
+        #expect(SharedContentDestination.resolve(
+            selectedPrivatePeerID: nil,
+            privateDisplayName: nil,
+            activeChannel: .mesh
+        ) == .mesh)
+        #expect(SharedContentDestination.resolve(
+            selectedPrivatePeerID: nil,
+            privateDisplayName: nil,
+            activeChannel: geohashChannel
+        ) == .geohash("9q8yy"))
+        #expect(SharedContentDestination.resolve(
+            selectedPrivatePeerID: stalePeer,
+            privateDisplayName: "alice",
+            activeChannel: geohashChannel
+        ) == .privateConversation(peerID: stalePeer, displayName: "alice"))
+    }
+
+    @Test("A destination change requires a new confirmation and never consumes on the stale tap")
+    @MainActor
+    func staleDestinationCannotBeConfirmed() throws {
+        let context = makeStore()
+        defer { context.defaults.removePersistentDomain(forName: context.suite) }
+        let now = Date(timeIntervalSince1970: 3_000_000)
+        let payload = SharedContentPayload.text("do not auto-send", createdAt: now)
+        let peer = PeerID(str: "8899aabbccddeeff")
+        let privateDestination = SharedContentDestination.privateConversation(
+            peerID: peer,
+            displayName: "alice"
+        )
+        let model = SharedContentImportModel(store: context.store)
+        try context.store.stage(payload, now: now)
+        model.refresh(destination: privateDestination, now: now)
+
+        #expect(model.confirm(destination: .mesh, now: now) == nil)
+        #expect(model.offer?.destination == .mesh)
+        #expect(context.store.pending(now: now) == payload)
+
+        #expect(model.confirm(destination: .mesh, now: now) == payload.content)
+        #expect(model.offer == nil)
+        #expect(context.store.pending(now: now) == nil)
+    }
+
+    @Test("Confirmation consumes once and cancellation explicitly clears without producing composer text")
+    @MainActor
+    func oneTimeConfirmationAndCancellation() throws {
+        let context = makeStore()
+        defer { context.defaults.removePersistentDomain(forName: context.suite) }
+        let now = Date(timeIntervalSince1970: 4_000_000)
+        let model = SharedContentImportModel(store: context.store)
+
+        let first = SharedContentPayload.text("confirmed", createdAt: now)
+        try context.store.stage(first, now: now)
+        model.refresh(destination: .geohash("u4pruy"), now: now)
+        #expect(model.confirm(destination: .geohash("u4pruy"), now: now) == "confirmed")
+        #expect(model.confirm(destination: .geohash("u4pruy"), now: now) == nil)
+
+        let second = SharedContentPayload.text("cancelled", createdAt: now)
+        try context.store.stage(second, now: now)
+        model.refresh(destination: .mesh, now: now)
+        model.cancel(destination: .mesh, now: now)
+        #expect(model.offer == nil)
+        #expect(context.store.pending(now: now) == nil)
+
+        let third = SharedContentPayload.text("panic-wiped", createdAt: now)
+        try context.store.stage(third, now: now)
+        model.refresh(destination: .mesh, now: now)
+        model.discardAll()
+        #expect(model.offer == nil)
+        #expect(context.store.pending(now: now) == nil)
+    }
+
+    @Test("Cancelling an old review never deletes a newer staged share")
+    @MainActor
+    func cancellationPreservesNewerShare() throws {
+        let context = makeStore()
+        defer { context.defaults.removePersistentDomain(forName: context.suite) }
+        let now = Date(timeIntervalSince1970: 5_000_000)
+        let model = SharedContentImportModel(store: context.store)
+        let old = SharedContentPayload.text("old", createdAt: now)
+        let newer = SharedContentPayload.text("new", createdAt: now)
+
+        try context.store.stage(old, now: now)
+        model.refresh(destination: .mesh, now: now)
+        try context.store.stage(newer, now: now)
+        model.cancel(destination: .mesh, now: now)
+
+        #expect(model.offer?.payload == newer)
+        #expect(context.store.pending(now: now) == newer)
+    }
+}

bitchatTests/ViewSmokeTests.swift

@@ -41,6 +41,7 @@ private struct SmokeFeatureModels {
     let conversationUIModel: ConversationUIModel
     let peerListModel: PeerListModel
     let boardAlertsModel: BoardAlertsModel
+    let sharedContentImportModel: SharedContentImportModel
 }
 
 @MainActor
@@ -99,7 +100,8 @@ private func makeSmokeFeatureModels(for viewModel: ChatViewModel) -> SmokeFeatur
         verificationModel: verificationModel,
         conversationUIModel: conversationUIModel,
         peerListModel: peerListModel,
-        boardAlertsModel: boardAlertsModel
+        boardAlertsModel: boardAlertsModel,
+        sharedContentImportModel: SharedContentImportModel(store: nil)
     )
 }
 
@@ -118,6 +120,7 @@ private func installSmokeEnvironment<V: View>(
         .environmentObject(featureModels.conversationUIModel)
         .environmentObject(featureModels.peerListModel)
         .environmentObject(featureModels.boardAlertsModel)
+        .environmentObject(featureModels.sharedContentImportModel)
 }
 
 @MainActor

docs/PRIVATE-MEDIA-MIGRATION.md

@@ -1,114 +0,0 @@
-# Private-media wire migration
-
-Private files use the `BitchatFilePacket` TLV shared by iOS and Android. The
-preferred direct-message wire form encrypts that complete TLV inside the
-peer's Noise session before BLE fragmentation.
-
-## Wire values and capability
-
-- `NoisePayloadType.privateFile` is `0x20`, the value already deployed by the
-  Android client. New sends must use this value.
-- iOS temporarily accepts `0x09`, which appeared in prerelease builds of the
-  private-media change. Decoders canonicalize it to `privateFile`; they never
-  emit it.
-- `NoisePayloadType.authenticatedPeerState` is permanently assigned `0x21`.
-  It is emitted after every completed/rekeyed Noise XX session and echoed at
-  most once when the remote state arrives, so message-3/proof reordering over
-  different mesh links converges. This type is part of the protocol security
-  boundary and is not removed when the media migration ends.
-- The `0x21` payload starts with version `0x01`, followed by one-byte
-  type/length/value fields. Version 1 requires canonical TLV `0x01` (the
-  minimal little-endian `PeerCapabilities` bitfield, 1-8 bytes) and TLV `0x02`
-  (the 32-byte Ed25519 announcement signing key). Duplicate required fields,
-  non-minimal capabilities, malformed lengths, missing fields, and unknown
-  versions are ignored without changing state. Unknown TLVs are skipped.
-- The public `PeerCapabilities.privateMedia` announce bit is a discovery hint:
-  it starts a Noise handshake, but never selects encrypted sending or creates
-  a pin. A private transfer waits boundedly for the exact session's encrypted
-  `0x21`. A valid bit-8 proof selects Noise `0x20`; a valid no-bit proof or a
-  no-proof timeout reaches the explicit legacy-consent path for an unpinned
-  peer. No timeout automatically sends raw bytes.
-- `PeerCapabilities.privateMediaReceipts` is bit 9. Its exact-session
-  authenticated proof enables bounded sender-side automatic retry; a public
-  announce never does. It does not replace bit 8: encrypted `0x20` media from
-  bit-8-only prior iOS clients keeps the same deterministic stable ID and
-  delivery ACK. Receivers durably commit that ID before UI delivery or ACK, so
-  a lost proof followed by a later bit-9 retry cannot create a second,
-  random-ID bubble.
-- An unpinned peer with a stable Noise key but without that capability is
-  eligible for one signed, directed
-  `fileTransfer`, matching the pre-migration wire form used by older iOS and
-  accepted by current Android clients, only after the sender confirms a
-  per-send warning that the file is not end-to-end encrypted and mesh relays
-  can see it. The
-  consent is consumed by that invocation and is never remembered.
-- A signed announce never creates a pin by itself: an attacker can copy a
-  victim's public Noise key, supply its own Ed25519 key and capability bits,
-  and self-sign an internally consistent announce. Only successfully
-  decrypted `0x21` state pins the authenticated Noise fingerprint and binds
-  the Ed25519 key used by later announces/public messages. A later valid
-  no-bit `0x21` is treated as a downgrade, and raw fallback is blocked even if
-  a caller presents legacy consent. Public no-bit announces cannot overwrite
-  current session-authenticated state.
-- During migration, both an absent capabilities TLV and an explicit TLV
-  without `privateMedia` are legacy-eligible when that stable fingerprint is
-  not pinned. This supports clients that added capability advertisement before
-  encrypted media. Neither shape bypasses a previously authenticated pin.
-
-Older clients decrypt and ignore unknown inner type `0x21`; they do not need to
-understand it to continue using text or the warned legacy media path. They are
-never inferred capable merely because the handshake succeeded.
-
-Removal gates are independent and must not share an arbitrary calendar date:
-
-- Remove the `0x09` receive alias only after every TestFlight/internal build
-  that emitted it has expired and minimum-supported-client policy excludes it.
-- Remove the signed directed raw `0x22` fallback only after minimum-supported
-  iOS and Android clients emit authenticated bit-8 `0x21` state and the legacy
-  population has aged out.
-- Nostr kind `1059` compatibility is a separate envelope migration. Its dual
-  publish/removal gate is not evidence that either BLE compatibility shape can
-  be removed.
-
-## Security boundary
-
-The encrypted form provides Noise confidentiality and peer authentication.
-The fallback is signed and its signature is required on receive, so relays
-cannot forge its sender or contents. It is not confidential: relays can see
-the raw file TLV. The UI says this explicitly and asks on every send. A peer
-without a stable Noise key from a verified registry entry cannot use the
-fallback. Keep it only for the mixed-version migration, and remove it only
-after minimum-supported Android and iOS releases emit authenticated bit-8
-`0x21` state and the legacy population has aged out. Never replace it with an
-unsigned fallback, persist blanket consent, or send both forms.
-
-Incoming clients accept all three migration-era shapes:
-
-| Sender | Inbound form | Result |
-| --- | --- | --- |
-| Current Android | Noise `0x20` | Decrypt and deliver |
-| Prerelease iOS | Noise `0x09` | Decrypt, canonicalize, and deliver |
-| Older client | Signed directed `fileTransfer` | Verify signature and deliver |
-| Forged/unsigned raw sender | Directed `fileTransfer` | Reject |
-
-Panic wipe clears the persistent capability pins together with the rest of
-the encrypted identity cache.
-
-This migration path is mesh-Noise-only (BLE and compatible direct mesh links).
-Nostr private-media transport is unchanged and remains a follow-up. Nostr
-inbound paths explicitly ignore `0x21`; do not infer the mesh consent fallback
-or capability-pin semantics for Nostr delivery.
-
-## Size interoperability
-
-iOS bounds inbound file content at 1 MiB and applies the expanded allocation
-budget only after a large Noise ciphertext authenticates to `0x20` or the
-temporary `0x09` alias. Ordinary Noise messages retain their 64 KiB limit.
-
-Current Android builds cap each reassembly at 256 fragments. Depending on the
-negotiated BLE packet size and routing overhead, that is roughly 110-120 KiB,
-well below iOS's absolute inbound ceiling. Private-media v1 therefore runs the
-actual route-aware BLE fragment planner before both encrypted and consented
-legacy sends and rejects any plan above 256 fragments with a visible failure.
-This fragment-count contract, rather than a guessed byte threshold, stays
-correct as route overhead changes.