Yield during main actor stress testing

Remove unused timeline helper
Avoid index rebuilds at conversation cap
2026-07-25 17:05:19 +00:00 · 2026-07-10 17:24:10 -04:00 · 2026-07-10 17:18:10 -04:00 · 2026-07-10 15:19:56 -04:00 · 2026-07-10 15:16:02 +02:00 · 2026-07-10 14:04:09 +02:00
383 changed files with 81493 additions and 7407 deletions
@@ -0,0 +1,30 @@
 name: Dead Code
 on:
  push:
    branches:
      - main
  pull_request:
 jobs:
  periphery:
    name: Periphery scan
    runs-on: macos-latest
    timeout-minutes: 30
    # Advisory, like SwiftLint (#1361): findings annotate the PR but don't
    # block merges. Drop continue-on-error once the baseline proves stable.
    continue-on-error: true
    steps:
      - name: Checkout code
        uses: actions/checkout@v5
      - name: Install Periphery
        # homebrew-core formula; the peripheryapp tap lags years behind.
        run: brew install periphery
      - name: Scan for dead code
        # Config comes from .periphery.yml; known findings (mostly iOS-only
        # code invisible to a macOS scan) are suppressed by the committed
        # baseline. --strict fails the step when NEW dead code appears.
        run: periphery scan --strict --disable-update-check
@@ -12,7 +12,10 @@ jobs:
    runs-on: macos-latest
    # A hung test must fail fast, not hold a runner for GitHub's 360-minute
    # default (observed: intermittent app-suite hangs starving the queue).
-    timeout-minutes: 15
+    # The long steps carry tighter individual bounds (5-minute test watchdog,
    # 6-minute benchmark step, 10-minute floor gate that may re-run the
    # benchmarks up to twice on a noisy runner); this is the backstop.
    timeout-minutes: 25
    strategy:
      fail-fast: false # Don't cancel other matrix jobs when one fails
@@ -102,9 +105,14 @@ jobs:
      # Order-of-magnitude performance regression gate. Floors are deliberately
      # generous (see bitchatTests/Performance/perf-floors.json) so this
-      # catches algorithmic regressions, never runner variance.
+      # catches algorithmic regressions, never runner variance. If a metric
      # still lands below floor (a saturated runner can dip one), the script
      # re-runs the benchmarks — appending to the same log and keeping each
      # benchmark's best value per metric — so noise clears on retry while a
      # real regression fails every attempt. Floors are never lowered by this.
      - name: Performance floor gate
        if: matrix.name == 'app'
        timeout-minutes: 10
        run: ./scripts/check-perf-floors.sh perf-output.log
      # Informational only: surfaces per-file and total line coverage in the
@@ -123,10 +131,10 @@ jobs:
            echo "No coverage data found; skipping summary."
          fi
-  # SPM tests above only compile the macOS slice; this job covers the
+  # SPM tests do not link the shipping app targets. This job covers the
-  # iOS-conditional code paths (UIKit, CoreBluetooth restoration, etc.).
+  # iOS-conditional paths and both universal Release link configurations.
  ios-build:
-    name: Build iOS app (simulator)
+    name: Build Release apps (universal)
    runs-on: macos-latest
    timeout-minutes: 15
@@ -135,13 +143,52 @@ jobs:
        uses: actions/checkout@v5
      - name: Build iOS (simulator, no signing)
-        # arm64 only: the vendored arti.xcframework has no x86_64 simulator slice.
+        # Build both simulator architectures so CI validates every vendored
        # Arti simulator slice and the configuration that ships.
        run: |
          set -o pipefail
          xcodebuild -project bitchat.xcodeproj \
            -scheme "bitchat (iOS)" \
            -configuration Release \
            -sdk iphonesimulator \
            -destination 'generic/platform=iOS Simulator' \
-            ARCHS=arm64 \
+            ARCHS='arm64 x86_64' \
            ONLY_ACTIVE_ARCH=NO \
            CODE_SIGNING_ALLOWED=NO \
            build
      - name: Build macOS (universal, no signing)
        run: |
          set -o pipefail
          xcodebuild -project bitchat.xcodeproj \
            -scheme "bitchat (macOS)" \
            -configuration Release \
            -destination 'generic/platform=macOS' \
            ARCHS='arm64 x86_64' \
            ONLY_ACTIVE_ARCH=NO \
            CODE_SIGNING_ALLOWED=NO \
            build
  # 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.
  lint:
    name: SwiftLint (advisory)
    runs-on: ubuntu-latest
    timeout-minutes: 15
    # This job runs a third-party container image, so give it the least
    # privilege we can: a read-only token, and no credentials left in the
    # checkout for the container to find.
    permissions:
      contents: read
    container:
      # Tag for readability, digest for immutability (tags can be repointed).
      # Bump both together, deliberately — never a floating tag.
      image: ghcr.io/realm/swiftlint:0.65.0@sha256:a482729f4b58741875af1566f23397f3f6db300372756fc31606d0a4527fab9e
    continue-on-error: true
    steps:
      - uses: actions/checkout@v5
        with:
          persist-credentials: false
      - name: Run SwiftLint
        run: swiftlint lint --reporter github-actions-logging
@@ -0,0 +1 @@
 {"v1":{"usrs":["param-buf-arti_bootstrap_summary(_:_:)-s:3Tor22arti_bootstrap_summary33_954FD7701B4E47ABB5F166D1CF862DC9LLys5Int32VSpys4Int8VG_AEtF","param-dataDir-arti_start(_:_:)-s:3Tor10arti_start33_954FD7701B4E47ABB5F166D1CF862DC9LLys5Int32VSPys4Int8VG_s6UInt16VtF","param-len-arti_bootstrap_summary(_:_:)-s:3Tor22arti_bootstrap_summary33_954FD7701B4E47ABB5F166D1CF862DC9LLys5Int32VSpys4Int8VG_AEtF","param-socksPort-arti_start(_:_:)-s:3Tor10arti_start33_954FD7701B4E47ABB5F166D1CF862DC9LLys5Int32VSPys4Int8VG_s6UInt16VtF","s:13BitFoundation16PeerCapabilitiesV8wifiBulkACvpZ","s:13BitFoundation18KeychainReadResultO18isRecoverableErrorSbvp","s:13BitFoundation23KeychainManagerProtocolP11secureClearyySSzF","s:18bitchatTests_macOS12MockKeychainC11secureClearyySSzF","s:18bitchatTests_macOS20TrackingMockKeychainC11resetCountsyyF","s:18bitchatTests_macOS20TrackingMockKeychainC11secureClearyySSzF","s:18bitchatTests_macOS20TrackingMockKeychainC25totalSecureClearCallCountSivp","s:18bitchatTests_macOS20TrackingMockKeychainC26secureClearStringCallCountSivp","s:18bitchatTests_macOS20TrackingMockKeychainC27_secureClearStringCallCount06_AB6D1M24FD239F2969C82F4108818260LLSivp","s:18bitchatTests_macOS24FailingCacheSaveKeychain33_22380C7A11A569A0B83FA83F34C498A7LLC11secureClearyySSzF","s:18bitchatTests_macOS24MockGeohashPresenceTimer33_483587EFB96650EE130EFB09BBA2A1AALLC7handleryycvp","s:3Tor0A7ManagerC21goDormantOnBackgroundyyF","s:7bitchat10AppRuntimeC24handleScreenshotCaptured33_C8B369AD8BC1D9963A50CEDA77A4332ALLyyF","s:7bitchat10AppRuntimeC33handleDidBecomeActiveNotificationyyF","s:7bitchat10BLEServiceC18logBluetoothStatus33_69191C53E68500C17D98DBCF2BDA7100LLyySSF","s:7bitchat10BLEServiceC20centralRestorationID33_69191C53E68500C17D98DBCF2BDA7100LLSSvpZ","s:7bitchat10BLEServiceC22captureBluetoothStatus33_69191C53E68500C17D98DBCF2BDA7100LL7contextySS_tF","s:7bitchat10BLEServiceC23peripheralRestorationID33_69191C53E68500C17D98DBCF2BDA7100LLSSvpZ","s:7bitchat10BLEServiceC29scheduleBluetoothStatusSample33_69191C53E68500C17D98DBCF2BDA7100LL5after7contextySd_SStF","s:7bitchat10QRScanViewV8isActiveSbvp","s:7bitchat15BLEPeerRegistryV5countSivp","s:7bitchat15KeychainManagerC11secureClearyySSzF","s:7bitchat15PaymentChipViewV7openURL33_10AC50641B1EBCD52E5092A2E521D236LL7SwiftUI13OpenURLActionVvp","s:7bitchat15TransportConfigO29uiBatchDispatchStaggerSecondsSdvpZ","s:7bitchat15TransportConfigO35uiShareExtensionDismissDelaySecondsSdvpZ","s:7bitchat15TransportConfigO38bleBackgroundPendingConnectSlotReserveSivpZ","s:7bitchat17GossipSyncManagerC10persistNowyyF","s:7bitchat17NostrRelayManagerC15InboundEventKey33_E4160FE8A9A2C9D6308EAAD5A8B5CB07LLV7eventIDSSvp","s:7bitchat25LocationNotesDependenciesV3now10Foundation4DateVycvp","s:7bitchat25NWPathReachabilityMonitorC7monitor33_84633C9DBCAF57538179C1E04DB8E015LL7Network0bD0CSgvp"]}}
@@ -0,0 +1,21 @@
 # Periphery dead-code scan configuration (https://github.com/peripheryapp/periphery)
 #
 # CI runs the macOS scheme only (an iOS scan needs a device destination and
 # doubles the build time). macOS-only scans falsely flag iOS-only code —
 # state restoration, screenshot handlers, background BLE sampling — so those
 # findings live in .periphery.baseline.json rather than being "fixed".
 # When auditing by hand, scan BOTH schemes and intersect:
 #   periphery scan --schemes "bitchat (iOS)" -- -destination 'generic/platform=iOS' ARCHS=arm64
 project: bitchat.xcodeproj
 schemes:
  - bitchat (macOS)
 retain_swift_ui_previews: true
 # Codable properties are (de)serialized via synthesized conformances the
 # indexer doesn't always attribute reads to: PrekeyBundleStore.StoredBundle
 # .noiseKey flaked CI as "assign-only" even while read in loadFromDisk —
 # and slipped past its baselined USR. Retaining Codable properties outright
 # is deterministic; a truly-dead Codable field is a persisted-format change
 # anyway, never a safe mechanical delete.
 retain_codable_properties: true
 relative_results: true
 baseline: .periphery.baseline.json
@@ -0,0 +1,34 @@
 # Build artifacts and generated sources; keeps local `swiftlint` runs clean
 # (CI checkouts are fresh, so this only matters in a working tree).
 excluded:
  - .build
  - .claude
  - .swiftpm
  - .DerivedData
  - DerivedData
  - build
  - localPackages/*/.build
 disabled_rules:
  - line_length
  - type_name
  - identifier_name
  - statement_position
  - implicit_optional_initialization
  - force_try
  - vertical_whitespace
  - for_where
  - control_statement
  - void_function_in_ternary
  - redundant_discardable_let  # SwiftUI breaks without it
  # To be enabled as we fix the issues
  - trailing_whitespace
  - cyclomatic_complexity
  - function_body_length
  - function_parameter_count
  - type_body_length
  - file_length
  - large_tuple
  - force_cast
  - multiple_closures_with_trailing_closure
  - nesting
@@ -1,4 +1,4 @@
-MARKETING_VERSION = 1.5.3
+MARKETING_VERSION = 1.7.1
 CURRENT_PROJECT_VERSION = 1
 IPHONEOS_DEPLOYMENT_TARGET = 16.0
@@ -1,165 +1,155 @@
 # bitchat Privacy Policy
-*Last updated: June 2026*
+*Last updated: July 2026*
 ## Our Commitment
-bitchat is designed with privacy as its foundation. We believe private communication is a fundamental human right. This policy explains how bitchat protects your privacy.
+bitchat is designed for private, account-free communication. This policy describes what the app keeps on your device, what it sends when you use mesh or optional internet features, and how long local data can remain.
 ## Summary
- **No personal data collection** - We don't collect names, emails, or phone numbers
+- **No project-operated accounts or messaging servers** — Bluetooth mesh is peer-to-peer; optional internet features use public or user-selected Nostr relays.
- **No accounts or company servers** - Mesh chat works peer-to-peer; optional Nostr features use public or user-selected relays
+- **No analytics, advertising, telemetry, or tracking** — the app does not contain an analytics or advertising SDK.
- **No tracking** - We have no analytics, telemetry, or user tracking
+- **No sale of data** — the project does not sell user data or build advertising profiles.
- **Open source** - You can verify these claims by reading our code
+- **Open source** — the storage, networking, and cryptography described here can be inspected in the source code.
-## What Information bitchat Stores
+## What bitchat Stores on Your Device
-### On Your Device Only
+1. **Identity and cryptographic keys**
   - Noise, signing, group, prekey, and optional Nostr identity material is generated locally.
   - Secret keys are stored in the system keychain. Public keys are shared when required for messaging, verification, groups, or Nostr events.
   - Keys remain until they are rotated, removed by the relevant feature, erased with panic wipe, or removed with the app.
-1. **Identity Keys**
+2. **Nickname, preferences, and relationships**
-   - Cryptographic private keys generated on first launch or when optional Nostr identities are created
+   - Your nickname, settings, favorites, petnames, read-receipt identifiers, and bounded operational metadata are stored locally.
-   - Stored locally in your device's secure storage
+   - The share extension briefly places content you choose to share in the app-group preferences so the main app can import it.
   - Allows you to maintain "favorite" relationships across app restarts
   - Private keys never leave your device; public keys are shared when needed for messaging
-2. **Nickname**
+3. **Private group state**
-   - The display name you choose (or auto-generated)
+   - Group names, rosters, creator identity, and key epoch are stored as protected files in Application Support.
-   - Stored only on your device
+   - Current group keys are stored in the keychain. Group state remains until you leave or remove the group, panic-wipe the app, or remove the app.
   - Shared with peers you communicate with
-3. **Message History** (if enabled)
+4. **Queued and carried private messages**
-   - When room owners enable retention, messages are saved locally
+   - An outgoing private message that has not been acknowledged may remain for up to 24 hours in a bounded, encrypted outbox. The outbox is sealed with ChaCha20-Poly1305 and its key is stored in the keychain.
-   - Stored encrypted on your device
+   - A device acting as a courier may store a bounded opaque end-to-end encrypted envelope for another user for up to 24 hours. The courier cannot read its message content.
-   - You can delete this at any time
+   - A panic wipe deletes both stores.
-4. **Favorite Peers**
+5. **Recent public mesh messages and notices**
-   - Public keys of peers you mark as favorites
+   - Signed public mesh messages may be kept in a protected local gossip archive for up to 15 minutes so they can cross mesh partitions and survive a short relaunch.
-   - Stored only on your device
+   - Public bulletin-board posts and deletion tombstones persist until the post's author-selected expiry, at most seven days. Both stores are bounded and panic-wipeable.
-   - Allows you to recognize these peers in future sessions
+   - These items are public to the mesh or board where they are posted; they are not confidential messages.
-5. **Optional Location Channel State**
+6. **Media attachments**
-   - Your selected geohash channel, bookmarked geohashes, teleport flags, and bookmark display names
+   - Voice notes and images you send or receive can be stored under Application Support so they remain playable while referenced by the app.
-   - Stored locally on your device so the location-channel UI can restore your choices
+   - Incoming media is subject to a 100 MB quota with oldest-file eviction. Media is deleted by panic wipe or app removal; some outgoing media can otherwise remain on disk.
   - Per-geohash Nostr identities are derived locally from a device seed stored in secure storage
   - Exact latitude and longitude are not persisted by bitchat
-### Temporary Session Data
+7. **Optional location-channel state**
   - Your selected geohash channel, bookmarks, teleport flags, and bookmark display names are stored locally so the UI can restore them.
   - Per-geohash Nostr identities are derived locally from a device seed stored in the keychain.
   - bitchat does not persist exact latitude or longitude and does not include exact coordinates in mesh or Nostr messages.
-During each session, bitchat temporarily maintains:
+## Temporary Session Data
 - Active peer connections (forgotten when app closes)
 - Routing information for message delivery
 - Cached messages for offline peers (12 hours max)
 - Your current location while optional location channels are enabled, used locally to compute geohash channels and friendly place names
-## What Information is Shared
+While running, bitchat maintains active connections, routing state, deduplication state, and bounded in-memory conversation timelines. Closing the app clears the in-memory timelines and active connections, but it does not erase the persistent stores listed above.
-### With Other bitchat Users
+## What Is Shared
-When you use bitchat, nearby peers can see:
+### With Nearby Mesh Users
 - Your chosen nickname
 - Your ephemeral public key (changes each session)
 - Messages you send to public rooms or directly to them
 - Your approximate Bluetooth signal strength (for connection quality)
-### With Room Members
+Depending on the feature you use, nearby peers can receive:
-When you join a password-protected room:
+- Your chosen nickname and public Noise/signing identity material.
- Your messages are visible to others with the password
+- Announce metadata such as supported capability flags and a bounded list of short direct-neighbor identifiers. When the bridge is enabled, an announce can also include its coarse rendezvous geohash cell.
- Your nickname appears in the member list
+- Public mesh messages, public notices, and group-control packets you intentionally send.
- Room owners can see you've joined
+- Private ciphertext addressed to them, or opaque courier ciphertext they agree to carry.
 - Radio metadata available to the receiver, such as approximate Bluetooth signal strength.
-### With Nostr Relays (Optional Features)
+Noise identity keys can persist across sessions; do not treat them as anonymous identifiers. Panic wipe rotates local identity state.
-If you enable Nostr-backed features:
+### With Private Group Members
 - Private fallback messages to mutual favorites are sent as encrypted NIP-17 gift wraps. Relays can see event metadata, but not message content.
 - Public location-channel messages, location notes, and presence are scoped with geohash tags. Relays and other participants can see the geohash tag, event kind, timestamp, and public key used for that geohash.
 - Exact GPS coordinates are not included in Nostr events by bitchat. The geohash precision you choose can still reveal an approximate area, from region-level to building-level.
 - Automatic presence heartbeats are limited to low-precision geohashes (region, province, and city). More precise geohash posts happen only when you use those channels or location notes.
-## What We DON'T Do
+Private group members receive the group's name, roster, key epoch, and encrypted group traffic needed to participate. Group messages are confidential to devices holding the current group key, subject to the security of those devices and members.
-bitchat **never**:
+### With Nostr Relays and Internet Gateways
 - Collects personal information
 - Sells or shares your exact GPS location
 - Stores data on servers we operate
 - Sells your data to advertisers or data brokers
 - Uses analytics or telemetry
 - Creates user profiles
 - Requires registration
-## Encryption
+Internet-backed features are optional. When enabled or used:
-All private messages use end-to-end encryption:
+- Private fallback messages use encrypted NIP-17 gift wraps. Relays can observe event and network metadata but not the message plaintext.
- **X25519** for key exchange
+- Public location-channel messages, notes, notices, and presence include a geohash tag, event kind, timestamp, and a public key. A geohash reveals an approximate area; finer precision reveals a smaller area.
- **AES-256-GCM** for message encryption
+- The optional mesh bridge publishes bridge-enabled public mesh messages and presence to a neighborhood rendezvous cell. Those messages are public to participants and relays for that cell. A per-message “nearby only” choice prevents that message from crossing the bridge.
- **Ed25519** for digital signatures
+- Bridge courier drops contain opaque end-to-end encrypted envelopes and a rotating recipient tag. Relays still observe timing and network metadata.
- **Argon2id** for password-protected rooms
+- A device with gateway features enabled may relay signed bridge/location traffic or opaque courier envelopes for nearby mesh devices.
-## Your Rights
+Nostr relays are operated by third parties. Their retention, logging, availability, and privacy practices are outside the project's control. Public events and encrypted events may remain on relays according to each relay's policy.
-You have complete control:
+## Location and Apple Services
 - **Delete Local State**: Triple-tap the logo to instantly wipe local keys, sessions, caches, and preferences
 - **Leave Anytime**: Close the app and local presence stops; relay-backed presence ages out
 - **No Account**: No account record exists for you to delete from us
 - **Portability**: Your local state stays on your device unless you send messages, use optional relay-backed features, or export it
-## Bluetooth & Permissions
+Location permission is optional and requested as when-in-use access. It is used to compute geohash channels, bridge rendezvous cells, and nearby place labels.
-bitchat requires Bluetooth permission to function:
+- Exact coordinates are not included in bitchat mesh or Nostr payloads and are not persisted by bitchat.
- Used only for peer-to-peer communication
+- A selected geohash can still reveal an approximate area to peers and relays.
- Bluetooth is not used for tracking
+- When bitchat asks the operating system for a friendly place name, Apple's `CLGeocoder` service may process the location under Apple's privacy terms.
- You can revoke this permission at any time in system settings
+- Revoking location permission stops live location sampling. Saved bookmarks remain until you remove them, panic-wipe the app, or remove the app.
-## Location Permission
+## Microphone, Camera, and Media Permissions
-Location permission is optional and is used only for location channels:
+- Microphone access is used only while you record a voice note or actively hold live push-to-talk. The resulting audio is sent to the mesh conversation you selected; public-conversation audio is public to that mesh, while private-conversation audio uses the private transport protections described below.
- Used to compute local geohash channels and display names
+- Voice-note and live-audio files can remain in Application Support under the media retention rules above.
- Requested as when-in-use permission
+- Camera access is used to scan peer-verification QR codes. Photo-library access is used when you choose an image to send.
- Exact coordinates are not shared in messages or stored by bitchat
+- These permissions can be revoked in system settings. bitchat does not record microphone or camera input while the related capture UI is inactive.
- Selected and bookmarked geohashes may persist locally until you remove them, use panic wipe, or delete the app
+
- You can revoke this permission at any time in system settings
+## Cryptography
 Private and public features use different protections:
 - Mesh private sessions use Noise XX with X25519, ChaCha20-Poly1305, and SHA-256.
 - Private group messages use ChaCha20-Poly1305; group state and relevant mesh packets use Ed25519 signatures.
 - Nostr events use secp256k1 Schnorr signatures. NIP-44 v2 private payloads use secp256k1 key agreement, HKDF-SHA256, and XChaCha20-Poly1305.
 - The persistent private-message outbox uses ChaCha20-Poly1305 with a key held in the keychain. Some other protected local identity state uses AES-GCM.
 - Public mesh, bridge, geohash, and board content is signed or authenticated as appropriate but is intentionally not confidential.
 No cryptographic system can protect content after a recipient reads, copies, screenshots, or exports it.
 ## Data Retention Summary
 - **In-memory chat timelines and active connections:** until the app closes or state is cleared.
 - **Queued outgoing private messages:** until acknowledged, dropped by bounded policy, or 24 hours, whichever comes first.
 - **Opaque courier envelopes:** until handed off, evicted by bounded policy, or 24 hours, whichever comes first.
 - **Recent public mesh gossip:** up to 15 minutes.
 - **Public board posts and tombstones:** until expiry, at most seven days.
 - **Groups, favorites, preferences, identity keys, bookmarks, and media:** until removed by the feature, panic wipe, quota eviction where applicable, or app removal.
 - **Nostr data:** according to the policies of the relays that receive it.
 ## Your Controls
 - **Panic wipe:** Triple-tap the logo to clear local keys, sessions, preferences, groups, queues, carried mail, public archives, board data, and media managed by the app.
 - **Feature controls:** Location channels, mesh bridge, internet gateway, and related internet behaviors can be disabled in the app. Some already-published relay data cannot be recalled.
 - **System permissions:** Bluetooth, location, microphone, camera, and photo-library access can be revoked in system settings.
 - **No account:** The project operates no account record for you to request or export.
 ## What the Project Does Not Do
 bitchat does not:
 - Operate an account database or project-owned messaging backend.
 - Include advertising, analytics, or tracking SDKs.
 - Sell user data or create advertising profiles.
 - Include exact GPS coordinates in bitchat mesh or Nostr message payloads.
 ## Children's Privacy
-bitchat does not knowingly collect information from children. The app has no age verification because it collects no personal information from anyone.
+The project does not knowingly operate a service that collects children's personal data. The app has no account registration or age-verification system. Users and guardians should understand that public mesh, board, bridge, and location-channel posts are visible to other participants and may be relayed.
 ## Data Retention
 - **Messages**: Deleted from memory when app closes (unless room retention is enabled)
 - **Identity Key**: Persists until you delete the app
 - **Favorites**: Persist until you remove them or delete the app
 - **Location channel choices**: Selected/bookmarked geohashes persist locally until removed, panic-wiped, or the app is deleted
 - **Nostr relay data**: Public geohash events and encrypted gift wraps may be retained by relays according to each relay's policy
 - **Everything Else**: Exists only during active sessions
 ## Security Measures
 - All communication is encrypted
 - No accounts or company servers
 - Optional Nostr relays receive only the events needed for Nostr-backed private fallback or public location channels
 - Open source code for public audit
 - Regular security updates
 - Cryptographic signatures prevent tampering
 ## Changes to This Policy
-If we update this policy:
+Material behavior changes will be reflected in this document and its “Last updated” date. Updating this policy cannot retroactively retrieve data that remained only on a user's device.
 - The "Last updated" date will change
 - The updated policy will be included in the app
 - No retroactive changes can make us collect data already held only in your app
 ## Contact
 bitchat is an open source project. For privacy questions:
 - View our source code: [https://github.com/permissionlesstech/bitchat/tree/main](https://github.com/permissionlesstech/bitchat/tree/main)
 - Open an issue on GitHub
 - Join the discussion in public rooms
-## Philosophy
+- View the source: [https://github.com/permissionlesstech/bitchat](https://github.com/permissionlesstech/bitchat)
-
+- Open an issue on GitHub.
 Privacy isn't just a feature—it's the entire point. bitchat proves that modern communication doesn't require surrendering your privacy. No accounts, no company servers, no analytics. Just people talking freely.
 ---
-*This policy is released into the public domain under The Unlicense, just like bitchat itself.*
+*This policy is released into the public domain under The Unlicense, like the project itself.*
@@ -13,9 +13,9 @@ let package = Package(
        .executable(
            name: "bitchat",
            targets: ["bitchat"]
-        ),
+        )
    ],
-    dependencies:[
+    dependencies: [
        .package(path: "localPackages/Arti"),
        .package(path: "localPackages/BitFoundation"),
        .package(path: "localPackages/BitLogger"),
@@ -1,309 +1,141 @@
-# BitChat Protocol Whitepaper
+# bitchat Protocol Whitepaper
-**Version 1.1**
+**Version 2.0**
-**Date: July 25, 2025**
+**Date: July 6, 2026**
 ---
 ## Abstract
-BitChat is a decentralized, peer-to-peer messaging application designed for secure, private, and censorship-resistant communication over ephemeral, ad-hoc networks. This whitepaper details the BitChat Protocol Stack, a layered architecture that combines a modern cryptographic foundation with a flexible application protocol. At its core, BitChat leverages the Noise Protocol Framework (specifically, the `XX` pattern) to establish mutually authenticated, end-to-end encrypted sessions between peers. This document provides a technical specification of the identity management, session lifecycle, message framing, and security considerations that underpin the BitChat network.
+bitchat is a decentralized, peer-to-peer messaging application for secure, private, censorship-resistant communication that works with or without the internet. Nearby devices form an ad-hoc Bluetooth Low Energy (BLE) mesh; distant peers are reached over the Nostr protocol when a connection exists. A layered store-and-forward stack — a persistent sender outbox, opportunistic couriers with a spray-and-wait copy budget, gossip-synced public history, and Nostr relay mailboxes — delivers messages to peers who are out of range at send time. This document describes the protocol and its delivery guarantees as implemented.
 ---
-## 1. Introduction
+## 1. Design Goals
-In an era of centralized communication platforms, BitChat offers a resilient alternative by operating without central servers. It is designed for scenarios where internet connectivity is unavailable or untrustworthy, such as protests, natural disasters, or remote areas. Communication occurs directly between devices over transports like Bluetooth Low Energy (BLE).
+* **Confidentiality:** all private communication is end-to-end encrypted; intermediate nodes and couriers carry only opaque ciphertext.
 * **Authentication:** peers are identified by cryptographic keys; announcements are signed and verified.
 * **Resilience:** the network functions in lossy, low-bandwidth, partitioned environments with churning membership.
 * **Eventual delivery:** a message to an out-of-range peer should still arrive — relayed by the mesh, carried by a moving person, or resting on an internet relay — within a bounded retention window.
 * **Ephemerality by default:** no plaintext message content is ever written to disk. Everything the store-and-forward stack persists is either sealed ciphertext or already-public broadcast traffic, and all of it dies with the panic wipe.
-The design goals of the BitChat Protocol are:
+## 2. Architecture Overview
-*   **Confidentiality:** All communication must be unreadable to third parties.
+Two transports implement a common `Transport` interface and are coordinated by a `MessageRouter`:
 *   **Authentication:** Users must be able to verify the identity of their correspondents.
 *   **Integrity:** Messages cannot be tampered with in transit.
 *   **Forward Secrecy:** The compromise of long-term identity keys must not compromise past session keys.
 *   **Deniability:** It should be difficult to cryptographically prove that a specific user sent a particular message.
 *   **Resilience:** The protocol must function reliably in lossy, low-bandwidth environments.
-This paper specifies the technical details of the protocol designed to meet these goals.
+* **BLE mesh** — every device is simultaneously a GATT central and peripheral, relaying packets in a controlled flood. No infrastructure, pairing, or accounts.
 * **Nostr** — private messages to mutual favorites travel as NIP-17 gift-wrapped events over public relays (over Tor where enabled), bridging separate meshes through the internet.
---
+The router prefers a live mesh link, falls back to Nostr, and engages the courier system when neither can deliver promptly.
-## 2. Protocol Stack
+## 3. Identity
-The BitChat Protocol is a four-layer stack. This layered approach separates concerns, allowing for modularity and future extensibility.
+Each device holds two long-term key pairs in the Keychain:
-```mermaid
+* a **Curve25519 static key** for Noise key agreement — its SHA-256 fingerprint is the peer's stable identity, and
-graph TD
+* an **Ed25519 signing key** for packet signatures.
    A[Application Layer] --> B[Session Layer];
    B --> C[Encryption Layer];
    C --> D[Transport Layer];
-    subgraph "BitChat Application"
+On the mesh, peers appear under short ephemeral IDs derived per session; favoriting pins the full Noise public key so identity survives across sessions. Mutual favorites also exchange Nostr public keys for the internet path. Optional QR verification binds a nickname to a fingerprint in person.
        A
    end
-    subgraph "Message Framing & State"
+## 4. BLE Mesh Layer
        B
    end
-    subgraph "Noise Protocol Framework"
+### 4.1 Packet Format
        C
    end
-    subgraph "BLE, Wi-Fi Direct, etc."
+A compact binary header (version, type, TTL, timestamp, flags) is followed by an 8-byte sender ID, an optional 8-byte recipient ID, the payload, and an optional Ed25519 signature. Version 2 packets may carry an explicit source route. Signatures exclude the TTL byte so relays can decrement it without invalidating them. Packets other than fragments are padded toward uniform sizes.
        D
    end
-    style A fill:#cde4ff
+### 4.2 Flood Control
    style B fill:#b5d8ff
    style C fill:#9ac2ff
    style D fill:#7eadff
 ```
-*   **Application Layer:** Defines the structure of user-facing messages (`BitchatMessage`), acknowledgments (`DeliveryAck`), and other application-level data.
+Relaying is a deterministic controlled flood tuned by local connection degree:
 *   **Session Layer:** Manages the overall communication packet (`BitchatPacket`). This includes routing information (TTL), message typing, fragmentation, and serialization into a compact binary format.
 *   **Encryption Layer:** Establishes and manages secure channels using the Noise Protocol Framework. It is responsible for the cryptographic handshake, session management, and transport message encryption/decryption.
 *   **Transport Layer:** The underlying physical medium used for data transmission, such as Bluetooth Low Energy (BLE). This layer is abstracted away from the core protocol.
---
+* **TTL:** packets originate with TTL 7. Relays clamp: dense graphs (≥ 6 links) cap broadcast TTL at 5; thin chains (≤ 2 links) relay at full incoming depth.
 * **Deduplication:** an LRU seen-set (1000 entries, 5-minute expiry) keyed by sender, timestamp, type, and a payload digest drops duplicates. A scheduled relay is cancelled when a duplicate arrives first from another relay.
 * **Jitter:** relays wait a random 10–220 ms (wider when dense) so duplicate suppression wins often.
 * **Fanout subsetting:** broadcast messages are re-sent to a deterministic, message-ID-seeded subset of links (~log₂ of degree) rather than all of them; announces, fragments, and sync packets use full fanout. The ingress link is always excluded (split horizon).
 * **Directed traffic** (handshakes, private messages, courier envelopes) relays deterministically with TTL − 1 and tight jitter, and is never subset.
-## 3. Identity and Key Management
+### 4.3 Routing
-A peer's identity in BitChat is defined by two persistent cryptographic key pairs, which are generated on first launch and stored securely in the device's Keychain.
+Announcements carry up to 10 direct-neighbor IDs, giving each node a shallow topology map (60 s freshness). When a bidirectionally-confirmed path exists, packets are source-routed along it; otherwise — and whenever a route fails — delivery falls back to flooding.
-1.  **Noise Static Key Pair (`Curve25519`):** This is the long-term identity key used for the Noise Protocol handshake. The public part of this key is shared with peers to establish secure sessions.
+### 4.4 Fragmentation
 2.  **Signing Key Pair (`Ed25519`):** This key is used to sign announcements and other protocol messages where non-repudiation is required, such as binding a public key to a nickname.
-### 3.1. Fingerprint
+Packets exceeding the link MTU split into ~469-byte fragments (8-byte fragment ID, index/total header) that relay independently and reassemble at each receiving node (128 concurrent assemblies, 30 s timeout, 1 MiB cap).
-A user's unique, verifiable fingerprint is the **SHA-256 hash** of their **Noise static public key**. This provides a user-friendly and secure way to verify an identity out-of-band (e.g., by reading it aloud or scanning a QR code).
+### 4.5 Presence
-`Fingerprint = SHA256(StaticPublicKey_Curve25519)`
+Signed announcements propagate multi-hop: every 4 s while isolated, backing off to ~15–30 s (jittered) when connected. A verified announce retains a peer as *reachable* for 60 s after last contact. Connection scheduling is RSSI-gated with duty-cycled scanning to bound battery drain.
-### 3.2. Identity Management
+## 5. Encryption
-The `SecureIdentityStateManager` class is responsible for managing all cryptographic identity material and social metadata (petnames, trust levels, etc.). It uses an in-memory cache for performance and persists this cache to the Keychain after encrypting it with a separate AES-GCM key.
+### 5.1 Live Sessions: Noise XX
---
+Connected peers establish sessions with the Noise `XX` pattern (Curve25519 / ChaCha20-Poly1305 / SHA-256), providing mutual authentication and forward secrecy. All private payloads — messages, delivery acks, read receipts — ride inside the session as typed ciphertext. Intermediate relays see only opaque `noiseEncrypted` packets.
-## 4. The Social Trust Layer
+### 5.2 Offline Seals: Noise X
-Beyond cryptographic identity, BitChat incorporates a social trust layer, allowing users to manage their relationships with peers. This functionality is handled by the `SecureIdentityStateManager`.
+Courier envelopes are sealed to the recipient's *static* key with the one-way Noise `X` pattern; the sender's identity is authenticated inside the ciphertext. **This path has no forward secrecy** — compromise of the recipient's static key exposes sealed-but-undelivered mail. A prekey scheme is future work.
-### 4.1. Peer Verification
+### 5.3 Nostr Path
-While the Noise handshake cryptographically authenticates a peer's key, it doesn't confirm the real-world identity of the person holding the device. To solve this, users can perform out-of-band (OOB) verification by comparing fingerprints. Once a user confirms that a peer's fingerprint matches the one they expect, they can mark that peer as "verified". This status is stored locally and displayed in the UI, providing a strong assurance of identity for future conversations.
+Private messages to mutual favorites are wrapped per NIP-17/NIP-59: a rumor (kind 14) sealed (kind 13) and gift-wrapped (kind 1059) under a throwaway ephemeral key, so relays learn neither sender nor content.
-### 4.2. Favorites and Blocking
+## 6. Store and Forward
-To improve the user experience and provide control over interactions, the protocol supports:
+Four mechanisms cover the "recipient is not here right now" problem. All persisted state is wiped by panic mode.
 *   **Favorites:** Users can mark trusted or frequently contacted peers as "favorites". This is a local designation that can be used by the application to prioritize notifications or display peers more prominently.
 *   **Blocking:** Users can block peers. When a peer is blocked, the application will discard any incoming packets from that peer's fingerprint at the earliest possible stage, effectively silencing them without notifying the blocked peer.
---
+### 6.1 Sender Outbox
-## 5. The Noise Protocol Layer
+Private messages without a prompt route are retained per peer (100 messages/peer, 24 h TTL) and re-sent on reconnect events until a delivery or read ack clears them, or a resend cap (8 attempts) drops them with visible failure. The outbox persists to disk sealed under a ChaChaPoly key held only in the Keychain, so queued mail survives an app kill without ever storing plaintext.
-BitChat implements the Noise Protocol Framework to provide strong, authenticated end-to-end encryption.
+### 6.2 Couriers
-### 5.1. Protocol Name
+When no transport can deliver promptly, the message is sealed (§5.2) into a **courier envelope** and handed to up to 3 connected peers who may physically encounter the recipient:
-The specific Noise protocol implemented is:
+* **Opaque addressing.** The only routing information is a 16-byte rotating recipient tag — an HMAC of the recipient's static key and the UTC day — computable solely by parties who already know that key. Couriers learn neither sender, recipient, nor content, and tags do not correlate across days.
 * **Trust tiers.** Mutual favorites may deposit 5 envelopes each; any peer with a signature-verified announce may deposit 2, into a bounded pool (20 of 40 slots) that can never crowd out favorites' mail. Envelopes are capped at 16 KiB and 24 h; overflow evicts oldest verified-tier mail first.
 * **Deposit retry.** Queued messages are re-deposited whenever a new eligible courier connects, until 3 distinct couriers carry the message or it expires.
 * **Spray and wait.** Envelopes carry a copy budget (initially 4, capped at 8). A courier meeting another eligible courier hands over half its remaining budget, so mail diffuses through a moving crowd instead of riding one person. Budgets, spray history, and carried mail persist across app restarts (iOS file protection).
 * **Handover.** On a verified *direct* announce from the recipient, matching envelopes are delivered over the live link and removed. On a verified *relayed* announce, a copy floods toward the recipient as a directed packet while the carried original stays put, throttled to one attempt per envelope per 10 minutes.
 * Receivers dedup by message ID, so redundant copies and the retained outbox original are harmless. Couriered mail from blocked senders is dropped at decryption time.
-**`Noise_XX_25519_ChaChaPoly_SHA256`**
+### 6.3 Public History (Gossip Sync)
-*   **`XX` Pattern:** This handshake pattern provides mutual authentication and forward secrecy. It does not require either party to know the other's static public key before the handshake begins. The keys are exchanged and authenticated during the three-part handshake. This is ideal for a decentralized P2P environment.
+Public broadcast messages are cached (1000 packets) and reconciled between peers every ~15 s using compact GCS filters: each side advertises what it holds, the other returns what is missing. Messages stay sync-able for **6 hours** and the cache persists to disk, so a device that walks between two partitions — or relaunches later — serves the room's recent history to whoever missed it. Fragments and file transfers keep a short 15-minute window.
 *   **`25519`:** The Diffie-Hellman function used is Curve25519.
 *   **`ChaChaPoly`:** The AEAD (Authenticated Encryption with Associated Data) cipher is ChaCha20-Poly1305.
 *   **`SHA256`:** The hash function used for all cryptographic hashing operations is SHA-256.
-### 5.2. The `XX` Handshake
+### 6.4 Nostr Mailboxes
-The `XX` handshake consists of three messages exchanged between an Initiator and a Responder to establish a shared secret and derive transport encryption keys.
+Gift-wrapped messages rest on Nostr relays; clients re-subscribe with a 24-hour lookback on reconnect, covering the both-devices-offline case for mutual favorites whenever either side touches the internet.
-```mermaid
+### 6.5 Delivery Metrics
 sequenceDiagram
    participant I as Initiator
    participant R as Responder
-    Note over I, R: Pre-computation: h = SHA256(protocol_name)
+Bare local counters (deposits, handovers, sprays, opens, outbox flushes and drops — no identities, message IDs, or timestamps) let delivery behavior be measured on-device. They never leave the device and are cleared by the panic wipe.
-    I->>R: -> e
+## 7. Application Layer
    Note right of I: I generates ephemeral key `e_i`.<br/>h = SHA256(h + e_i.pub)
-    R->>I: <- e, ee, s, es
+* **Public chat** — signed broadcast messages within the mesh, backed by the gossip-synced history above.
-    Note left of R: R generates ephemeral key `e_r`.<br/>h = SHA256(h + e_r.pub)<br/>MixKey(DH(e_i, e_r))<br/>R sends static key `s_r`, encrypted.<br/>h = SHA256(h + ciphertext)<br/>MixKey(DH(e_i, s_r))
+* **Private chat** — end-to-end encrypted messages with delivery and read receipts, over mesh, courier, or Nostr.
-
+* **Location channels** — geohash-scoped public rooms carried over Nostr relays for regional chat beyond radio range.
-    I->>R: -> s, se
+* **Favorites** — the mutual-trust relationship that unlocks Nostr delivery and the larger courier quota.
-    Note right of I: I decrypts and verifies `s_r`.<br/>I sends static key `s_i`, encrypted.<br/>h = SHA256(h + ciphertext)<br/>MixKey(DH(s_i, e_r))
+* **Media** — files and images fragment over the mesh (1 MiB cap, explicit accept before anything touches disk); couriers carry text only.
-
+* **Panic wipe** — clears identity keys, favorites, carried courier mail, the sealed outbox, archived public history, and metrics.
    Note over I, R: Handshake complete. Transport keys derived.
 ```
 **Handshake Flow:**
 1.  **Initiator -> Responder:** The initiator generates a new ephemeral key pair (`e_i`) and sends the public part to the responder.
 2.  **Responder -> Initiator:** The responder receives the initiator's ephemeral public key. It then generates its own ephemeral key pair (`e_r`), performs a DH exchange with the initiator's ephemeral key (`ee`), sends its own static public key (`s_r`) encrypted with the resulting symmetric key, and performs another DH exchange between the initiator's ephemeral key and its own static key (`es`).
 3.  **Initiator -> Responder:** The initiator receives the responder's message, decrypts the responder's static key, and authenticates it. The initiator then sends its own static key (`s_i`) encrypted and performs a final DH exchange between its static key and the responder's ephemeral key (`se`).
 Upon completion, both parties share a set of symmetric keys for bidirectional transport message encryption. The final handshake hash is used for channel binding.
 ### 5.3. Session Management
 The `NoiseSessionManager` class manages all active Noise sessions. It handles:
 *   Creating sessions for new peers.
 *   Coordinating the handshake process to prevent race conditions.
 *   Storing the resulting transport ciphers (`sendCipher`, `receiveCipher`).
 *   Periodically checking if sessions need to be re-keyed for enhanced security.
 ---
 ## 6. The BitChat Session and Application Protocol
 Once a Noise session is established, peers exchange `BitchatPacket` structures, which are encrypted as the payload of Noise transport messages.
 ### 6.1. Binary Packet Format (`BitchatPacket`)
 To minimize bandwidth, `BitchatPacket`s are serialized into a compact binary format. The structure is designed to be fixed-size where possible to resist traffic analysis.
 | Field           | Size (bytes) | Description                                                                                             |
 |-----------------|--------------|---------------------------------------------------------------------------------------------------------|
 | **Header**      | **13**       | **Fixed-size header**                                                                                   |
 | Version         | 1            | Protocol version (currently `1`).                                                                       |
 | Type            | 1            | Message type (e.g., `message`, `deliveryAck`, `noiseHandshakeInit`). See `MessageType` enum.            |
 | TTL             | 1            | Time-To-Live for mesh network routing. Decremented at each hop.                                         |
 | Timestamp       | 8            | `UInt64` millisecond timestamp of packet creation.                                                      |
 | Flags           | 1            | Bitmask for optional fields (`hasRecipient`, `hasSignature`, `isCompressed`).                           |
 | Payload Length  | 2            | `UInt16` length of the payload field.                                                                   |
 | **Variable**    | **...**      | **Variable-size fields**                                                                                |
 | Sender ID       | 8            | 8-byte truncated peer ID of the sender.                                                                 |
 | Recipient ID    | 8 (optional) | 8-byte truncated peer ID of the recipient. Present if `hasRecipient` flag is set. Broadcast if `0xFF..FF`. |
 | Payload         | Variable     | The actual content of the packet, as defined by the `Type` field.                                       |
 | Signature       | 64 (optional)| `Ed25519` signature of the packet. Present if `hasSignature` flag is set.                               |
 **Padding:** All packets are padded to the next standard block size (256, 512, 1024, or 2048 bytes) using a PKCS#7-style scheme to obscure the true message length from network observers.
 ```mermaid
 ---
 config:
  theme: dark
 ---
 ---
 title: "BitchatPacket"
 ---
 packet
 +8: "Version"
 +8: "Type"
 +8: "TTL"
 +64: "Timestamp"
 +8: "Flags"
 +16: "Payload Length"
 +64: "Sender ID"
 +64: "Recipient ID (optional)"
 +48: "Payload (variable)"
 +64: "Signature (optional)"
 ```
 _A representation of the sizes of the fields in `BitchatPacket`_
 ### 6.2. Application Message Format (`BitchatMessage`)
 For packets of type `message`, the payload is a binary-serialized `BitchatMessage` containing the chat content.
 | Field               | Size (bytes) | Description                                                              |
 |---------------------|--------------|--------------------------------------------------------------------------|
 | Flags               | 1            | Bitmask for optional fields (`isRelay`, `isPrivate`, `hasOriginalSender`). |
 | Timestamp           | 8            | `UInt64` millisecond timestamp of message creation.                      |
 | ID                  | 1 + len      | `UUID` string for the message.                                           |
 | Sender              | 1 + len      | Nickname of the sender.                                                  |
 | Content             | 2 + len      | The UTF-8 encoded message content.                                       |
 | Original Sender     | 1 + len (opt)| Nickname of the original sender if the message is a relay.               |
 | Recipient Nickname  | 1 + len (opt)| Nickname of the recipient for private messages.                          |
 ```mermaid
 ---
 config:
  theme: dark
 ---
 ---
 title: "BitchatMessage"
 ---
 packet
 +8: "Flags"
 +64: "Timestamp"
 +24: "ID (variable)"
 +32: "Sender (variable)"
 +32: "Content (variable)"
 +32: "Original Sender (variable) (optional)"
 +32: "Recipient Nickname (variable) (optional)"
 ```
 _A representation of the sizes of the fields in `BitchatMessage`_
 ---
 ## 7. Message Routing and Propagation
 BitChat operates as a decentralized mesh network, meaning there are no central servers to route messages. Packets are propagated through the network from peer to peer. The protocol supports several modes of message delivery.
 ### 7.1. Direct Connection
 This is the simplest case. If Peer A and Peer B are directly connected, they can exchange packets after establishing a mutually authenticated Noise session. All packets are encrypted using the transport ciphers derived from the handshake.
 ### 7.2. Efficient Gossip with Bloom Filters
 To send messages to peers that are not directly connected, BitChat employs a "flooding" or "gossip" protocol. When a peer receives a packet that is not destined for it, it acts as a relay. To prevent infinite routing loops and minimize memory usage, the protocol uses an `OptimizedBloomFilter` to track recently seen packet IDs.
 The logic is as follows:
 1.  A peer receives a packet.
 2.  It checks the Bloom filter to see if the packet's ID has likely been seen before. If so, the packet is discarded. Bloom filters can have false positives (though they are rare), but they guarantee no false negatives. This means that while some packets may be incorrectly discarded due to false positives, the gossip protocol's redundancy ensures these packets will eventually be received through subsequent exchanges with other peers.
 3.  If the packet is new, its ID is added to the Bloom filter.
 4.  The peer decrements the packet's Time-To-Live (TTL) field.
 5.  If the TTL is greater than zero, the peer re-broadcasts the packet to all of its connected peers, *except* for the peer from which it received the packet.
 This mechanism allows packets to "flood" through the network efficiently, maximizing the chance of reaching their destination while using minimal resources to prevent loops.
 ### 7.3. Time-To-Live (TTL)
 Every `BitchatPacket` contains an 8-bit TTL field. This value is set by the originating peer and is decremented by one at each relay hop. If a peer receives a packet and decrements its TTL to 0, it will process the packet (if it is the recipient) but will not relay it further. This is a crucial mechanism to prevent packets from circulating endlessly in the mesh.
 ### 7.4. Private vs. Broadcast Messages
 The routing logic respects the confidentiality of private messages:
 *   **Private Messages:** A packet with a specific `recipientID` is a private message. Relay nodes forward the entire, encrypted Noise message without being able to access the inner `BitchatPacket` or its payload. Only the final recipient, who shares the correct Noise session keys with the sender, can decrypt the packet.
 *   **Broadcast Messages:** A packet with the special broadcast `recipientID` (`0xFFFFFFFFFFFFFFFF`) is intended for all peers. Any peer that receives and decrypts a broadcast message will process its content. It will still be relayed according to the flooding algorithm to ensure it reaches the entire network.
 ### 7.5. Message Reliability and Lifecycle
 To function in unreliable, lossy networks, the protocol includes features to track the lifecycle of a message and ensure its delivery.
 *   **Delivery Acknowledgments (`DeliveryAck`):** When a private message reaches its final destination, the recipient's device sends a `DeliveryAck` packet back to the original sender. This acknowledgment contains the ID of the original message.
 *   **Read Receipts (`ReadReceipt`):** After a message is displayed on the recipient's screen, the application can send a `ReadReceipt`, also containing the original message ID, to inform the sender that the message has been seen.
 *   **Message Retry Service:** Senders maintain a `MessageRetryService` which tracks outgoing messages. If a `DeliveryAck` is not received for a message within a certain time window, the service will automatically re-send the message, creating a more resilient user experience.
 ### 7.6. Fragmentation
 Transport layers like BLE have a Maximum Transmission Unit (MTU) that limits the size of a single packet. To handle messages larger than this limit, BitChat implements a fragmentation protocol.
 *   **`fragmentStart`:** A packet with this type marks the beginning of a fragmented message. It contains metadata about the total size and number of fragments.
 *   **`fragmentContinue`:** These packets carry the intermediate chunks of the message data.
 *   **`fragmentEnd`:** This packet carries the final chunk of the message and signals the receiver to begin reassembly.
 Receiving peers collect all fragments and reassemble them in the correct order before passing the complete message up to the application layer.
 ---
 ## 8. Security Considerations
-*   **Replay Attacks:** The Noise transport messages include a nonce that is incremented for each message. The `NoiseCipherState` implements a sliding window replay protection mechanism to detect and discard replayed or out-of-order messages.
+* **Relay nodes** cannot read private traffic; they forward padded, opaque ciphertext.
-*   **Denial of Service:** The `NoiseRateLimiter` is implemented to prevent resource exhaustion from rapid, repeated handshake attempts from a single peer.
+* **Couriers** are quota-bounded mailbags. A malicious courier can drop mail (redundant copies and deposit retry mitigate this) but cannot read it, link it across days, or amplify it — copy budgets are capped and every envelope is validated against size and lifetime policy on deposit.
-*   **Key-Compromise Impersonation:** The `XX` pattern authenticates both parties, preventing an attacker from impersonating one party to the other.
+* **Flooding abuse** is bounded by TTL clamps, deduplication, per-depositor quotas, connect-rate limits, and announce-rate limiting.
-*   **Identity Binding:** While the Noise handshake authenticates the cryptographic keys, binding those keys to a human-readable nickname is handled at the application layer. Users must verify fingerprints out-of-band to prevent man-in-the-middle attacks.
+* **Replay** of public broadcasts is bounded by the 6-hour acceptance window plus deduplication; private payloads are protected by Noise nonces.
-*   **Traffic Analysis:** The use of fixed-size padding for all packets helps to obscure the exact nature and content of the communication, making it harder for a network-level adversary to infer information based on message size.
+* **Metadata.** BLE proximity is inherently observable; ephemeral IDs and daily-rotating courier tags limit long-term correlation. Nostr traffic can ride Tor.
 * **No forward secrecy for sealed mail** (§5.2) is the main cryptographic trade-off of the offline path.
 ## 9. Future Work
 * Prekey-based forward secrecy for courier envelopes.
 * Couriered media beyond the 16 KiB text cap.
 * Probabilistic relay and edge-of-network TTL boosting for very dense and very sparse graphs.
 * Multi-hop courier routing informed by encounter history.
 ---
-## 9. Conclusion
+*This document describes the protocol as implemented in the current release. The implementation is free and unencumbered software released into the public domain.*
 The BitChat Protocol provides a robust and secure foundation for decentralized, peer-to-peer communication. By layering a flexible application protocol on top of the well-regarded Noise Protocol Framework, it achieves strong confidentiality, authentication, and forward secrecy. The use of a compact binary format and thoughtful security considerations like rate limiting and traffic analysis resistance make it suitable for use in challenging network environments.
@@ -92,7 +92,8 @@
 		A6E32D232E762EAB0032EA8A /* Exceptions for "bitchatShareExtension" folder in "bitchatShareExtension" target */ = {
 			isa = PBXFileSystemSynchronizedBuildFileExceptionSet;
 			membershipExceptions = (
-				ShareViewController.swift,
+				Info.plist,
 				bitchatShareExtension.entitlements,
 			);
 			target = 57CA17A36A2532A6CFF367BB /* bitchatShareExtension */;
 		};
@@ -258,9 +259,13 @@
 			buildConfigurationList = E4EA6DC648DF55FF84032EB5 /* Build configuration list for PBXNativeTarget "bitchatShareExtension" */;
 			buildPhases = (
 				0A08E70F08F55FD5BA8C7EF3 /* Sources */,
 				7E9B64F63F93443FB7BA12DF /* Resources */,
 			);
 			buildRules = (
 			);
 			fileSystemSynchronizedGroups = (
 				A6E32D212E762EAB0032EA8A /* bitchatShareExtension */,
 			);
 			name = bitchatShareExtension;
 			productName = bitchatShareExtension;
 			productReference = 61F92EBA29C47C0FCC482F1F /* bitchatShareExtension.appex */;
@@ -388,6 +393,13 @@
 				E0A1B2C3D4E5F6012345678E /* relays/online_relays_gps.csv in Resources */,
 			);
 		};
 		7E9B64F63F93443FB7BA12DF /* Resources */ = {
 			isa = PBXResourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
 /* End PBXResourcesBuildPhase section */
 /* Begin PBXSourcesBuildPhase section */
@@ -528,7 +540,6 @@
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
 				MARKETING_VERSION = "$(MARKETING_VERSION)";
 				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER).ShareExtension";
 				SDKROOT = iphoneos;
 				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
@@ -561,7 +572,6 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
 				MARKETING_VERSION = 1.5.3;
 				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER)";
 				PRODUCT_NAME = bitchat;
 				SDKROOT = iphoneos;
@@ -620,7 +630,6 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
 				MARKETING_VERSION = 1.5.3;
 				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER)";
 				PRODUCT_NAME = bitchat;
 				SDKROOT = iphoneos;
@@ -655,7 +664,6 @@
 					"@executable_path/../Frameworks",
 				);
 				MACOSX_DEPLOYMENT_TARGET = "$(MACOSX_DEPLOYMENT_TARGET)";
 				MARKETING_VERSION = 1.5.3;
 				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER)";
 				PRODUCT_NAME = bitchat;
 				REGISTER_APP_GROUPS = YES;
@@ -716,7 +724,6 @@
 				GCC_WARN_UNUSED_VARIABLE = YES;
 				IPHONEOS_DEPLOYMENT_TARGET = "$(IPHONEOS_DEPLOYMENT_TARGET)";
 				MACOSX_DEPLOYMENT_TARGET = "$(MACOSX_DEPLOYMENT_TARGET)";
 				MARKETING_VERSION = "$(MARKETING_VERSION)";
 				MTL_ENABLE_DEBUG_INFO = NO;
 				MTL_FAST_MATH = YES;
 				PRODUCT_NAME = "$(TARGET_NAME)";
@@ -749,7 +756,6 @@
 					"@executable_path/../Frameworks",
 				);
 				MACOSX_DEPLOYMENT_TARGET = "$(MACOSX_DEPLOYMENT_TARGET)";
 				MARKETING_VERSION = 1.5.3;
 				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER)";
 				PRODUCT_NAME = bitchat;
 				REGISTER_APP_GROUPS = YES;
@@ -816,7 +822,6 @@
 				GCC_WARN_UNUSED_VARIABLE = YES;
 				IPHONEOS_DEPLOYMENT_TARGET = "$(IPHONEOS_DEPLOYMENT_TARGET)";
 				MACOSX_DEPLOYMENT_TARGET = "$(MACOSX_DEPLOYMENT_TARGET)";
 				MARKETING_VERSION = "$(MARKETING_VERSION)";
 				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
 				MTL_FAST_MATH = YES;
 				ONLY_ACTIVE_ARCH = YES;
@@ -846,7 +851,6 @@
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
 				MARKETING_VERSION = "$(MARKETING_VERSION)";
 				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER).ShareExtension";
 				SDKROOT = iphoneos;
 				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
@@ -36,34 +36,12 @@ enum AppEvent: Sendable, Equatable {
 actor AppEventStream {
    private var continuations: [UUID: AsyncStream<AppEvent>.Continuation] = [:]
    func stream() -> AsyncStream<AppEvent> {
        let id = UUID()
        return AsyncStream { continuation in
            continuations[id] = continuation
            continuation.onTermination = { [id] _ in
                Task {
                    await self.removeContinuation(id)
                }
            }
        }
    }
    func emit(_ event: AppEvent) {
        for continuation in continuations.values {
            continuation.yield(event)
        }
    }
    func finish() {
        for continuation in continuations.values {
            continuation.finish()
        }
        continuations.removeAll()
    }
    private func removeContinuation(_ id: UUID) {
        continuations.removeValue(forKey: id)
    }
 }
 /// Identity key for a direct conversation. Equality and hashing use the
@@ -10,6 +10,10 @@ final class AppChromeModel: ObservableObject {
    @Published var showingFingerprintFor: PeerID?
    @Published var isAppInfoPresented = false
    @Published var isLocationChannelsSheetPresented = false
    @Published var isNoticesSheetPresented = false
    /// When the sheet is opened for "notes left here" (empty mesh timeline),
    /// it should land on the geo tab instead of the channel-derived default.
    @Published var noticesSheetPrefersGeoTab = false
    @Published var showBluetoothAlert = false
    @Published var bluetoothAlertMessage = ""
    @Published var bluetoothState: CBManagerState = .unknown
@@ -18,6 +22,9 @@ final class AppChromeModel: ObservableObject {
    private let chatViewModel: ChatViewModel
    private var cancellables = Set<AnyCancellable>()
    /// 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) {
        self.chatViewModel = chatViewModel
        self.nickname = chatViewModel.nickname
@@ -59,6 +66,33 @@ final class AppChromeModel: ObservableObject {
        isAppInfoPresented = true
    }
    func presentNotices(geoTab: Bool = false) {
        noticesSheetPrefersGeoTab = geoTab
        isNoticesSheetPresented = true
    }
    /// Builds the mesh topology map model from the transport's gossiped
    /// graph plus the live nickname table. Unknown nodes (heard about via a
    /// neighbor claim but never announced to us) fall back to a short ID.
    func meshTopologyDisplayModel() -> MeshTopologyDisplayModel {
        let mesh = chatViewModel.meshService
        guard let snapshot = mesh.currentMeshTopology() else { return .empty }
        let nicknames = mesh.getPeerNicknames()
        let nodes = snapshot.nodes.map { peerID -> MeshTopologyDisplayModel.Node in
            let isSelf = peerID == snapshot.localPeerID
            let label: String
            if isSelf {
                label = chatViewModel.nickname
            } else {
                label = nicknames[peerID] ?? "\(peerID.id.prefix(8))…"
            }
            return MeshTopologyDisplayModel.Node(id: peerID.id, label: label, isSelf: isSelf)
        }
        let edges = snapshot.edges.map { ($0.a.id, $0.b.id) }
        return MeshTopologyDisplayModel(nodes: nodes, edges: edges)
    }
    func triggerScreenshotPrivacyWarning() {
        showScreenshotPrivacyWarning = true
    }
@@ -18,8 +18,6 @@ final class AppRuntime: ObservableObject {
    /// (docs/CONVERSATION-STORE-DESIGN.md). Owned here; the feature models
    /// and `ChatViewModel` observe and mutate it through its intent API.
    let conversations: ConversationStore
    let peerIdentityStore: PeerIdentityStore
    let locationPresenceStore: LocationPresenceStore
    let publicChatModel: PublicChatModel
    let privateInboxModel: PrivateInboxModel
    let privateConversationModel: PrivateConversationModel
@@ -28,6 +26,7 @@ final class AppRuntime: ObservableObject {
    let locationChannelsModel: LocationChannelsModel
    let peerListModel: PeerListModel
    let appChromeModel: AppChromeModel
    let boardAlertsModel: BoardAlertsModel
    private let idBridge: NostrIdentityBridge
    private var cancellables = Set<AnyCancellable>()
@@ -41,7 +40,7 @@ final class AppRuntime: ObservableObject {
    #endif
    init(
-        keychain: KeychainManagerProtocol = KeychainManager(),
+        keychain: KeychainManagerProtocol = KeychainManager.makeDefault(),
        idBridge: NostrIdentityBridge = NostrIdentityBridge()
    ) {
        self.idBridge = idBridge
@@ -50,8 +49,6 @@ final class AppRuntime: ObservableObject {
        let locationPresenceStore = LocationPresenceStore()
        let locationManager = LocationChannelManager.shared
        self.conversations = conversations
        self.peerIdentityStore = peerIdentityStore
        self.locationPresenceStore = locationPresenceStore
        self.chatViewModel = ChatViewModel(
            keychain: keychain,
            idBridge: idBridge,
@@ -91,6 +88,24 @@ final class AppRuntime: ObservableObject {
            chatViewModel: self.chatViewModel,
            privateInboxModel: self.privateInboxModel
        )
        let chatViewModel = self.chatViewModel
        self.boardAlertsModel = BoardAlertsModel(
            arrivals: BoardStore.shared.postArrivals.eraseToAnyPublisher(),
            wipes: BoardStore.shared.didWipe.eraseToAnyPublisher(),
            dependencies: BoardAlertsModel.Dependencies(
                isOwnPost: { post in
                    let key = chatViewModel.meshService.noiseSigningPublicKeyData()
                    return !key.isEmpty && key == post.authorSigningKey
                },
                emitSystemLine: { content, geohash in
                    if geohash.isEmpty {
                        chatViewModel.addMeshOnlySystemMessage(content)
                    } else {
                        chatViewModel.addGeohashSystemMessage(content, geohash: geohash)
                    }
                }
            )
        )
        GeoRelayDirectory.shared.prefetchIfNeeded()
        bindRuntimeObservers()
@@ -202,7 +217,16 @@ final class AppRuntime: ObservableObject {
        chatViewModel.applicationWillTerminate()
    }
-    func handleNotificationResponse(identifier: String, userInfo: [AnyHashable: Any]) {
+    func handleNotificationResponse(
        identifier: String,
        actionIdentifier: String = UNNotificationDefaultActionIdentifier,
        userInfo: [AnyHashable: Any]
    ) {
        if actionIdentifier == NotificationService.waveActionID {
            chatViewModel.sendMeshWave()
            return
        }
        if identifier.hasPrefix("private-"), let peerID = PeerID(str: userInfo["peerID"] as? String) {
            record(.notificationOpened(peerID: peerID))
            chatViewModel.startPrivateChat(with: peerID)
@@ -289,21 +313,29 @@ private extension AppRuntime {
    }
    func checkForSharedContent() {
-        guard let userDefaults = UserDefaults(suiteName: BitchatApp.groupID),
+        guard let userDefaults = UserDefaults(suiteName: BitchatApp.groupID) else { return }
-              let sharedContent = userDefaults.string(forKey: "sharedContent"),
+        let clearSharedContent = {
            userDefaults.removeObject(forKey: "sharedContent")
            userDefaults.removeObject(forKey: "sharedContentType")
            userDefaults.removeObject(forKey: "sharedContentDate")
        }
        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
-        userDefaults.removeObject(forKey: "sharedContent")
+        clearSharedContent()
        userDefaults.removeObject(forKey: "sharedContentType")
        userDefaults.removeObject(forKey: "sharedContentDate")
        switch contentKind {
        case .url:
@@ -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
+    /// Incrementally-maintained message-ID → logical-index map for O(1)
-    /// delivery-status lookup. Kept in sync on every mutation:
+    /// dedup and delivery-status lookup. Logical indexes are physical array
-    /// - tail append: single insert
+    /// indexes plus `indexOffset`; trimming from the head advances the offset
-    /// - out-of-order insert: suffix reindex from the insertion point
+    /// instead of rewriting every surviving dictionary entry. This matters
-    /// - trim: full rebuild — `removeFirst(k)` is already O(n), so the
+    /// after the 1337-message cap is reached, when every steady-state tail
-    ///   rebuild does not change the asymptotics, and trim only happens once
+    /// append evicts one old row.
-    ///   the cap (1337) is reached. Simple and correct beats the
+    ///
-    ///   offset-tracking alternative here.
+    /// 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)
        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 let logicalIndex = indexByMessageID[message.id] {
-                if index != position {
+                let expectedIndex = indexOffset + position
-                    violations.append("\(label): message \(message.id.prefix(8))… at \(position) indexed at \(index)")
+                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")
@@ -225,8 +234,25 @@ final class Conversation: ObservableObject, Identifiable {
        guard let current else { return false }
        if current == new { return true }
        // Never downgrade to a weaker delivery state. Ordering of certainty:
        // sending < sent < carried < delivered < read. A late `.sent` write
        // (e.g. the optimistic stamp after routing) must not clobber the
        // `.carried` the router already set when it handed a copy to a
        // courier/bridge, nor a `.delivered`/`.read` ack. A late asynchronous
        // failure is weaker than a confirmed recipient receipt too, so it may
        // not replace `.delivered`/`.read`. Same for the
        // `.sending` stamp a pre-handshake resend emits asynchronously: it
        // can land after the message already reached `.sent`, and "Sent" was
        // already truthful. (`.failed` → `.sending` stays allowed so a real
        // failure retry is visible.)
        switch (current, new) {
-        case (.read, .delivered), (.read, .sent):
+        case (.read, .delivered), (.read, .carried), (.read, .sent), (.read, .sending), (.read, .failed):
            return true
        case (.delivered, .carried), (.delivered, .sent), (.delivered, .sending), (.delivered, .failed):
            return true
        case (.carried, .sent), (.carried, .sending):
            return true
        case (.sent, .sending):
            return true
        default:
            return false
@@ -252,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 [] }
@@ -265,7 +298,7 @@ final class Conversation: ObservableObject, Identifiable {
            indexByMessageID.removeValue(forKey: id)
        }
        messages.removeFirst(overflow)
-        reindex(from: 0)
+        indexOffset += overflow
        return trimmedIDs
    }
 }
@@ -796,16 +829,6 @@ extension ConversationStore {
        return messageIDs
    }
    /// Removes every direct conversation (panic clear).
    func removeAllDirectConversations() {
        let directIDs = conversationIDs.filter { id in
            if case .direct = id { return true }
            return false
        }
        for id in directIDs {
            removeConversation(id)
        }
    }
 }
 // MARK: - Diagnostics support
@@ -837,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[0].id] = indexOffset + 1
-        indexByMessageID[messages[1].id] = 0
+        indexByMessageID[messages[1].id] = indexOffset
    }
    /// Drops a message's index entry entirely (count mismatch + missing).
@@ -852,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[0].id] = indexOffset
-        indexByMessageID[messages[messages.count - 1].id] = messages.count - 1
+        indexByMessageID[messages[messages.count - 1].id] = indexOffset + messages.count - 1
    }
 }
@@ -893,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
@@ -12,6 +12,9 @@ final class ConversationUIModel: ObservableObject {
    @Published private(set) var currentNickname: String
    @Published private(set) var isBatchingPublic = false
    @Published private(set) var canSendMediaInCurrentContext = true
    /// 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?
    private let chatViewModel: ChatViewModel
    private let privateConversationModel: PrivateConversationModel
@@ -49,6 +52,14 @@ final class ConversationUIModel: ObservableObject {
        chatViewModel.sendMessage(message)
    }
    /// Resends a failed private message through the normal send path,
    /// removing the failed original so the re-submission replaces it
    /// instead of stacking a duplicate under the red bubble.
    func resendFailedPrivateMessage(_ message: BitchatMessage) {
        chatViewModel.removePrivateMessage(withID: message.id)
        chatViewModel.sendMessage(message.content)
    }
    func clearCurrentConversation() {
        chatViewModel.sendMessage("/clear")
    }
@@ -67,11 +78,23 @@ final class ConversationUIModel: ObservableObject {
        if let peerID, peerID.isGeoChat,
           let full = chatViewModel.fullNostrHex(forSenderPeerID: peerID) {
            chatViewModel.blockGeohashUser(pubkeyHexLowercased: full, displayName: displayName)
        } else if let peerID, !peerID.isGeoDM, !peerID.isGeoChat {
            // Mesh: block the peer's stable Noise identity resolved from the
            // tapped peerID rather than re-resolving a display-name string.
            chatViewModel.blockMeshPeer(peerID: peerID, displayName: displayName)
        } else {
            chatViewModel.sendMessage("/block \(displayName)")
        }
    }
    /// Mesh counterpart of `block(peerID:displayName:)`. Resolves the unblock by
    /// the tapped peer's stable identity so the exact row is unblocked — this
    /// also works for offline peers, which the `/unblock <displayName>` command
    /// cannot resolve.
    func unblock(peerID: PeerID, displayName: String) {
        chatViewModel.unblockMeshPeer(peerID: peerID, displayName: displayName)
    }
    func updateAutocomplete(for text: String, cursorPosition: Int) {
        chatViewModel.updateAutocomplete(for: text, cursorPosition: cursorPosition)
    }
@@ -130,6 +153,17 @@ final class ConversationUIModel: ObservableObject {
        chatViewModel.sendVoiceNote(at: url)
    }
    /// Capture backend for the mic gesture: live PTT when the current DM
    /// peer can hear it now, classic voice note otherwise.
    func makeVoiceCaptureSession() -> VoiceCaptureSession {
        chatViewModel.makeVoiceCaptureSession()
    }
    /// Whether this message is a live voice burst still streaming in.
    func isLiveVoiceMessage(_ message: BitchatMessage) -> Bool {
        chatViewModel.liveVoiceCoordinator.isLiveVoiceMessage(message)
    }
    func cancelMediaSend(messageID: String) {
        chatViewModel.cancelMediaSend(messageID: messageID)
    }
@@ -155,6 +189,10 @@ final class ConversationUIModel: ObservableObject {
            .receive(on: DispatchQueue.main)
            .assign(to: &$isBatchingPublic)
        chatViewModel.$activePublicVoiceTalker
            .receive(on: DispatchQueue.main)
            .assign(to: &$activeLiveVoiceTalker)
        conversations.$activeChannel
            .receive(on: DispatchQueue.main)
            .sink { [weak self] channel in
@@ -173,7 +211,9 @@ final class ConversationUIModel: ObservableObject {
    private func refreshComputedState() {
        if let selectedPeerID = privateConversationModel.selectedPeerID {
-            canSendMediaInCurrentContext = !(selectedPeerID.isGeoDM || selectedPeerID.isGeoChat)
+            // Media transfer is not wired for groups in v1; keep it off so the
            // composer can't strand a media placeholder that never sends.
            canSendMediaInCurrentContext = !(selectedPeerID.isGeoDM || selectedPeerID.isGeoChat || selectedPeerID.isGroup)
            return
        }
@@ -1,4 +1,3 @@
 import BitFoundation
 import Combine
 import Foundation
@@ -12,20 +11,25 @@ final class LocationChannelsModel: ObservableObject {
    @Published private(set) var bookmarkNames: [String: String]
    @Published private(set) var locationNames: [GeohashChannelLevel: String]
    @Published private(set) var userTorEnabled: Bool
    @Published private(set) var gatewayEnabled: Bool
    private let manager: LocationChannelManager
    private let network: NetworkActivationService
-    private var cancellables = Set<AnyCancellable>()
+    private let gateway: GatewayService
    init(
        manager: LocationChannelManager? = nil,
-        network: NetworkActivationService? = nil
+        network: NetworkActivationService? = nil,
        gateway: GatewayService? = nil
    ) {
        let manager = manager ?? .shared
        let network = network ?? .shared
        let gateway = gateway ?? .shared
        self.manager = manager
        self.network = network
        self.gateway = gateway
        self.gatewayEnabled = gateway.isEnabled
        self.permissionState = manager.permissionState
        self.availableChannels = manager.availableChannels
        self.selectedChannel = manager.selectedChannel
@@ -160,6 +164,10 @@ final class LocationChannelsModel: ObservableObject {
        network.$userTorEnabled
            .receive(on: DispatchQueue.main)
            .assign(to: &$userTorEnabled)
        gateway.$isEnabled
            .receive(on: DispatchQueue.main)
            .assign(to: &$gatewayEnabled)
    }
    private func level(forLength length: Int) -> GeohashChannelLevel {
@@ -0,0 +1,138 @@
 //
 // NearbyNotesCounter.swift
 // bitchat
 //
 // Counts unexpired location notes left at the user's current building-level
 // geohash so the empty mesh timeline can say "📍 3 notes left here". Only
 // subscribes while a view holds it active, and only when location notes are
 // enabled and location permission is already granted (it never prompts).
 // This is free and unencumbered software released into the public domain.
 //
 import Combine
 import Foundation
@MainActor
 final class NearbyNotesCounter: ObservableObject {
    static let shared = NearbyNotesCounter()
    @Published private(set) var noteCount = 0
    /// Whether an explicit notes act (the empty-timeline "check for notes"
    /// tap, opening the notices sheet's geo tab, or a successful /drop) has
    /// unlocked the counter this session. Until then nothing subscribes:
    /// merely looking at the mesh timeline must not open a building-precision
    /// relay REQ that leaks location passively.
    @Published private(set) var revealed = false
    private var manager: LocationNotesManager?
    private var managerCancellable: AnyCancellable?
    private var channelsCancellable: AnyCancellable?
    private var permissionCancellable: AnyCancellable?
    private var settingCancellable: AnyCancellable?
    private var activeHolders = 0
    private let locationManager: LocationChannelManager
    private let managerFactory: @MainActor (String) -> LocationNotesManager
    private let releaseManager: @MainActor (LocationNotesManager?) -> Void
    init(
        locationManager: LocationChannelManager = .shared,
        managerFactory: @escaping @MainActor (String) -> LocationNotesManager = { LocationNotesPool.shared.acquire($0) },
        releaseManager: @escaping @MainActor (LocationNotesManager?) -> Void = { LocationNotesPool.shared.release($0) }
    ) {
        self.locationManager = locationManager
        self.managerFactory = managerFactory
        self.releaseManager = releaseManager
    }
    /// Whether the empty-timeline "check for notes" hint should render.
    /// The permission gate matters: `retarget()` never subscribes without
    /// location authorization, so offering the hint to an unauthorized
    /// install would be a silent dead-end — tap, `revealed` flips, the hint
    /// vanishes, and nothing else happens for the session. The hint never
    /// prompts; it simply stays hidden until permission exists. The caller
    /// passes its own observed permission state so the hint re-renders when
    /// authorization changes.
    func offersRevealHint(permissionState: LocationChannelManager.PermissionState) -> Bool {
        !revealed && LocationNotesSettings.enabled && permissionState == .authorized
    }
    /// Marks the one explicit act that lets the counter subscribe. Sticky for
    /// the rest of the session (the singleton's lifetime); `deactivate()`
    /// deliberately does not reset it.
    func reveal() {
        guard !revealed else { return }
        revealed = true
        retarget()
    }
    /// Begins (or keeps) the notes subscription for the current building
    /// geohash. Balanced by `deactivate()`; ref-counted so multiple views can
    /// hold it.
    func activate() {
        activeHolders += 1
        guard activeHolders == 1 else { return }
        channelsCancellable = locationManager.$availableChannels
            .receive(on: DispatchQueue.main)
            .sink { [weak self] _ in self?.retarget() }
        // CoreLocation can revoke authorization while the view remains
        // mounted. `availableChannels` deliberately retains its last value,
        // so permission must be an independent invalidation signal or the
        // building REQ survives on stale coordinates.
        permissionCancellable = locationManager.$permissionState
            .receive(on: DispatchQueue.main)
            .sink { [weak self] _ in self?.retarget() }
        // The app-info kill switch must take effect immediately, not on the
        // next location change or remount.
        settingCancellable = NotificationCenter.default
            .publisher(for: LocationNotesSettings.didChangeNotification)
            .receive(on: DispatchQueue.main)
            .sink { [weak self] _ in self?.retarget() }
        retarget()
    }
    func deactivate() {
        activeHolders = max(0, activeHolders - 1)
        guard activeHolders == 0 else { return }
        channelsCancellable = nil
        permissionCancellable = nil
        settingCancellable = nil
        managerCancellable = nil
        releaseManager(manager)
        manager = nil
        noteCount = 0
    }
    private func retarget() {
        guard activeHolders > 0,
              revealed,
              LocationNotesSettings.enabled,
              locationManager.permissionState == .authorized,
              let geohash = locationManager.availableChannels
                  .first(where: { $0.level == .building })?.geohash
        else {
            managerCancellable = nil
            releaseManager(manager)
            manager = nil
            noteCount = 0
            return
        }
        if let manager {
            guard manager.geohash != geohash.lowercased() else { return }
            // Pooled managers are shared; never retarget one in place —
            // release the old cell and acquire the new one.
            managerCancellable = nil
            releaseManager(manager)
            self.manager = nil
        }
        let fresh = managerFactory(geohash)
        manager = fresh
        managerCancellable = fresh.$notes
            .receive(on: DispatchQueue.main)
            .sink { [weak self] notes in
                let now = Date()
                self?.noteCount = notes.filter { $0.expiresAt.map { $0 > now } ?? true }.count
            }
    }
 }
@@ -25,10 +25,6 @@ final class PeerIdentityStore: ObservableObject {
        stablePeerIDsByShortID[peerID] = stablePeerID
    }
    func replaceStablePeerIDs(_ mappings: [PeerID: PeerID]) {
        stablePeerIDsByShortID = mappings
    }
    func fingerprint(for peerID: PeerID) -> String? {
        peerFingerprintsByPeerID[peerID]
    }
@@ -94,10 +90,6 @@ final class PeerIdentityStore: ObservableObject {
        invalidateEncryptionCache(for: peerID)
    }
    func replaceEncryptionStatuses(_ statuses: [PeerID: EncryptionStatus]) {
        encryptionStatuses = statuses
    }
    func setVerifiedFingerprints(_ fingerprints: Set<String>) {
        verifiedFingerprints = fingerprints
    }
@@ -14,6 +14,9 @@ struct MeshPeerRow: Identifiable, Equatable {
    let isMutualFavorite: Bool
    let encryptionStatus: EncryptionStatus
    let showsVerifiedBadgeWhenOffline: Bool
    /// Vouched-for by someone I verified, without an explicit verification of
    /// mine — rendered as the unfilled seal (verified gets the filled one).
    let showsVouchedBadge: Bool
    var id: String { peerID.id }
 }
@@ -26,11 +29,22 @@ struct GeohashPersonRow: Identifiable, Equatable {
    let isBlocked: Bool
 }
 struct GroupChatRow: Identifiable, Equatable {
    let peerID: PeerID
    let name: String
    let memberCount: Int
    let isCreator: Bool
    let hasUnread: Bool
    var id: String { peerID.id }
 }
@MainActor
 final class PeerListModel: ObservableObject {
    @Published private(set) var allPeers: [BitchatPeer] = []
    @Published private(set) var meshRows: [MeshPeerRow] = []
    @Published private(set) var geohashPeople: [GeohashPersonRow] = []
    @Published private(set) var groupRows: [GroupChatRow] = []
    @Published private(set) var reachableMeshPeerCount = 0
    @Published private(set) var connectedMeshPeerCount = 0
    @Published private(set) var visibleGeohashPeerCount = 0
@@ -129,6 +143,13 @@ final class PeerListModel: ObservableObject {
            }
            .store(in: &cancellables)
        chatViewModel.groupStore.$groups
            .receive(on: DispatchQueue.main)
            .sink { [weak self] _ in
                self?.refresh()
            }
            .store(in: &cancellables)
        peerIdentityStore.$encryptionStatuses
            .receive(on: DispatchQueue.main)
            .sink { [weak self] _ in
@@ -183,13 +204,12 @@ final class PeerListModel: ObservableObject {
        let myPeerID = chatViewModel.meshService.myPeerID
        let meshRows = allPeers.map { peer in
            let isMe = peer.peerID == myPeerID
-            let verifiedBadge: Bool
+            let fingerprint = isMe ? nil : chatViewModel.getFingerprint(for: peer.peerID)
-            if !isMe && !peer.isConnected,
+            let isVerifiedFingerprint = fingerprint.map { peerIdentityStore.isVerified($0) } ?? false
-               let fingerprint = chatViewModel.getFingerprint(for: peer.peerID) {
+            let verifiedBadge = !peer.isConnected && isVerifiedFingerprint
-                verifiedBadge = peerIdentityStore.isVerified(fingerprint)
+            // Vouched is subordinate to verified: never show both seals.
-            } else {
+            let vouchedBadge = !isVerifiedFingerprint
-                verifiedBadge = false
+                && (fingerprint.map { chatViewModel.isVouchedFingerprint($0) } ?? false)
            }
            return MeshPeerRow(
                peerID: peer.peerID,
@@ -202,7 +222,8 @@ final class PeerListModel: ObservableObject {
                isReachable: peer.isReachable,
                isMutualFavorite: peer.isMutualFavorite,
                encryptionStatus: chatViewModel.getEncryptionStatus(for: peer.peerID),
-                showsVerifiedBadgeWhenOffline: verifiedBadge
+                showsVerifiedBadgeWhenOffline: verifiedBadge,
                showsVouchedBadge: vouchedBadge
            )
        }
@@ -217,22 +238,40 @@ final class PeerListModel: ObservableObject {
        }
        let geohashPeople = buildGeohashPeople()
        let groupRows = buildGroupRows()
        self.meshRows = meshRows
        reachableMeshPeerCount = meshCounts.reachable
        connectedMeshPeerCount = meshCounts.connected
        self.geohashPeople = geohashPeople
        visibleGeohashPeerCount = geohashPeople.count
        self.groupRows = groupRows
        renderID = (
            meshRows.map {
                "\($0.id)-\($0.isConnected)-\($0.isReachable)-\($0.hasUnread)-\($0.isFavorite)-\($0.isBlocked)"
            } +
            geohashPeople.map {
                "geo:\($0.id)-\($0.isTeleported)-\($0.isBlocked)-\($0.displayName)"
            } +
            groupRows.map {
                "group:\($0.id)-\($0.name)-\($0.memberCount)-\($0.hasUnread)"
            }
        ).joined(separator: "|")
    }
    private func buildGroupRows() -> [GroupChatRow] {
        let myFingerprint = chatViewModel.meshService.noiseIdentityFingerprint()
        return chatViewModel.groupStore.groups.map { group in
            GroupChatRow(
                peerID: group.peerID,
                name: group.name,
                memberCount: group.members.count,
                isCreator: group.creatorFingerprint == myFingerprint,
                hasUnread: chatViewModel.hasUnreadMessages(for: group.peerID)
            )
        }
    }
    private func buildGeohashPeople() -> [GeohashPersonRow] {
        let myHex = currentGeohashIdentityHex()
        let teleportedSet = Set(locationPresenceStore.teleportedGeo.map { $0.lowercased() })
@@ -108,7 +108,13 @@ struct PrivateConversationHeaderState: Equatable {
    let encryptionStatus: EncryptionStatus?
    var supportsFavoriteToggle: Bool {
-        !conversationPeerID.isGeoDM
+        !conversationPeerID.isGeoDM && !conversationPeerID.isGroup
    }
    /// Group chats have no single peer identity behind the header: no
    /// fingerprint screen, no per-peer encryption badge.
    var isGroupConversation: Bool {
        conversationPeerID.isGroup
    }
 }
@@ -206,6 +212,13 @@ final class PrivateConversationModel: ObservableObject {
            }
            .store(in: &cancellables)
        chatViewModel.groupStore.$groups
            .receive(on: DispatchQueue.main)
            .sink { [weak self] _ in
                self?.refreshSelectedConversation()
            }
            .store(in: &cancellables)
        NotificationCenter.default.publisher(for: Notification.Name("peerStatusUpdated"))
            .receive(on: DispatchQueue.main)
            .sink { [weak self] _ in
@@ -229,10 +242,36 @@ final class PrivateConversationModel: ObservableObject {
    }
    private func makeHeaderState(for conversationPeerID: PeerID) -> PrivateConversationHeaderState {
        // Group chats: the "peer" is the whole crew. Name + member count in
        // the header; availability reads as mesh since group traffic floods
        // the local mesh, and the per-peer encryption badge does not apply.
        if conversationPeerID.isGroup {
            let displayName: String
            if let group = chatViewModel.groupStore.group(for: conversationPeerID) {
                displayName = "#\(group.name) (\(group.members.count))"
            } else {
                displayName = String(localized: "common.unknown", comment: "Fallback label for unknown peer")
            }
            return PrivateConversationHeaderState(
                conversationPeerID: conversationPeerID,
                headerPeerID: conversationPeerID,
                displayName: displayName,
                availability: .meshReachable,
                isFavorite: false,
                encryptionStatus: nil
            )
        }
        let headerPeerID = chatViewModel.getShortIDForNoiseKey(conversationPeerID)
        let peer = chatViewModel.getPeer(byID: headerPeerID)
        let displayName = resolveDisplayName(for: conversationPeerID, headerPeerID: headerPeerID, peer: peer)
-        let availability = resolveAvailability(for: headerPeerID, peer: peer)
+        // Geo DMs are always routed over Nostr (NIP-17); their nostr_ keys
        // never resolve to a reachable mesh peer, so resolveAvailability would
        // report .offline. Report .nostrAvailable so the header shows the
        // globe instead of a misleading "offline" tag.
        let availability = conversationPeerID.isGeoDM
            ? .nostrAvailable
            : resolveAvailability(for: headerPeerID, peer: peer)
        let encryptionStatus: EncryptionStatus? = conversationPeerID.isGeoDM
            ? nil
            : chatViewModel.getEncryptionStatus(for: headerPeerID)
@@ -3,12 +3,19 @@ import Combine
 import Foundation
 struct FingerprintPresentationState: Equatable {
    let statusPeerID: PeerID
    let peerNickname: String
    let encryptionStatus: EncryptionStatus
    let theirFingerprint: String?
    let myFingerprint: String
    let isVerified: Bool
    /// Number of currently-valid vouches from peers the user verified
    /// (0 when the peer is explicitly verified — the stronger badge wins).
    let voucherCount: Int
    /// Display names of the (verified) vouchers, where known.
    let voucherNames: [String]
    /// Vouched for by ≥1 peer the user verified (and not explicitly verified).
    var isVouched: Bool { voucherCount > 0 }
    var canToggleVerification: Bool {
        encryptionStatus == .noiseSecured || encryptionStatus == .noiseVerified
@@ -48,10 +55,6 @@ final class VerificationModel: ObservableObject {
        return VerificationService.shared.buildMyQRString(nickname: currentNickname, npub: npub) ?? ""
    }
    func beginQRVerification(with qr: VerificationService.VerificationQR) -> Bool {
        chatViewModel.beginQRVerification(with: qr)
    }
    func verifyScannedPayload(_ payload: String) -> VerificationScanOutcome {
        guard let qr = VerificationService.shared.verifyScannedQR(payload) else {
            return .invalid
@@ -82,14 +85,33 @@ final class VerificationModel: ObservableObject {
        let encryptionStatus = chatViewModel.getEncryptionStatus(for: statusPeerID)
        let theirFingerprint = chatViewModel.getFingerprint(for: statusPeerID)
        let peerNickname = resolveDisplayName(for: peerID, statusPeerID: statusPeerID)
        let isVerified = theirFingerprint.map { peerIdentityStore.isVerified($0) } ?? false
        // Vouch state is recomputed on read: only vouchers still in the
        // verified set count, so removing a verification silently retires the
        // vouches that peer gave.
        let vouchers: [VouchRecord]
        if !isVerified, let theirFingerprint {
            vouchers = chatViewModel.identityManager.validVouchers(for: theirFingerprint)
        } else {
            vouchers = []
        }
        let voucherNames = vouchers.compactMap { record -> String? in
            guard let social = chatViewModel.identityManager.getSocialIdentity(for: record.voucherFingerprint) else {
                return nil
            }
            if let petname = social.localPetname, !petname.isEmpty { return petname }
            return social.claimedNickname.isEmpty ? nil : social.claimedNickname
        }
        return FingerprintPresentationState(
            statusPeerID: statusPeerID,
            peerNickname: peerNickname,
            encryptionStatus: encryptionStatus,
            theirFingerprint: theirFingerprint,
            myFingerprint: chatViewModel.getMyFingerprint(),
-            isVerified: theirFingerprint.map { peerIdentityStore.isVerified($0) } ?? false
+            isVerified: isVerified,
            voucherCount: vouchers.count,
            voucherNames: voucherNames
        )
    }
@@ -122,6 +144,17 @@ final class VerificationModel: ObservableObject {
                self?.objectWillChange.send()
            }
            .store(in: &cancellables)
        // Vouch state changes (ChatVouchCoordinator.notifyPeerTrustChanged)
        // are signalled via this notification rather than a published
        // property, so an open fingerprint sheet refreshes its vouched badge
        // live when a vouch batch is accepted.
        NotificationCenter.default.publisher(for: Notification.Name("peerStatusUpdated"))
            .receive(on: DispatchQueue.main)
            .sink { [weak self] _ in
                self?.objectWillChange.send()
            }
            .store(in: &cancellables)
    }
    private func resolveDisplayName(for peerID: PeerID, statusPeerID: PeerID) -> String {
@@ -27,6 +27,66 @@
      "idiom" : "universal",
      "platform" : "ios",
      "size" : "1024x1024"
    },
    {
      "filename" : "mac_16x16.png",
      "idiom" : "mac",
      "scale" : "1x",
      "size" : "16x16"
    },
    {
      "filename" : "mac_16x16@2x.png",
      "idiom" : "mac",
      "scale" : "2x",
      "size" : "16x16"
    },
    {
      "filename" : "mac_32x32.png",
      "idiom" : "mac",
      "scale" : "1x",
      "size" : "32x32"
    },
    {
      "filename" : "mac_32x32@2x.png",
      "idiom" : "mac",
      "scale" : "2x",
      "size" : "32x32"
    },
    {
      "filename" : "mac_128x128.png",
      "idiom" : "mac",
      "scale" : "1x",
      "size" : "128x128"
    },
    {
      "filename" : "mac_128x128@2x.png",
      "idiom" : "mac",
      "scale" : "2x",
      "size" : "128x128"
    },
    {
      "filename" : "mac_256x256.png",
      "idiom" : "mac",
      "scale" : "1x",
      "size" : "256x256"
    },
    {
      "filename" : "mac_256x256@2x.png",
      "idiom" : "mac",
      "scale" : "2x",
      "size" : "256x256"
    },
    {
      "filename" : "mac_512x512.png",
      "idiom" : "mac",
      "scale" : "1x",
      "size" : "512x512"
    },
    {
      "filename" : "mac_512x512@2x.png",
      "idiom" : "mac",
      "scale" : "2x",
      "size" : "512x512"
    }
  ],
  "info" : {
@@ -40,6 +40,7 @@ struct BitchatApp: App {
                .environmentObject(runtime.locationChannelsModel)
                .environmentObject(runtime.peerListModel)
                .environmentObject(runtime.appChromeModel)
                .environmentObject(runtime.boardAlertsModel)
                .onAppear {
                    appDelegate.runtime = runtime
                    runtime.start()
@@ -71,7 +72,7 @@ struct BitchatApp: App {
 final class AppDelegate: NSObject, UIApplicationDelegate {
    weak var runtime: AppRuntime?
-    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
+    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil) -> Bool {
        true
    }
@@ -103,13 +104,21 @@ final class NotificationDelegate: NSObject, UNUserNotificationCenterDelegate {
    func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
        let identifier = response.notification.request.identifier
        let actionIdentifier = response.actionIdentifier
        let userInfo = response.notification.request.content.userInfo
        // Complete only after the response is handled: for a background
        // action (👋 wave) the system may suspend the app the moment the
        // completion handler runs, which would drop the queued send.
        Task { @MainActor in
-            self.runtime?.handleNotificationResponse(identifier: identifier, userInfo: userInfo)
+            self.runtime?.handleNotificationResponse(
-        }
+                identifier: identifier,
                actionIdentifier: actionIdentifier,
                userInfo: userInfo
            )
            completionHandler()
        }
    }
    func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
        let identifier = notification.request.identifier
@@ -0,0 +1,472 @@
 //
 // AudioSessionCoordinator.swift
 // bitchat
 //
 // This is free and unencumbered software released into the public domain.
 // For more information, see <https://unlicense.org>
 //
 import AVFoundation
 import BitLogger
 import Foundation
 /// The raw audio-session calls the coordinator makes, abstracted so the
 /// state machine is unit-testable with a mock (and compiles on the macOS
 /// test host, where `AVAudioSession` doesn't exist).
 ///
 /// Calls arrive on the coordinator's private serial queue — never the main
 /// thread. `setCategory`/`setActive` block on IPC to the audio server
 /// (observed >1 s under contention on device, tripping the system gesture
 /// gate), and Apple explicitly recommends activating the session off the
 /// main thread.
 protocol SessionApplying: Sendable {
    func setCategory(_ category: AudioSessionCoordinator.Category) throws
    func setActive(_ active: Bool, notifyOthersOnDeactivation: Bool) throws
 }
 /// Sole owner of `AVAudioSession` category/activation for voice features.
 ///
 /// Talk-over means capture (push-to-talk) and playback (inbound bursts,
 /// voice notes) can be live simultaneously; letting each engine configure
 /// the shared session directly made them stomp each other's category and
 /// route mid-flight (the AURemoteIO -10851 dead-input class). Instead every
 /// client acquires a `Token` and the coordinator:
 ///
 /// - reference-counts activation: `setActive(true)` only on the first
 ///   holder, `setActive(false, notifyOthersOnDeactivation:)` only when the
 ///   last one releases — no client can deactivate another's session;
 /// - keeps one escalating category: playback-only holders get `.playback`,
 ///   any capture holder escalates to `.playAndRecord`, and the category is
 ///   never downgraded while anyone still holds a token (capture ending must
 ///   not yank the route out from under live playback);
 /// - fans out `onInterrupted` on system interruptions and when the active
 ///   route's device disappears (no auto-resume: bursts are transient, the
 ///   next press or burst simply re-acquires). The escalating category change
 ///   fans out separately as `onCategoryEscalated` — the session stays live,
 ///   so holders that can rebuild their engine against the new configuration
 ///   keep playing (talk-over is bidirectional); holders that don't provide
 ///   it fall back to `onInterrupted`.
 ///
 /// Threading: all state lives on a private serial queue, which both
 /// serializes rapid acquire/release pairs and keeps the blocking session IPC
 /// off the main thread (`acquire` is `async` for exactly that hop; `release`
 /// is fire-and-forget onto the queue). Holder callbacks always run on the
 /// main actor.
 ///
 /// Microphone *permission* queries stay with their callers; this type owns
 /// only category and activation.
 ///
 /// `@unchecked Sendable`: every mutable property is confined to `queue`.
 final class AudioSessionCoordinator: @unchecked Sendable {
    enum Use {
        case playback
        case capture
    }
    /// The session category the coordinator has applied (the `SessionApplying`
    /// adapter maps these to concrete `AVAudioSession` category/mode/options).
    enum Category {
        case playback
        case playAndRecord
    }
    /// Opaque handle for one client's hold on the session. Release exactly
    /// once when done (extra releases are ignored).
    ///
    /// `@unchecked` because the stored callbacks are `@MainActor`-isolated
    /// closures (non-Sendable as stored types). Lifecycle state is protected
    /// by `stateLock`, and callbacks are only ever invoked on the main actor.
    final class Token: @unchecked Sendable {
        fileprivate enum CallbackKind: Sendable {
            case interrupted
            case categoryEscalated
        }
        /// A callback snapshot is only valid for the lifecycle epoch in which
        /// it was captured. `release` advances the epoch synchronously before
        /// its queue work, so a callback already headed to the main actor can't
        /// reach a client that has since released this token and reacquired a
        /// different one.
        fileprivate struct CallbackTicket: Sendable {
            let token: Token
            let kind: CallbackKind
            let lifecycleEpoch: UInt64
        }
        private enum Lifecycle {
            /// Registered on the session queue, but `acquire` has not yet
            /// returned into the client's main-actor call frame.
            case acquiring
            case ready
            case released
        }
        fileprivate let onInterrupted: @MainActor () -> Void
        fileprivate let onCategoryEscalated: (@MainActor () -> Void)?
        private let stateLock = NSLock()
        private var lifecycle = Lifecycle.acquiring
        private var lifecycleEpoch: UInt64 = 0
        /// A terminal event that lands while the token is registered but not
        /// yet handed off invalidates the acquire before its caller can start.
        private var terminalEventPendingHandoff = false
        fileprivate init(
            onInterrupted: @escaping @MainActor () -> Void,
            onCategoryEscalated: (@MainActor () -> Void)?
        ) {
            self.onInterrupted = onInterrupted
            self.onCategoryEscalated = onCategoryEscalated
        }
        /// Records an event at the same linearization point at which the
        /// coordinator snapshots its holders. An acquiring token cannot safely
        /// receive a callback yet: terminal events invalidate the acquire,
        /// while category escalation needs no callback because its engine will
        /// start against the already-escalated configuration.
        fileprivate func record(_ kind: CallbackKind) -> CallbackTicket? {
            stateLock.withLock {
                switch lifecycle {
                case .acquiring:
                    switch kind {
                    case .interrupted:
                        terminalEventPendingHandoff = true
                    case .categoryEscalated:
                        break
                    }
                    return nil
                case .ready:
                    return CallbackTicket(token: self, kind: kind, lifecycleEpoch: lifecycleEpoch)
                case .released:
                    return nil
                }
            }
        }
        /// Completes the main-actor ownership handoff if no terminal event
        /// invalidated it. Because `acquire` itself is main-actor isolated, a
        /// successful handoff returns directly into the caller without another
        /// actor hop; no callback can interleave before the caller stores the
        /// returned token.
        fileprivate func completeHandoff() -> Bool {
            stateLock.withLock {
                guard lifecycle == .acquiring,
                      !terminalEventPendingHandoff
                else { return false }
                lifecycle = .ready
                return true
            }
        }
        /// Marks the token dead synchronously, before the asynchronous holder
        /// removal. Returns false for an already-released token.
        fileprivate func markReleased() -> Bool {
            stateLock.withLock {
                guard lifecycle != .released else { return false }
                lifecycle = .released
                lifecycleEpoch &+= 1
                terminalEventPendingHandoff = false
                return true
            }
        }
        /// Revalidates a queue snapshot at the main-actor delivery boundary.
        /// The lock is deliberately released before invoking client code: real
        /// callbacks commonly call `release` on this same token.
        @MainActor
        fileprivate func deliver(_ ticket: CallbackTicket) {
            let isLive = stateLock.withLock {
                lifecycle == .ready && lifecycleEpoch == ticket.lifecycleEpoch
            }
            guard isLive else { return }
            switch ticket.kind {
            case .interrupted:
                onInterrupted()
            case .categoryEscalated:
                (onCategoryEscalated ?? onInterrupted)()
            }
        }
    }
    /// Deterministic suspension points for lifecycle race tests. Production
    /// instances use the nil defaults; the hooks never move session calls off
    /// the coordinator queue or callback execution off the main actor.
    struct TestingHooks: Sendable {
        let beforeAcquireHandoff: (@Sendable () async -> Void)?
        let beforeCallbackDelivery: (@Sendable () async -> Void)?
        init(
            beforeAcquireHandoff: (@Sendable () async -> Void)? = nil,
            beforeCallbackDelivery: (@Sendable () async -> Void)? = nil
        ) {
            self.beforeAcquireHandoff = beforeAcquireHandoff
            self.beforeCallbackDelivery = beforeCallbackDelivery
        }
    }
    static let shared = AudioSessionCoordinator(session: SystemAudioSession())
    private let session: SessionApplying
    private let testingHooks: TestingHooks
    /// Confines all mutable state, serializes whole acquire/release
    /// operations (two rapid presses can't interleave their category and
    /// activation calls), and hosts the blocking session IPC off main.
    private let queue = DispatchQueue(label: "chat.bitchat.audio-session", qos: .userInitiated)
    // Queue-confined state.
    private var holders: [ObjectIdentifier: Token] = [:]
    private var currentCategory: Category?
    private var sessionActive = false
    /// Written once in init, read in deinit — never touched concurrently.
    private var observers: [NSObjectProtocol] = []
    init(session: SessionApplying, testingHooks: TestingHooks = TestingHooks()) {
        self.session = session
        self.testingHooks = testingHooks
        observeSystemNotifications()
    }
    deinit {
        for observer in observers {
            NotificationCenter.default.removeObserver(observer)
        }
    }
    /// Configures + activates the session for `use` and registers the caller
    /// as a holder. The blocking `AVAudioSession` calls run on the session
    /// queue — the caller suspends instead of stalling its thread (a PTT
    /// press used to block main >1 s in `setActive`, tripping the system
    /// gesture gate). `onInterrupted` fires (on the main actor) when the
    /// client must stop using the session: a system interruption began or
    /// its route's device went away. The client should stop its engine,
    /// finalize any artifacts, and release — resuming means acquiring again.
    ///
    /// `onCategoryEscalated` fires instead when the session category
    /// escalated underneath the holder (a capture client joined): the session
    /// stays active, so a holder that can rebuild its engine against the new
    /// configuration should restart and keep going. Holders that pass `nil`
    /// get `onInterrupted` for escalation too. Escalation is delivered before
    /// `acquire` returns, so the new holder starts its engine strictly after
    /// existing ones were told to rebuild. Main-actor isolation is also the
    /// ownership handoff boundary: if interruption or route loss lands after
    /// queue registration but before that boundary, the provisional holder is
    /// removed and `acquire` throws `CancellationError` instead of returning a
    /// token whose callback already fired.
    @MainActor
    func acquire(
        _ use: Use,
        onInterrupted: @escaping @MainActor () -> Void,
        onCategoryEscalated: (@MainActor () -> Void)? = nil
    ) async throws -> Token {
        let token = Token(onInterrupted: onInterrupted, onCategoryEscalated: onCategoryEscalated)
        let reconfigured: [Token.CallbackTicket] = try await withCheckedThrowingContinuation { continuation in
            queue.async {
                do {
                    continuation.resume(returning: try self.activateOnQueue(use, registering: token))
                } catch {
                    continuation.resume(throwing: error)
                }
            }
        }
        // Escalating playback -> playAndRecord reconfigures the hardware
        // route; engines started against the old configuration must restart.
        if !reconfigured.isEmpty {
            SecureLogger.info("AudioSession: category escalated to playAndRecord with \(reconfigured.count) live holder(s)", category: .session)
            await deliver(reconfigured)
        }
        if let beforeAcquireHandoff = testingHooks.beforeAcquireHandoff {
            await beforeAcquireHandoff()
        }
        guard token.completeHandoff() else {
            // A call/Siri interruption or route loss landed after registration
            // but before ownership handoff. Remove the provisional holder and
            // fail instead of starting a client engine after the stop event.
            release(token)
            throw CancellationError()
        }
        return token
    }
    /// Drops one holder. Deactivates the session (notifying other apps) only
    /// when the last holder releases. Safe to call more than once, from any
    /// thread (including `deinit` paths): the work is fire-and-forget onto
    /// the session queue, so the blocking deactivation IPC never runs on the
    /// caller.
    func release(_ token: Token) {
        guard token.markReleased() else { return }
        queue.async {
            self.releaseOnQueue(token)
        }
    }
    // MARK: - Queue-confined core
    /// Returns callback tickets for pre-existing live holders whose engines
    /// must restart because this acquire escalated the category.
    private func activateOnQueue(_ use: Use, registering token: Token) throws -> [Token.CallbackTicket] {
        let target: Category = (use == .capture || currentCategory == .playAndRecord) ? .playAndRecord : .playback
        let categoryChanged = target != currentCategory
        let previousCategory = currentCategory
        if categoryChanged {
            try session.setCategory(target)
            currentCategory = target
        }
        if !sessionActive {
            do {
                try session.setActive(true, notifyOthersOnDeactivation: false)
            } catch {
                // Activation failed (e.g. a phone call owns the hardware):
                // with no holder registered, an escalated category recorded
                // here would stick and pin later playback-only acquires to
                // .playAndRecord. Existing holders keep the category the
                // hardware really has.
                if categoryChanged, holders.isEmpty {
                    currentCategory = previousCategory
                }
                throw error
            }
            sessionActive = true
        }
        let reconfigured = categoryChanged
            ? holders.values.compactMap { $0.record(.categoryEscalated) }
            : []
        holders[ObjectIdentifier(token)] = token
        return reconfigured
    }
    private func releaseOnQueue(_ token: Token) {
        guard holders.removeValue(forKey: ObjectIdentifier(token)) != nil else { return }
        guard holders.isEmpty else { return }
        currentCategory = nil
        guard sessionActive else { return }
        sessionActive = false
        do {
            try session.setActive(false, notifyOthersOnDeactivation: true)
        } catch {
            SecureLogger.error("AudioSession: deactivation failed: \(error)", category: .session)
        }
    }
    private func onQueue<T: Sendable>(_ body: @escaping @Sendable () -> T) async -> T {
        await withCheckedContinuation { continuation in
            queue.async {
                continuation.resume(returning: body())
            }
        }
    }
    @MainActor
    private func deliver(_ tickets: [Token.CallbackTicket]) async {
        guard !tickets.isEmpty else { return }
        if let beforeCallbackDelivery = testingHooks.beforeCallbackDelivery {
            await beforeCallbackDelivery()
        }
        for ticket in tickets {
            ticket.token.deliver(ticket)
        }
    }
    // MARK: - System events (internal so tests can drive them directly)
    /// A system interruption began: the session is already deactivated by the
    /// OS, so just mark it inactive and tell every ready holder (on the main
    /// actor) to stop. A provisional acquiring holder is invalidated instead.
    /// No auto-resume — the next acquire re-activates.
    func handleInterruptionBegan() async {
        let tickets = await onQueue { () -> [Token.CallbackTicket] in
            self.sessionActive = false
            return self.holders.values.compactMap { $0.record(.interrupted) }
        }
        await deliver(tickets)
    }
    /// The active route's input/output device disappeared (e.g. BT headset
    /// off): ready holders' engines are wedged against a dead route — stop
    /// them; invalidate a holder whose acquire has not returned yet.
    func handleRouteDeviceUnavailable() async {
        let tickets = await onQueue {
            self.holders.values.compactMap { $0.record(.interrupted) }
        }
        await deliver(tickets)
    }
    /// Test hook: suspends until every session operation enqueued before this
    /// call — including fire-and-forget `release`s — has completed.
    func drain() async {
        await onQueue {}
    }
    private func observeSystemNotifications() {
        #if os(iOS)
        let center = NotificationCenter.default
        observers.append(center.addObserver(
            forName: AVAudioSession.interruptionNotification,
            object: AVAudioSession.sharedInstance(),
            queue: .main
        ) { [weak self] note in
            guard let raw = note.userInfo?[AVAudioSessionInterruptionTypeKey] as? UInt,
                  AVAudioSession.InterruptionType(rawValue: raw) == .began,
                  let self
            else { return }
            SecureLogger.info("AudioSession: interruption began", category: .session)
            Task { await self.handleInterruptionBegan() }
        })
        observers.append(center.addObserver(
            forName: AVAudioSession.routeChangeNotification,
            object: AVAudioSession.sharedInstance(),
            queue: .main
        ) { [weak self] note in
            guard let raw = note.userInfo?[AVAudioSessionRouteChangeReasonKey] as? UInt,
                  AVAudioSession.RouteChangeReason(rawValue: raw) == .oldDeviceUnavailable,
                  let self
            else { return }
            SecureLogger.info("AudioSession: route device became unavailable", category: .session)
            Task { await self.handleRouteDeviceUnavailable() }
        })
        #endif
    }
 }
 // MARK: - Production adapter
 #if os(iOS)
 private struct SystemAudioSession: SessionApplying {
    func setCategory(_ category: AudioSessionCoordinator.Category) throws {
        let session = AVAudioSession.sharedInstance()
        switch category {
        case .playback:
            try session.setCategory(.playback, mode: .spokenAudio, options: [.mixWithOthers])
        case .playAndRecord:
            // allowBluetoothHFP is not available on iOS Simulator
            #if targetEnvironment(simulator)
            try session.setCategory(
                .playAndRecord,
                mode: .default,
                options: [.defaultToSpeaker, .allowBluetoothA2DP, .mixWithOthers]
            )
            #else
            try session.setCategory(
                .playAndRecord,
                mode: .default,
                options: [.defaultToSpeaker, .allowBluetoothA2DP, .allowBluetoothHFP, .mixWithOthers]
            )
            #endif
        }
    }
    func setActive(_ active: Bool, notifyOthersOnDeactivation: Bool) throws {
        try AVAudioSession.sharedInstance().setActive(
            active,
            options: notifyOthersOnDeactivation ? [.notifyOthersOnDeactivation] : []
        )
    }
 }
 #else
 /// macOS has no app-level audio session; the coordinator still runs its
 /// bookkeeping so client code is identical across platforms.
 private struct SystemAudioSession: SessionApplying {
    func setCategory(_ category: AudioSessionCoordinator.Category) throws {}
    func setActive(_ active: Bool, notifyOthersOnDeactivation: Bool) throws {}
 }
 #endif
@@ -0,0 +1,175 @@
 //
 // PTTAudioCodec.swift
 // bitchat
 //
 // This is free and unencumbered software released into the public domain.
 // For more information, see <https://unlicense.org>
 //
 import AVFoundation
 import BitLogger
 import Foundation
 /// Streaming PCM -> AAC-LC encoder for live voice. Stateful (the AAC encoder
 /// carries a bit reservoir across frames); one instance per burst.
 /// Not thread-safe — confine to one queue.
 final class PTTFrameEncoder {
    private let converter: AVAudioConverter
    private var pendingInput: [AVAudioPCMBuffer] = []
    init?() {
        guard let pcm = PTTAudioFormat.pcmFormat,
              let aac = PTTAudioFormat.aacFormat,
              let converter = AVAudioConverter(from: pcm, to: aac)
        else { return nil }
        converter.bitRate = PTTAudioFormat.bitRate
        self.converter = converter
    }
    /// Feeds PCM (16 kHz mono float) and returns every complete AAC frame the
    /// encoder produced. Frames come out ~130 bytes each at 16 kbps.
    func encode(_ buffer: AVAudioPCMBuffer) -> [Data] {
        pendingInput.append(buffer)
        return drainConverter()
    }
    private func drainConverter() -> [Data] {
        var frames: [Data] = []
        while true {
            let output = AVAudioCompressedBuffer(
                format: converter.outputFormat,
                packetCapacity: 8,
                maximumPacketSize: max(converter.maximumOutputPacketSize, 1)
            )
            var error: NSError?
            let status = converter.convert(to: output, error: &error) { [weak self] _, outStatus in
                guard let self, let next = self.pendingInput.first else {
                    outStatus.pointee = .noDataNow
                    return nil
                }
                self.pendingInput.removeFirst()
                outStatus.pointee = .haveData
                return next
            }
            if status == .error {
                SecureLogger.error("PTT encode failed: \(error?.localizedDescription ?? "unknown")", category: .session)
                return frames
            }
            frames.append(contentsOf: Self.extractPackets(from: output))
            // .haveData means the output buffer filled and more may be ready;
            // anything else means the converter wants more input.
            if status != .haveData { return frames }
        }
    }
    private static func extractPackets(from buffer: AVAudioCompressedBuffer) -> [Data] {
        guard buffer.packetCount > 0, let descriptions = buffer.packetDescriptions else { return [] }
        var frames: [Data] = []
        frames.reserveCapacity(Int(buffer.packetCount))
        for index in 0..<Int(buffer.packetCount) {
            let description = descriptions[index]
            guard description.mDataByteSize > 0 else { continue }
            let start = buffer.data.advanced(by: Int(description.mStartOffset))
            frames.append(Data(bytes: start, count: Int(description.mDataByteSize)))
        }
        return frames
    }
 }
 /// Streaming AAC-LC -> PCM decoder for live voice. Stateful; one instance per
 /// inbound burst. Not thread-safe — confine to one queue/actor.
 final class PTTFrameDecoder {
    private let converter: AVAudioConverter
    private let pcmFormat: AVAudioFormat
    private let aacFormat: AVAudioFormat
    init?() {
        guard let pcm = PTTAudioFormat.pcmFormat,
              let aac = PTTAudioFormat.aacFormat,
              let converter = AVAudioConverter(from: aac, to: pcm)
        else { return nil }
        self.converter = converter
        self.pcmFormat = pcm
        self.aacFormat = aac
    }
    /// Decodes one raw AAC frame to PCM. Returns nil for malformed input or
    /// while the decoder is still priming (the first frame of a stream).
    func decode(_ frame: Data) -> AVAudioPCMBuffer? {
        guard !frame.isEmpty, frame.count <= 8 * 1024 else { return nil }
        let input = AVAudioCompressedBuffer(format: aacFormat, packetCapacity: 1, maximumPacketSize: frame.count)
        frame.withUnsafeBytes { raw in
            guard let base = raw.baseAddress else { return }
            input.data.copyMemory(from: base, byteCount: frame.count)
        }
        input.byteLength = UInt32(frame.count)
        input.packetCount = 1
        input.packetDescriptions?.pointee = AudioStreamPacketDescription(
            mStartOffset: 0,
            mVariableFramesInPacket: 0,
            mDataByteSize: UInt32(frame.count)
        )
        guard let output = AVAudioPCMBuffer(
            pcmFormat: pcmFormat,
            frameCapacity: PTTAudioFormat.samplesPerFrame * 2
        ) else { return nil }
        var consumed = false
        var error: NSError?
        let status = converter.convert(to: output, error: &error) { _, outStatus in
            if consumed {
                outStatus.pointee = .noDataNow
                return nil
            }
            consumed = true
            outStatus.pointee = .haveData
            return input
        }
        guard status != .error else {
            SecureLogger.debug("PTT decode failed: \(error?.localizedDescription ?? "unknown")", category: .session)
            return nil
        }
        return output.frameLength > 0 ? output : nil
    }
 }
 /// Sample-rate/channel converter from the microphone's native format to the
 /// 16 kHz mono processing format. Stateful; not thread-safe.
 final class PTTInputResampler {
    private let converter: AVAudioConverter
    private let outputFormat: AVAudioFormat
    private let ratio: Double
    init?(inputFormat: AVAudioFormat) {
        guard let pcm = PTTAudioFormat.pcmFormat,
              let converter = AVAudioConverter(from: inputFormat, to: pcm)
        else { return nil }
        self.converter = converter
        self.outputFormat = pcm
        self.ratio = PTTAudioFormat.sampleRate / inputFormat.sampleRate
    }
    func resample(_ buffer: AVAudioPCMBuffer) -> AVAudioPCMBuffer? {
        let capacity = AVAudioFrameCount(Double(buffer.frameLength) * ratio) + 64
        guard let output = AVAudioPCMBuffer(pcmFormat: outputFormat, frameCapacity: capacity) else { return nil }
        var consumed = false
        var error: NSError?
        let status = converter.convert(to: output, error: &error) { _, outStatus in
            if consumed {
                outStatus.pointee = .noDataNow
                return nil
            }
            consumed = true
            outStatus.pointee = .haveData
            return buffer
        }
        guard status != .error else {
            SecureLogger.debug("PTT resample failed: \(error?.localizedDescription ?? "unknown")", category: .session)
            return nil
        }
        return output.frameLength > 0 ? output : nil
    }
 }
@@ -0,0 +1,84 @@
 //
 // PTTAudioFormat.swift
 // bitchat
 //
 // This is free and unencumbered software released into the public domain.
 // For more information, see <https://unlicense.org>
 //
 import AVFoundation
 import Foundation
 /// Shared audio parameters for live push-to-talk: AAC-LC, 16 kHz, mono,
 /// ~16 kbps — deliberately identical to `VoiceRecorder`'s voice-note settings
 /// so a burst's finalized `.m4a` and its live frames sound the same.
 enum PTTAudioFormat {
    static let sampleRate: Double = 16_000
    static let channelCount: AVAudioChannelCount = 1
    static let bitRate = 16_000
    /// AAC-LC frame size is fixed by the codec: 1024 samples = 64 ms at 16 kHz.
    static let samplesPerFrame: AVAudioFrameCount = 1024
    static var frameDuration: TimeInterval { Double(samplesPerFrame) / sampleRate }
    /// Uncompressed processing format (deinterleaved float PCM).
    static var pcmFormat: AVAudioFormat? {
        AVAudioFormat(standardFormatWithSampleRate: sampleRate, channels: channelCount)
    }
    /// Compressed wire format.
    static var aacFormat: AVAudioFormat? {
        var description = AudioStreamBasicDescription(
            mSampleRate: sampleRate,
            mFormatID: kAudioFormatMPEG4AAC,
            mFormatFlags: 0,
            mBytesPerPacket: 0,
            mFramesPerPacket: samplesPerFrame,
            mBytesPerFrame: 0,
            mChannelsPerFrame: channelCount,
            mBitsPerChannel: 0,
            mReserved: 0
        )
        return AVAudioFormat(streamDescription: &description)
    }
    /// Voice-note container settings for the finalized `.m4a`, mirroring
    /// `VoiceRecorder.startRecording()`.
    static var voiceNoteFileSettings: [String: Any] {
        [
            AVFormatIDKey: kAudioFormatMPEG4AAC,
            AVSampleRateKey: sampleRate,
            AVNumberOfChannelsKey: Int(channelCount),
            AVEncoderBitRateKey: bitRate
        ]
    }
 }
 /// Builds ADTS-framed AAC so a receiver can persist a burst progressively:
 /// unlike `.m4a` (whose moov atom only exists after close), an ADTS `.aac`
 /// stream is playable at any prefix — a partially received burst is still a
 /// replayable voice note.
 enum ADTSFramer {
    private static let headerSize = 7
    /// MPEG-4 sampling frequency index for 16 kHz.
    private static let samplingFrequencyIndex: UInt8 = 8
    private static let channelConfiguration: UInt8 = 1
    /// Wraps one raw AAC-LC frame in an ADTS header.
    static func frame(_ aacFrame: Data) -> Data {
        let frameLength = aacFrame.count + headerSize
        var data = Data(capacity: frameLength)
        // Syncword 0xFFF, MPEG-4, layer 00, no CRC.
        data.append(0xFF)
        data.append(0xF1)
        // Profile AAC-LC (audio object type 2 -> bits 01), frequency index,
        // private bit 0, channel config high bit.
        data.append((0b01 << 6) | (samplingFrequencyIndex << 2) | ((channelConfiguration >> 2) & 0x1))
        data.append(((channelConfiguration & 0x3) << 6) | UInt8((frameLength >> 11) & 0x3))
        data.append(UInt8((frameLength >> 3) & 0xFF))
        data.append(UInt8((frameLength & 0x7) << 5) | 0x1F)
        // Buffer fullness 0x7FF (VBR), one AAC frame per ADTS frame.
        data.append(0xFC)
        data.append(aacFrame)
        return data
    }
 }
@@ -0,0 +1,509 @@
 //
 // PTTBurstPlayer.swift
 // bitchat
 //
 // This is free and unencumbered software released into the public domain.
 // For more information, see <https://unlicense.org>
 //
@preconcurrency import AVFoundation
 import BitLogger
 import Foundation
 /// The engine operations behind live-burst playback, abstracted so the
 /// player's lifecycle (jitter start, category-escalation restart, stop) is
 /// unit-testable without real audio hardware.
@MainActor
 protocol PTTPlaybackEngine: AnyObject {
    /// The object `AVAudioEngineConfigurationChange` notifications are posted
    /// for (nil for mocks — no observer is registered).
    var configChangeObject: AnyObject? { get }
    func start() throws
    func play()
    func stop()
    func schedule(
        _ buffer: AVAudioPCMBuffer,
        completionType: PTTPlaybackCompletionType,
        completionHandler: @escaping @Sendable (PTTPlaybackCompletionEvent) -> Void
    )
 }
 /// The lifecycle point requested from `AVAudioPlayerNode` for a scheduled
 /// buffer. `dataConsumed` only means the node no longer needs the bytes; it
 /// may arrive before the render pipeline has made the audio audible.
 enum PTTPlaybackCompletionType: Equatable, Sendable {
    case dataConsumed
    case dataPlayedBack
 }
 enum PTTPlaybackCompletionEvent: Equatable, Sendable {
    case dataConsumed
    case dataPlayedBack
    /// AVAudioPlayerNode invokes the requested callback when the node is
    /// stopped too. That is not audible completion and must remain replayable.
    case playbackStopped
 }
 /// One `AVAudioEngine` + `AVAudioPlayerNode` pair. Created fresh per (re)start:
 /// an engine instantiated against an earlier audio-session configuration keeps
 /// rendering to the stale route (same class of failure as the capture side's
 /// fresh-engine-per-press rule).
@MainActor
 private final class SystemPTTPlaybackEngine: PTTPlaybackEngine {
    private let engine = AVAudioEngine()
    private let node = AVAudioPlayerNode()
    init(format: AVAudioFormat) {
        engine.attach(node)
        engine.connect(node, to: engine.mainMixerNode, format: format)
    }
    var configChangeObject: AnyObject? { engine }
    func start() throws {
        engine.prepare()
        try engine.start()
    }
    func play() {
        node.play()
    }
    func stop() {
        node.stop()
        engine.stop()
    }
    func schedule(
        _ buffer: AVAudioPCMBuffer,
        completionType: PTTPlaybackCompletionType,
        completionHandler: @escaping @Sendable (PTTPlaybackCompletionEvent) -> Void
    ) {
        let callbackType: AVAudioPlayerNodeCompletionCallbackType = switch completionType {
        case .dataConsumed: .dataConsumed
        case .dataPlayedBack: .dataPlayedBack
        }
        let scheduledEngine = engine
        node.scheduleBuffer(buffer, completionCallbackType: callbackType) { [weak scheduledEngine] callbackType in
            // The API invokes this callback when the player is stopped as
            // well. A configuration change can stop the engine before its
            // notification reaches MainActor, so do not misclassify that
            // flushed tail as audible playback.
            guard scheduledEngine?.isRunning == true else {
                completionHandler(.playbackStopped)
                return
            }
            switch callbackType {
            case .dataConsumed:
                completionHandler(.dataConsumed)
            case .dataRendered:
                completionHandler(.dataConsumed)
            case .dataPlayedBack:
                completionHandler(.dataPlayedBack)
            @unknown default:
                completionHandler(.playbackStopped)
            }
        }
    }
 }
 /// Completion callbacks arrive off the main actor, while engine rebuilds are
 /// serialized on it. This small lock-backed latch lets a rebuild atomically
 /// claim only buffers whose completion has not already fired — even when the
 /// callback's hop back to the main actor is still queued.
 private final class PTTPlaybackCompletionState: @unchecked Sendable {
    private enum State {
        case scheduled
        case completed
        case retired
    }
    private let lock = NSLock()
    private var state: State = .scheduled
    /// Returns true exactly once when playback completion wins the race with
    /// an engine rebuild or stop.
    func complete() -> Bool {
        lock.withLock {
            guard case .scheduled = state else { return false }
            state = .completed
            return true
        }
    }
    /// Returns true exactly once when a rebuild or stop claims this
    /// still-pending schedule. Later callbacks from that engine are stale.
    func retireIfPending() -> Bool {
        lock.withLock {
            guard case .scheduled = state else { return false }
            state = .retired
            return true
        }
    }
 }
 /// Plays one inbound live voice burst with a small jitter buffer.
 ///
 /// Frames are decoded and scheduled back-to-back on an `AVAudioPlayerNode`;
 /// an underrun (missing/late packets) simply pauses output until the next
 /// buffer arrives, which self-heals timing without explicit silence
 /// insertion. Playback starts once `TransportConfig.pttJitterBufferSeconds`
 /// of audio is queued or `pttJitterDeadlineSeconds` has elapsed.
 ///
 /// Talk-over is bidirectional: when push-to-talk capture starts while this
 /// burst plays, the session category escalates underneath the engine — the
 /// player rebuilds a fresh engine against the new configuration and keeps
 /// streaming instead of dying. Real interruptions (phone call, route device
 /// gone) still stop it; the burst keeps assembling to file either way.
@MainActor
 final class PTTBurstPlayer {
    /// Restart-on-reconfigure ceiling: a burst is at most ~2 minutes, so a
    /// handful of category/route changes is plenty — beyond it something is
    /// thrashing and stopping cleanly beats an engine-rebuild loop.
    private static let maxEngineRestarts = 8
    private let makeEngine: @MainActor () -> PTTPlaybackEngine
    private var engine: PTTPlaybackEngine
    private let decoder: PTTFrameDecoder
    private let coordinator: AudioSessionCoordinator
    /// Injectable so tests don't fight over the app-wide exclusive-playback
    /// slot (a parallel test's `play()` would stop this player mid-test).
    private let exclusivity: VoiceNotePlaybackCoordinator
    private var queuedBuffers: [AVAudioPCMBuffer] = []
    private var queuedDuration: TimeInterval = 0
    private struct ScheduledBuffer {
        let id: UInt64
        let buffer: AVAudioPCMBuffer
        let completionState: PTTPlaybackCompletionState
    }
    /// Buffers handed to the current engine whose completion has not yet
    /// been processed on the main actor. Keeping the buffers themselves lets
    /// a category-escalation rebuild replay the unfinished tail in order.
    private var scheduledBuffers: [ScheduledBuffer] = []
    private var nextScheduledBufferID: UInt64 = 0
    /// Bumped on every engine rebuild or stop so completion tasks from a
    /// torn-down engine cannot mutate the current generation's pending list.
    private var engineGeneration = 0
    private var engineRestarts = 0
    private var engineStarted = false
    private var finished = false
    /// Latched off (internal read so tests can await the async failure path).
    private(set) var stopped = false
    /// A session acquire is in flight (it suspends off-main for the blocking
    /// session IPC); gates `startIfReady` against double acquisition.
    private var acquiringSession = false
    private var deadlineTask: Task<Void, Never>?
    private var sessionToken: AudioSessionCoordinator.Token?
    /// Reserved before the session acquire suspends. Activation succeeds only
    /// if no newer playback request claimed the floor in the meantime.
    private var playbackReservation: VoiceNotePlaybackCoordinator.Reservation?
    private var configChangeObserver: NSObjectProtocol?
    private(set) var isPlaying = false
    /// Fires exactly once when the player stops for good (drain-out, cancel,
    /// interruption, failure). `ChatLiveVoiceCoordinator` uses it to unpark
    /// the draining player it keeps alive after the assembly — the player's
    /// only long-lived owner — is discarded on burst END.
    var onStopped: (() -> Void)?
    init?(
        coordinator: AudioSessionCoordinator? = nil,
        exclusivity: VoiceNotePlaybackCoordinator? = nil,
        makeEngine: (@MainActor () -> PTTPlaybackEngine)? = nil
    ) {
        guard let format = PTTAudioFormat.pcmFormat, let decoder = PTTFrameDecoder() else { return nil }
        self.decoder = decoder
        self.coordinator = coordinator ?? .shared
        self.exclusivity = exclusivity ?? .shared
        let factory = makeEngine ?? { SystemPTTPlaybackEngine(format: format) }
        self.makeEngine = factory
        self.engine = factory()
        deadlineTask = Task { [weak self] in
            try? await Task.sleep(nanoseconds: UInt64(TransportConfig.pttJitterDeadlineSeconds * 1_000_000_000))
            self?.startIfReady(force: true)
        }
    }
    deinit {
        // Backstop for an owner dropping the player before it stopped: the
        // session coordinator retains registered tokens strongly, so a token
        // leaked here would keep the session active (and pin any escalated
        // category) for the app's lifetime. `release` is fire-and-forget
        // onto the coordinator's queue, so it is deinit-safe.
        if let token = sessionToken {
            coordinator.release(token)
        }
        if let observer = configChangeObserver {
            NotificationCenter.default.removeObserver(observer)
        }
        deadlineTask?.cancel()
    }
    /// Decodes and queues frames (in burst order). Starts playback when the
    /// jitter buffer fills.
    func enqueue(_ frames: [Data]) {
        guard !stopped else { return }
        for frame in frames {
            guard let pcm = decoder.decode(frame) else { continue }
            if engineStarted {
                schedule(pcm)
            } else {
                queuedBuffers.append(pcm)
                queuedDuration += Double(pcm.frameLength) / PTTAudioFormat.sampleRate
            }
        }
        startIfReady(force: false)
    }
    /// The burst ended: stop once everything scheduled has played out.
    func finishAfterDrain() {
        finished = true
        // The complete burst is queued — no jitter left to wait for. This
        // also matters when END lands while the async session acquire is
        // still in flight: the queued audio must play out, not be treated
        // as already drained.
        startIfReady(force: true)
        stopIfDrained()
    }
    /// Immediate stop (cancel, another playback taking over, interruption,
    /// teardown).
    func stop() {
        guard !stopped else { return }
        stopped = true
        deadlineTask?.cancel()
        removeConfigObserver()
        queuedBuffers = []
        retireScheduledBuffers()
        if engineStarted {
            engine.stop()
        }
        isPlaying = false
        releaseSessionToken()
        exclusivity.deactivate(self)
        onStopped?()
    }
    private func startIfReady(force: Bool) {
        guard !engineStarted, !acquiringSession, !stopped, !queuedBuffers.isEmpty else { return }
        guard force || queuedDuration >= TransportConfig.pttJitterBufferSeconds else { return }
        // Acquiring the session suspends for its blocking IPC (off the main
        // actor); frames arriving meanwhile keep queueing and are flushed
        // onto the engine once it starts.
        acquiringSession = true
        playbackReservation = exclusivity.reserve(self)
        Task { [weak self] in
            await self?.acquireSessionAndStart()
        }
    }
    private func acquireSessionAndStart() async {
        let token: AudioSessionCoordinator.Token
        do {
            token = try await coordinator.acquire(
                .playback,
                onInterrupted: { [weak self] in self?.stop() },
                onCategoryEscalated: { [weak self] in self?.restartEngine() }
            )
        } catch {
            acquiringSession = false
            SecureLogger.error("PTT playback session activation failed: \(error)", category: .session)
            // Playing unregistered would leave the engine exposed: another
            // holder's last release deactivates the session mid-play, and no
            // interruption/escalation fan-out ever reaches us. Bail like the
            // engine-start failure below; the burst still assembles to file.
            // (stop() also fires onStopped so a parked draining player is
            // unparked instead of leaking.)
            stop()
            return
        }
        acquiringSession = false
        // stop() (cancel, exclusivity, teardown) may have landed while the
        // session was activating: hand the token straight back.
        guard !stopped else {
            coordinator.release(token)
            return
        }
        sessionToken = token
        guard let playbackReservation,
              exclusivity.isCurrent(playbackReservation, for: self)
        else {
            // The request was superseded while audio-session activation was
            // suspended. Do not even start the retired engine.
            stop()
            return
        }
        // Observe reconfiguration before starting so nothing lands between.
        registerConfigObserver()
        do {
            try engine.start()
        } catch {
            // A capture racing this start can reconfigure the session while
            // the engine spins up (its escalation fan-out no-ops on a player
            // that never started): rebuild once against the settled
            // configuration — counted against the restart cap — before
            // giving up.
            SecureLogger.warning("PTT playback engine failed to start (\(error)) — rebuilding once", category: .session)
            removeConfigObserver()
            engineRestarts += 1
            engine = makeEngine()
            registerConfigObserver()
            do {
                try engine.start()
            } catch {
                SecureLogger.error("PTT playback engine failed to start: \(error)", category: .session)
                // stop() removes the observer, hands the token back, and
                // fires onStopped for any parked draining owner.
                stop()
                return
            }
        }
        engineStarted = true
        guard exclusivity.activate(self, reservation: playbackReservation)
        else {
            // A newer user-initiated playback reserved the floor while this
            // older PTT request was suspended in audio-session activation.
            // Never let the late completion steal playback back.
            stop()
            return
        }
        isPlaying = true
        engine.play()
        let buffered = queuedBuffers
        queuedBuffers = []
        queuedDuration = 0
        for buffer in buffered {
            schedule(buffer)
        }
    }
    /// The audio session was reconfigured underneath the running engine
    /// (category escalation for talk-over, or an engine configuration
    /// change): rebuild a fresh engine against the new configuration and
    /// keep streaming. Buffers already completed stay completed; the
    /// unfinished scheduled tail is replayed in order on the fresh engine,
    /// and frames still arriving continue scheduling after it.
    private func restartEngine() {
        guard engineStarted, !stopped else { return }
        engineRestarts += 1
        guard engineRestarts <= Self.maxEngineRestarts else {
            SecureLogger.warning("PTT playback: engine reconfigured \(engineRestarts) times in one burst — stopping", category: .session)
            stop()
            return
        }
        removeConfigObserver()
        // Claim the unfinished tail before stopping the old engine. Stopping
        // a player node may itself invoke its completion handlers; retiring
        // the claimed entries first makes those callbacks unambiguously stale.
        // A completion that fired just before this rebuild wins the latch and
        // is excluded even if its MainActor task has not run yet.
        let buffersToReplay = scheduledBuffers.compactMap { scheduled in
            scheduled.completionState.retireIfPending() ? scheduled.buffer : nil
        }
        scheduledBuffers = []
        engineGeneration += 1
        engine.stop()
        engine = makeEngine()
        registerConfigObserver()
        do {
            try engine.start()
        } catch {
            SecureLogger.error("PTT playback engine failed to restart after session reconfigure: \(error)", category: .session)
            stop()
            return
        }
        engine.play()
        for buffer in buffersToReplay {
            schedule(buffer)
        }
        SecureLogger.info("PTT playback: engine restarted after session reconfigure", category: .session)
        // If every old buffer completed before the rebuild, a finished burst
        // can stop now. Otherwise the replayed tail keeps it alive until its
        // new-generation completions arrive.
        stopIfDrained()
    }
    private func registerConfigObserver() {
        guard let object = engine.configChangeObject else { return }
        configChangeObserver = NotificationCenter.default.addObserver(
            forName: .AVAudioEngineConfigurationChange,
            object: object,
            queue: .main
        ) { [weak self] _ in
            Task { @MainActor [weak self] in
                self?.restartEngine()
            }
        }
    }
    private func removeConfigObserver() {
        if let observer = configChangeObserver {
            NotificationCenter.default.removeObserver(observer)
            configChangeObserver = nil
        }
    }
    private func schedule(_ buffer: AVAudioPCMBuffer) {
        let id = nextScheduledBufferID
        nextScheduledBufferID &+= 1
        let completionState = PTTPlaybackCompletionState()
        scheduledBuffers.append(ScheduledBuffer(
            id: id,
            buffer: buffer,
            completionState: completionState
        ))
        let generation = engineGeneration
        engine.schedule(buffer, completionType: .dataPlayedBack) { [weak self, completionState] event in
            guard event == .dataPlayedBack else { return }
            // Mark completion before hopping to MainActor. A rebuild can then
            // distinguish already-completed audio from an unfinished tail
            // even when this task has not run yet.
            guard completionState.complete() else { return }
            Task { @MainActor [weak self] in
                guard let self, self.engineGeneration == generation else { return }
                self.scheduledBuffers.removeAll { $0.id == id }
                self.stopIfDrained()
            }
        }
    }
    private func retireScheduledBuffers() {
        engineGeneration += 1
        for scheduled in scheduledBuffers {
            _ = scheduled.completionState.retireIfPending()
        }
        scheduledBuffers = []
    }
    private func stopIfDrained() {
        guard finished, scheduledBuffers.isEmpty else { return }
        // Started: everything scheduled has played out. Never started with
        // nothing queued or in flight (e.g. no decodable frames): nothing
        // will ever play. Otherwise the engine start is still pending (the
        // async session acquire) and the queued audio must play out first.
        guard engineStarted || (!acquiringSession && queuedBuffers.isEmpty) else { return }
        stop()
    }
    private func releaseSessionToken() {
        sessionToken.map(coordinator.release)
        sessionToken = nil
    }
 }
 extension PTTBurstPlayer: ExclusivePlayback {
    /// A live stream can't meaningfully pause; yielding the floor stops it.
    /// The burst keeps assembling to file, so nothing is lost.
    nonisolated func pauseForExclusivity() {
        Task { @MainActor [weak self] in
            self?.stop()
        }
    }
 }
@@ -0,0 +1,326 @@
 //
 // PTTCaptureEngine.swift
 // bitchat
 //
 // This is free and unencumbered software released into the public domain.
 // For more information, see <https://unlicense.org>
 //
 import AVFoundation
 import BitLogger
 import Foundation
 /// Owns one capture token and returns it even when the capture engine's owner
 /// disappears without reaching its normal stop/cancel path. The coordinator
 /// retains registered tokens strongly, so relying on `Token.deinit` cannot
 /// reclaim an abandoned hold.
 final class PTTCaptureSessionLease: @unchecked Sendable {
    private let coordinator: AudioSessionCoordinator
    private let lock = NSLock()
    private var token: AudioSessionCoordinator.Token?
    init(coordinator: AudioSessionCoordinator) {
        self.coordinator = coordinator
    }
    func install(_ token: AudioSessionCoordinator.Token) {
        let previous = lock.withLock {
            let previous = self.token
            self.token = token
            return previous
        }
        previous.map(coordinator.release)
    }
    func release() {
        let token = lock.withLock {
            let token = self.token
            self.token = nil
            return token
        }
        token.map(coordinator.release)
    }
    deinit {
        release()
    }
 }
 /// Monotonic capture identity shared by main-actor lifecycle code and queued
 /// engine callbacks. Removing a notification observer does not cancel a block
 /// already enqueued on the main queue, so every callback must also prove it
 /// still belongs to the current hold before mutating capture state.
 final class PTTCaptureGeneration: @unchecked Sendable {
    private let lock = NSLock()
    private var value: UInt = 0
    func begin() -> UInt {
        lock.withLock {
            value &+= 1
            return value
        }
    }
    func invalidate() {
        lock.withLock { value &+= 1 }
    }
    func invalidate(ifCurrent generation: UInt) -> Bool {
        lock.withLock {
            guard value == generation else { return false }
            value &+= 1
            return true
        }
    }
    func isCurrent(_ generation: UInt) -> Bool {
        lock.withLock { value == generation }
    }
 }
 /// Captures microphone audio for a live push-to-talk burst, producing both:
 /// - live AAC frames via `onFrames` (called on the capture queue), and
 /// - a finalized `.m4a` voice note on `stop()` — the same artifact
 ///   `VoiceRecorder` produces, so the existing voice-note send pipeline
 ///   handles delivery to receivers that missed the live stream.
 /// `@unchecked Sendable`: every mutable property is confined to one executor —
 /// the capture `queue` (resampler/encoder/file/counters) or the main actor
 /// (`engine`, `engineStarted`, `sessionLease`, `configChangeObserver`) — so
 /// weak references may cross the `@Sendable` tap/notification closures, which
 /// immediately hop back to the owning executor.
 final class PTTCaptureEngine: @unchecked Sendable {
    /// Hard cap matching `VoiceRecorder.maxRecordingDuration`: past it the
    /// engine keeps running (the UI owns the gesture) but stops encoding.
    private static let maxCaptureDuration: TimeInterval = 120
    /// Recreated on every `start()`: an engine whose input unit was
    /// instantiated against an earlier (playback-only or inactive) audio
    /// session keeps reporting a dead 0 Hz / 2 ch input format and fails to
    /// enable the mic (AURemoteIO -10851, observed on iPhone field tests).
    private var engine = AVAudioEngine()
    private let queue = DispatchQueue(label: "chat.bitchat.ptt.capture", qos: .userInitiated)
    private let coordinator: AudioSessionCoordinator
    private let sessionLease: PTTCaptureSessionLease
    private let captureGeneration = PTTCaptureGeneration()
    // Capture-queue-confined state.
    private var resampler: PTTInputResampler?
    private var encoder: PTTFrameEncoder?
    private var file: AVAudioFile?
    private var fileURL: URL?
    private var encodedFrameCount = 0
    private var running = false
    private var captureStart = Date()
    /// Whether `engine.start()` succeeded for the current capture
    /// (see `stopEngineIfStarted`).
    @MainActor private var engineStarted = false
    @MainActor private var configChangeObserver: NSObjectProtocol?
    /// Called on the capture queue with each batch of encoded AAC frames.
    var onFrames: (([Data]) -> Void)?
    enum CaptureError: Error {
        case inputUnavailable
        case audioSetupFailed
    }
    init(coordinator: AudioSessionCoordinator = .shared) {
        self.coordinator = coordinator
        self.sessionLease = PTTCaptureSessionLease(coordinator: coordinator)
    }
    deinit {
        sessionLease.release()
    }
    /// Async because acquiring the session hops its blocking IPC off the main
    /// actor (a PTT press used to stall main >1 s in `setActive`); the engine
    /// itself still starts back on main once the session is configured.
    @MainActor
    func start(outputURL: URL) async throws {
        let generation = captureGeneration.begin()
        let token = try await coordinator.acquire(.capture) { [weak self] in
            self?.handleInterruption(for: generation)
        }
        // The hold ended (stop/cancel) while the session was activating:
        // starting the engine now would leave a hot mic after release.
        guard captureGeneration.isCurrent(generation) else {
            coordinator.release(token)
            throw CancellationError()
        }
        sessionLease.install(token)
        do {
            try beginCapture(outputURL: outputURL, generation: generation)
        } catch {
            releaseSessionToken()
            throw error
        }
    }
    @MainActor
    private func beginCapture(outputURL: URL, generation: UInt) throws {
        // Fresh engine per capture so its input unit binds to the session
        // that is active *now* (see `engine` doc comment).
        engine = AVAudioEngine()
        let inputFormat = engine.inputNode.outputFormat(forBus: 0)
        guard inputFormat.sampleRate > 0, inputFormat.channelCount > 0 else {
            SecureLogger.error("PTT: capture input unavailable (input reports \(Int(inputFormat.sampleRate)) Hz, \(inputFormat.channelCount) ch)", category: .session)
            throw CaptureError.inputUnavailable
        }
        guard let resampler = PTTInputResampler(inputFormat: inputFormat),
              let encoder = PTTFrameEncoder(),
              let pcmFormat = PTTAudioFormat.pcmFormat
        else { throw CaptureError.audioSetupFailed }
        let file = try AVAudioFile(
            forWriting: outputURL,
            settings: PTTAudioFormat.voiceNoteFileSettings,
            commonFormat: pcmFormat.commonFormat,
            interleaved: pcmFormat.isInterleaved
        )
        queue.sync {
            self.resampler = resampler
            self.encoder = encoder
            self.file = file
            self.fileURL = outputURL
            self.encodedFrameCount = 0
            self.captureStart = Date()
            self.running = true
        }
        engine.inputNode.installTap(onBus: 0, bufferSize: 4096, format: inputFormat) { [weak self] buffer, _ in
            self?.queue.async { self?.process(buffer, generation: generation) }
        }
        // Route/category changes reconfigure the engine underneath the tap;
        // stop and finalize cleanly — the .m4a captured so far still sends.
        // Registered before start() so no reconfigure lands unobserved
        // (handleInterruption also validates this capture generation).
        configChangeObserver = NotificationCenter.default.addObserver(
            forName: .AVAudioEngineConfigurationChange,
            object: engine,
            queue: .main
        ) { [weak self] _ in
            Task { @MainActor [weak self] in
                self?.handleInterruption(for: generation)
            }
        }
        engine.prepare()
        do {
            try engine.start()
        } catch {
            SecureLogger.error("PTT: capture engine failed to start (input: \(Int(inputFormat.sampleRate)) Hz, \(inputFormat.channelCount) ch): \(error)", category: .session)
            if let observer = configChangeObserver {
                NotificationCenter.default.removeObserver(observer)
                configChangeObserver = nil
            }
            engine.inputNode.removeTap(onBus: 0)
            queue.sync { self.teardown(deleteFile: true) }
            throw error
        }
        engineStarted = true
        SecureLogger.info("PTT: capture engine running (input: \(Int(inputFormat.sampleRate)) Hz, \(inputFormat.channelCount) ch)", category: .session)
    }
    /// Stops capture and finalizes the `.m4a`. Returns the file URL and the
    /// number of encoded AAC frames (each `PTTAudioFormat.frameDuration` long).
    @MainActor
    func stop() -> (url: URL?, encodedFrames: Int) {
        captureGeneration.invalidate()
        stopEngineIfStarted()
        let result: (URL?, Int) = queue.sync {
            let url = fileURL
            let frames = encodedFrameCount
            teardown(deleteFile: false)
            return (url, frames)
        }
        releaseSessionToken()
        return result
    }
    @MainActor
    func cancel() {
        captureGeneration.invalidate()
        stopEngineIfStarted()
        queue.sync { teardown(deleteFile: true) }
        releaseSessionToken()
    }
    /// Audio session interrupted (call, Siri) or the engine was reconfigured
    /// mid-capture: behave like `stop()` — finalize the `.m4a` container but
    /// keep `fileURL`/`encodedFrameCount` so the caller's pending `stop()`
    /// still returns the note for delivery.
    @MainActor
    private func handleInterruption(for generation: UInt) {
        // Also invalidate a start whose acquire has registered its token but
        // has not returned to this actor yet. Without this bump the callback
        // is lost while `engineStarted == false`, and the resumed start can
        // open the mic after the stop signal.
        guard captureGeneration.invalidate(ifCurrent: generation) else { return }
        guard engineStarted else {
            releaseSessionToken()
            return
        }
        stopEngineIfStarted()
        queue.sync {
            running = false
            // Releasing the AVAudioFile finalizes the .m4a container.
            file = nil
            encoder = nil
            resampler = nil
        }
        releaseSessionToken()
        SecureLogger.info("PTT: capture interrupted — burst finalized early", category: .session)
    }
    /// Touching `inputNode` on an engine that never started instantiates its
    /// input unit against whatever session is active and spams AURemoteIO
    /// errors — a canceled-before-start hold must not touch the engine.
    @MainActor
    private func stopEngineIfStarted() {
        if let observer = configChangeObserver {
            NotificationCenter.default.removeObserver(observer)
            configChangeObserver = nil
        }
        guard engineStarted else { return }
        engineStarted = false
        engine.inputNode.removeTap(onBus: 0)
        engine.stop()
    }
    @MainActor
    private func releaseSessionToken() {
        sessionLease.release()
    }
    // MARK: - Capture queue
    private func process(_ buffer: AVAudioPCMBuffer, generation: UInt) {
        guard captureGeneration.isCurrent(generation),
              running,
              Date().timeIntervalSince(captureStart) < Self.maxCaptureDuration,
              let resampled = resampler?.resample(buffer)
        else { return }
        do {
            try file?.write(from: resampled)
        } catch {
            SecureLogger.error("PTT capture file write failed: \(error)", category: .session)
        }
        guard let frames = encoder?.encode(resampled), !frames.isEmpty else { return }
        encodedFrameCount += frames.count
        onFrames?(frames)
    }
    private func teardown(deleteFile: Bool) {
        running = false
        // Releasing the AVAudioFile finalizes the .m4a container.
        file = nil
        encoder = nil
        resampler = nil
        if deleteFile, let url = fileURL {
            try? FileManager.default.removeItem(at: url)
        }
        fileURL = nil
    }
 }
@@ -0,0 +1,39 @@
 //
 // PTTSettings.swift
 // bitchat
 //
 // This is free and unencumbered software released into the public domain.
 // For more information, see <https://unlicense.org>
 //
 import Foundation
 #if os(iOS)
 import UIKit
 #elseif os(macOS)
 import AppKit
 #endif
 /// User preference for live push-to-talk voice. One switch controls both
 /// directions: streaming your holds live, and auto-playing inbound bursts.
 /// Off means voice messages behave exactly like classic voice notes.
 enum PTTSettings {
    private static let liveVoiceEnabledKey = "ptt.liveVoiceEnabled"
    static var liveVoiceEnabled: Bool {
        get { UserDefaults.standard.object(forKey: liveVoiceEnabledKey) as? Bool ?? true }
        set { UserDefaults.standard.set(newValue, forKey: liveVoiceEnabledKey) }
    }
    /// Autoplay is foreground-only: audio must never start from the
    /// background.
    @MainActor
    static var isAppActive: Bool {
        #if os(iOS)
        return UIApplication.shared.applicationState == .active
        #elseif os(macOS)
        return NSApplication.shared.isActive
        #else
        return true
        #endif
    }
 }
@@ -0,0 +1,237 @@
 //
 // VoiceCaptureSession.swift
 // bitchat
 //
 // This is free and unencumbered software released into the public domain.
 // For more information, see <https://unlicense.org>
 //
 import BitFoundation
 import BitLogger
 import Foundation
 /// Capture backend behind the composer's hold-to-record gesture.
 /// `VoiceRecordingViewModel` drives one session per press; the concrete type
 /// decides *how* audio leaves the device: `VoiceNoteCaptureSession` records a
 /// note delivered on release (today's behavior), `PTTLiveVoiceSession`
 /// additionally streams frames live while the button is held.
@MainActor
 protocol VoiceCaptureSession: AnyObject {
    /// Whether audio is leaving the device in real time while recording —
    /// drives the composer's LIVE treatment.
    var isLive: Bool { get }
    func requestPermission() async -> Bool
    func start() async throws
    /// Stops capture and returns the finalized voice-note file, or nil when
    /// nothing valid was captured.
    func finish() async -> URL?
    func cancel() async
 }
 /// The classic record-then-send backend, wrapping the shared `VoiceRecorder`.
@MainActor
 final class VoiceNoteCaptureSession: VoiceCaptureSession {
    private let recorder: VoiceRecorder
    private let owner = VoiceRecorder.RecordingOwner()
    var isLive: Bool { false }
    init(recorder: VoiceRecorder = .shared) {
        self.recorder = recorder
    }
    func requestPermission() async -> Bool {
        await recorder.requestPermission()
    }
    func start() async throws {
        try await recorder.startRecording(owner: owner)
    }
    func finish() async -> URL? {
        await recorder.stopRecording(owner: owner)
    }
    func cancel() async {
        await recorder.cancelRecording(owner: owner)
    }
 }
 /// Testable surface of the live capture engine. Production uses
 /// `PTTCaptureEngine`; tests can supply captured-frame counts without opening
 /// real audio hardware.
@MainActor
 protocol PTTCapturing: AnyObject {
    var onFrames: (([Data]) -> Void)? { get set }
    func start(outputURL: URL) async throws
    func stop() -> (url: URL?, encodedFrames: Int)
    func cancel()
 }
 extension PTTCaptureEngine: PTTCapturing {}
 /// Live push-to-talk backend: streams `VoiceBurstPacket`s to one peer while
 /// recording, then finalizes the same audio as a standard voice note whose
 /// file name carries the burst ID (`voice_<burstID>.m4a`) so receivers that
 /// heard the live stream absorb the note silently instead of seeing a
 /// duplicate.
@MainActor
 final class PTTLiveVoiceSession: VoiceCaptureSession {
    let burstID: Data
    private let sendPacket: (Data) -> Void
    private let capture: any PTTCapturing
    private let now: () -> Date
    /// Capture-queue-confined stream state: packetizes frames and lazily
    /// emits START so packet order is guaranteed by queue serialization.
    private final class StreamState {
        var packetizer: VoiceBurstPacketizer
        var sentStart = false
        init(burstID: Data) {
            packetizer = VoiceBurstPacketizer(burstID: burstID)
        }
    }
    private let stream: StreamState
    private var startDate: Date?
    private var completed = false
    var isLive: Bool { true }
    /// - Parameter sendPacket: delivers one encoded `VoiceBurstPacket` to the
    ///   target peer; must be safe to call from any queue (BLEService hops to
    ///   its own message queue internally).
    init(
        sendPacket: @escaping (Data) -> Void,
        capture: (any PTTCapturing)? = nil,
        now: @escaping () -> Date = Date.init,
        burstID: Data? = nil
    ) {
        self.burstID = burstID ?? VoiceBurstPacket.makeBurstID()
        self.sendPacket = sendPacket
        self.capture = capture ?? PTTCaptureEngine()
        self.now = now
        self.stream = StreamState(burstID: self.burstID)
    }
    func requestPermission() async -> Bool {
        await VoiceRecorder.shared.requestPermission()
    }
    func start() async throws {
        let outputURL = try Self.makeOutputURL(burstID: burstID)
        let sendPacket = sendPacket
        let stream = stream
        capture.onFrames = { frames in
            if !stream.sentStart {
                stream.sentStart = true
                if let start = VoiceBurstPacket(
                    burstID: stream.packetizer.burstID,
                    seq: 0,
                    kind: .start(codec: .aacLC16kMono)
                ) {
                    sendPacket(start.encode())
                }
            }
            for frame in frames {
                for packet in stream.packetizer.add(frame) {
                    sendPacket(packet)
                }
            }
            // Flush per callback batch: at ~130-byte frames the budget fits
            // one frame per packet anyway, and holding residue would add
            // ~100 ms of avoidable latency.
            for packet in stream.packetizer.flush() {
                sendPacket(packet)
            }
        }
        do {
            try await capture.start(outputURL: outputURL)
        } catch is CancellationError {
            // The hold was released/canceled while the session acquire was
            // in flight: the engine never started and the capture already
            // handed its token back — nothing to retry. A coordinator-side
            // interruption during handoff also cancels acquire, but that is
            // not a successful start and must propagate to the view model.
            guard completed else { throw CancellationError() }
            return
        } catch {
            // The HAL can briefly report a dead input right after the audio
            // session (re)activates while the route settles; one retry after
            // a short pause covers it (observed on iPhone field tests).
            SecureLogger.warning("PTT: capture start failed (\(error)) — retrying once after route settle", category: .session)
            try? await Task.sleep(nanoseconds: 150_000_000)
            // The hold may have been released/canceled during the retry pause.
            // Starting the mic now would leave it live and streaming after the
            // user let go, so bail instead of opening a hot mic.
            guard !completed else {
                capture.cancel()
                return
            }
            try await capture.start(outputURL: outputURL)
        }
        startDate = now()
        SecureLogger.info("PTT: live burst \(burstID.hexEncodedString()) capture started", category: .session)
    }
    func finish() async -> URL? {
        guard !completed else { return nil }
        completed = true
        let elapsed = startDate.map { now().timeIntervalSince($0) } ?? 0
        let (url, encodedFrames) = capture.stop()
        // stop() drained the capture queue, so touching `stream` is safe now.
        let capturedDuration = Double(encodedFrames) * PTTAudioFormat.frameDuration
        guard elapsed >= VoiceRecorder.minRecordingDuration,
              capturedDuration >= VoiceRecorder.minRecordingDuration,
              let url
        else {
            sendControlPacket(.canceled)
            if let url {
                try? FileManager.default.removeItem(at: url)
            }
            return nil
        }
        for packet in stream.packetizer.flush() {
            sendPacket(packet)
        }
        let durationMs = UInt32((capturedDuration * 1000).rounded())
        sendControlPacket(.end(totalDataPackets: stream.packetizer.dataPacketCount, durationMs: durationMs))
        SecureLogger.info("PTT: live burst \(burstID.hexEncodedString()) finished — \(stream.packetizer.dataPacketCount) data packets, \(encodedFrames) frames, \(durationMs) ms", category: .session)
        return url
    }
    func cancel() async {
        let alreadyCompleted = completed
        completed = true
        // Always tear down the capture, even if a quick-release already marked
        // us completed: the engine can start late (during start()'s retry
        // pause), and only capture.cancel() stops the mic and deactivates the
        // session. It is idempotent, so a redundant call is harmless.
        capture.cancel()
        if !alreadyCompleted {
            sendControlPacket(.canceled)
        }
    }
    private func sendControlPacket(_ kind: VoiceBurstPacket.Kind) {
        guard let packet = VoiceBurstPacket(burstID: burstID, seq: stream.packetizer.nextSeq, kind: kind) else { return }
        sendPacket(packet.encode())
    }
    private static func makeOutputURL(burstID: Data) throws -> URL {
        let base = try FileManager.default.url(
            for: .applicationSupportDirectory,
            in: .userDomainMask,
            appropriateFor: nil,
            create: true
        )
        let directory = base
            .appendingPathComponent("files", isDirectory: true)
            .appendingPathComponent("voicenotes/outgoing", isDirectory: true)
        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true, attributes: nil)
        return directory.appendingPathComponent("voice_\(burstID.hexEncodedString()).m4a")
    }
 }
@@ -9,6 +9,9 @@ final class VoiceNotePlaybackController: NSObject, ObservableObject, AVAudioPlay
    @Published private(set) var duration: TimeInterval = 0
    @Published private(set) var progress: Double = 0
    /// Internal lifecycle visibility for deterministic acquisition tests.
    var isPlaybackStartPending: Bool { sessionAcquireInFlight }
    /// rounded so 4.9s shows "00:05"
    var roundedDuration: Int {
        guard duration.isFinite else { return 0 }
@@ -24,9 +27,24 @@ final class VoiceNotePlaybackController: NSObject, ObservableObject, AVAudioPlay
    private var player: AVAudioPlayer?
    private var timer: Timer?
    private var url: URL
    /// Test seam; `AudioSessionCoordinator.shared` when nil.
    private let sessionCoordinatorOverride: AudioSessionCoordinator?
    /// Injectable so tests don't fight over the app-wide exclusive-playback
    /// slot (a parallel test's `play()` would pause this controller mid-test).
    private let exclusivity: VoiceNotePlaybackCoordinator
    private var sessionToken: AudioSessionCoordinator.Token?
    /// A session acquire is in flight (it suspends off-main for the blocking
    /// session IPC); gates against double acquisition on rapid play taps.
    private var sessionAcquireInFlight = false
-    init(url: URL) {
+    init(
        url: URL,
        sessionCoordinator: AudioSessionCoordinator? = nil,
        exclusivity: VoiceNotePlaybackCoordinator? = nil
    ) {
        self.url = url
        self.sessionCoordinatorOverride = sessionCoordinator
        self.exclusivity = exclusivity ?? .shared
        super.init()
        // Don't load anything eagerly - wait until user interaction or view is fully displayed
    }
@@ -51,6 +69,16 @@ final class VoiceNotePlaybackController: NSObject, ObservableObject, AVAudioPlay
    deinit {
        timer?.invalidate()
        player?.stop()
        // A per-row @StateObject can be discarded mid-playback (navigating
        // away). Leaking the token here would hold the session forever —
        // never deactivating it, and pinning any escalated category for the
        // app's lifetime. `release` is fire-and-forget onto the coordinator's
        // queue, so it is deinit-safe: only the Sendable token crosses.
        if let token = sessionToken {
            sessionToken = nil
            (sessionCoordinatorOverride ?? .shared).release(token)
        }
    }
    func replaceURL(_ url: URL) {
@@ -68,11 +96,15 @@ final class VoiceNotePlaybackController: NSObject, ObservableObject, AVAudioPlay
    func play() {
        guard ensurePlayerReady() else { return }
-        VoiceNotePlaybackCoordinator.shared.activate(self)
+        exclusivity.activate(self)
-        player?.play()
+        isPlaying = true
        startTimer()
        updateProgress()
-        isPlaying = true
+        // Acquired here (not in ensurePlayerReady): scrubbing a paused note
        // must not hold the session while nothing is audible. The session
        // calls block on audio-server IPC, so they run off the main thread;
        // the player starts once the session is configured.
        startPlayerAfterAcquiringSession()
    }
    func pause() {
@@ -80,6 +112,7 @@ final class VoiceNotePlaybackController: NSObject, ObservableObject, AVAudioPlay
        stopTimer()
        updateProgress()
        isPlaying = false
        releaseSession()
    }
    func stop() {
@@ -88,7 +121,8 @@ final class VoiceNotePlaybackController: NSObject, ObservableObject, AVAudioPlay
        stopTimer()
        updateProgress()
        isPlaying = false
-        VoiceNotePlaybackCoordinator.shared.deactivate(self)
+        releaseSession()
        exclusivity.deactivate(self)
    }
    func seek(to fraction: Double) {
@@ -96,8 +130,11 @@ final class VoiceNotePlaybackController: NSObject, ObservableObject, AVAudioPlay
        let clamped = max(0, min(1, fraction))
        if let player = player {
            player.currentTime = clamped * player.duration
-            if isPlaying {
+            // While the session acquire is still in flight, don't start
-                player.play()
+            // audio pre-activation — the pending acquire's completion starts
            // playback (from the new position) once the session resolves.
            if isPlaying, !sessionAcquireInFlight {
                startPreparedPlayer()
            }
            updateProgress()
        }
@@ -112,18 +149,20 @@ final class VoiceNotePlaybackController: NSObject, ObservableObject, AVAudioPlay
            self.stopTimer()
            self.updateProgress()
            self.isPlaying = false
-            VoiceNotePlaybackCoordinator.shared.deactivate(self)
+            self.releaseSession()
            self.exclusivity.deactivate(self)
        }
    }
    // MARK: - Private Helpers
    private func preparePlayer(for url: URL) {
-        // Prepare player synchronously (only called when playback is requested)
+        // Load metadata synchronously, but do not call prepareToPlay here:
        // paused scrubbing reaches this path and must not acquire playback
        // hardware outside the AudioSessionCoordinator token lifetime.
        do {
            let player = try AVAudioPlayer(contentsOf: url)
            player.delegate = self
            player.prepareToPlay()
            self.player = player
            duration = player.duration
            currentTime = player.currentTime
@@ -141,16 +180,79 @@ final class VoiceNotePlaybackController: NSObject, ObservableObject, AVAudioPlay
        if player == nil {
            preparePlayer(for: url)
        }
-        #if os(iOS)
+        return player != nil
-        let session = AVAudioSession.sharedInstance()
+    }
    /// All entry points (SwiftUI actions, `pauseForExclusivity`, the
    /// delegate's main-queue hop) run on the main thread; the acquire itself
    /// suspends while the blocking session IPC runs on the coordinator's
    /// queue, and the player starts when it resolves. An acquire failure
    /// leaves playback stopped: starting without a registered token would
    /// bypass interruption fan-out and the coordinator's refcount. A
    /// pause/stop landing mid-acquire hands the token straight back.
    private func startPlayerAfterAcquiringSession() {
        if sessionToken != nil {
            startPreparedPlayer()
            return
        }
        guard !sessionAcquireInFlight else { return }
        sessionAcquireInFlight = true
        let coordinator = sessionCoordinatorOverride ?? AudioSessionCoordinator.shared
        Task { @MainActor [weak self] in
            var token: AudioSessionCoordinator.Token?
            do {
-            try session.setCategory(.playback, mode: .spokenAudio, options: [.mixWithOthers])
+                token = try await coordinator.acquire(.playback) { [weak self] in
-            try session.setActive(true, options: [])
+                    self?.pause()
                }
            } catch {
                SecureLogger.error("Failed to activate audio session: \(error)", category: .session)
            }
-        #endif
+            guard let self else {
-        return player != nil
+                // The row was discarded while acquiring; deinit had no token
                // to release yet.
                token.map(coordinator.release)
                return
            }
            self.sessionAcquireInFlight = false
            guard self.isPlaying else {
                // Paused/stopped while the session was activating.
                token.map(coordinator.release)
                return
            }
            guard let token else {
                self.failPlaybackStart()
                return
            }
            self.sessionToken = token
            self.startPreparedPlayer()
        }
    }
    @discardableResult
    private func startPreparedPlayer() -> Bool {
        guard let player,
              player.prepareToPlay(),
              player.play()
        else {
            SecureLogger.error("Voice note player refused to start " + url.lastPathComponent, category: .session)
            failPlaybackStart()
            return false
        }
        return true
    }
    private func failPlaybackStart() {
        player?.pause()
        stopTimer()
        updateProgress()
        isPlaying = false
        releaseSession()
        exclusivity.deactivate(self)
    }
    private func releaseSession() {
        sessionToken.map((sessionCoordinatorOverride ?? .shared).release)
        sessionToken = nil
    }
    private func startTimer() {
@@ -181,25 +283,75 @@ final class VoiceNotePlaybackController: NSObject, ObservableObject, AVAudioPlay
    }
 }
-/// Ensures only one voice note plays at a time.
+/// Something that can hold the app's single audio-playback slot and yield it
 /// when another playback starts (voice notes pause; live bursts stop).
 protocol ExclusivePlayback: AnyObject {
    func pauseForExclusivity()
 }
 extension VoiceNotePlaybackController: ExclusivePlayback {
    func pauseForExclusivity() {
        pause()
    }
 }
 /// Ensures only one voice playback (note or live burst) runs at a time.
 final class VoiceNotePlaybackCoordinator {
    static let shared = VoiceNotePlaybackCoordinator()
-    private weak var activeController: VoiceNotePlaybackController?
+    struct Reservation: Equatable {
        fileprivate let generation: UInt64
    }
-    private init() {}
+    private weak var activeController: (any ExclusivePlayback)?
    private weak var latestReservedController: (any ExclusivePlayback)?
    private var latestReservation = Reservation(generation: 0)
-    func activate(_ controller: VoiceNotePlaybackController) {
+    /// Internal so tests can isolate their own exclusivity slot; the app
    /// uses `shared`.
    init() {}
    /// Records playback intent without interrupting audio that is already
    /// audible. Async starters reserve before suspension, then activate only
    /// after their audio resource is ready.
    func reserve(_ controller: any ExclusivePlayback) -> Reservation {
        latestReservation = Reservation(generation: latestReservation.generation &+ 1)
        latestReservedController = controller
        return latestReservation
    }
    /// Immediate activation for synchronous/user-initiated playback.
    @discardableResult
    func activate(_ controller: any ExclusivePlayback) -> Reservation {
        let reservation = reserve(controller)
        _ = activate(controller, reservation: reservation)
        return reservation
    }
    /// Commits an earlier reservation only when it is still the newest
    /// playback request. This prevents an older async acquire from stealing
    /// the floor after a newer play gesture.
    @discardableResult
    func activate(_ controller: any ExclusivePlayback, reservation: Reservation) -> Bool {
        guard isCurrent(reservation, for: controller) else { return false }
        if activeController === controller {
-            return
+            return true
        }
-        activeController?.pause()
+        activeController?.pauseForExclusivity()
        activeController = controller
        return true
    }
-    func deactivate(_ controller: VoiceNotePlaybackController) {
+    func isCurrent(_ reservation: Reservation, for controller: any ExclusivePlayback) -> Bool {
        latestReservation == reservation && latestReservedController === controller
    }
    func deactivate(_ controller: any ExclusivePlayback) {
        if activeController === controller {
            activeController = nil
        }
        if latestReservedController === controller {
            latestReservedController = nil
        }
    }
 }
@@ -1,22 +1,95 @@
 import Foundation
 import AVFoundation
 /// The small surface of `AVAudioRecorder` that `VoiceRecorder` owns. Keeping
 /// it behind a protocol lets lifecycle races be tested without opening the
 /// microphone on the test host.
 protocol VoiceAudioRecording: AnyObject {
    var isRecording: Bool { get }
    var isMeteringEnabled: Bool { get set }
    func prepareToRecord() -> Bool
    func record(forDuration duration: TimeInterval) -> Bool
    func stop()
 }
 extension AVAudioRecorder: VoiceAudioRecording {}
 protocol VoiceAudioRecorderCreating {
    func makeRecorder(url: URL) throws -> any VoiceAudioRecording
 }
 private struct SystemVoiceAudioRecorderFactory: VoiceAudioRecorderCreating {
    func makeRecorder(url: URL) throws -> any VoiceAudioRecording {
        let settings: [String: Any] = [
            AVFormatIDKey: kAudioFormatMPEG4AAC,
            AVSampleRateKey: 16_000,
            AVNumberOfChannelsKey: 1,
            AVEncoderBitRateKey: 16_000
        ]
        return try AVAudioRecorder(url: url, settings: settings)
    }
 }
 /// Manages audio capture for mesh voice notes with predictable encoding settings.
 actor VoiceRecorder {
-    enum RecorderError: Error {
+    enum RecorderError: Error, Equatable {
        case microphoneAccessDenied
        case recorderInitializationFailed
        case recordingInProgress
        case failedToStartRecording
    }
    static let shared = VoiceRecorder()
    private let paddingInterval: TimeInterval = 0.5
    private let maxRecordingDuration: TimeInterval = 120
    static let minRecordingDuration: TimeInterval = 1
-    private var recorder: AVAudioRecorder?
+    /// Identity of one press/hold. Every lifecycle mutation must present the
    /// same owner that started the recorder, so a stale finish or cancel from
    /// another hold cannot stop or delete the current recording.
    final class RecordingOwner: @unchecked Sendable {}
    /// Test-only scheduling seams for lifecycle boundaries that otherwise rely
    /// on wall-clock sleeps. Production uses the real padding delay.
    struct TestingHooks: Sendable {
        let waitForStopPadding: (@Sendable (TimeInterval) async -> Void)?
        init(waitForStopPadding: (@Sendable (TimeInterval) async -> Void)? = nil) {
            self.waitForStopPadding = waitForStopPadding
        }
    }
    private let sessionCoordinator: AudioSessionCoordinator
    private let recorderFactory: any VoiceAudioRecorderCreating
    private let permissionGranted: () -> Bool
    private let paddingInterval: TimeInterval
    private let maxRecordingDuration: TimeInterval
    private let outputDirectory: URL?
    private let testingHooks: TestingHooks
    private var recorder: (any VoiceAudioRecording)?
    private var currentURL: URL?
    private var sessionToken: AudioSessionCoordinator.Token?
    private var activeOwner: RecordingOwner?
    /// True only while `startRecording()` is suspended in session acquire.
    /// A second start is rejected instead of superseding the first one.
    private var startInFlight = false
    init(
        sessionCoordinator: AudioSessionCoordinator = .shared,
        recorderFactory: any VoiceAudioRecorderCreating = SystemVoiceAudioRecorderFactory(),
        permissionGranted: (() -> Bool)? = nil,
        paddingInterval: TimeInterval = 0.5,
        maxRecordingDuration: TimeInterval = 120,
        outputDirectory: URL? = nil,
        testingHooks: TestingHooks = TestingHooks()
    ) {
        self.sessionCoordinator = sessionCoordinator
        self.recorderFactory = recorderFactory
        self.permissionGranted = permissionGranted ?? Self.hasSystemPermission
        self.paddingInterval = paddingInterval
        self.maxRecordingDuration = maxRecordingDuration
        self.outputDirectory = outputDirectory
        self.testingHooks = testingHooks
    }
    // MARK: - Permissions
@@ -42,82 +115,130 @@ actor VoiceRecorder {
    // MARK: - Recording Lifecycle
    @discardableResult
-    func startRecording() throws -> URL {
+    func startRecording(owner: RecordingOwner) async throws -> URL {
-        if recorder?.isRecording == true {
+        if activeOwner != nil {
            throw RecorderError.recordingInProgress
        }
-        #if os(iOS)
+        guard permissionGranted() else {
        let session = AVAudioSession.sharedInstance()
        guard session.recordPermission == .granted else {
            throw RecorderError.microphoneAccessDenied
        }
-        #if targetEnvironment(simulator)
+
-        // allowBluetoothHFP is not available on iOS Simulator
+        activeOwner = owner
-        try session.setCategory(
+        startInFlight = true
-            .playAndRecord,
+
-            mode: .default,
+        // The acquire suspends while the blocking session IPC runs on the
-            options: [.defaultToSpeaker, .allowBluetoothA2DP]
+        // coordinator's queue (never this actor's thread or main).
-        )
+        let token: AudioSessionCoordinator.Token
-        #else
+        do {
-        try session.setCategory(
+            token = try await sessionCoordinator.acquire(.capture) { [weak self] in
-            .playAndRecord,
+                Task { await self?.handleSessionInterruption(for: owner) }
-            mode: .default,
+            }
-            options: [.defaultToSpeaker, .allowBluetoothA2DP, .allowBluetoothHFP]
+        } catch {
-        )
+            guard activeOwner === owner else {
-        #endif
+                throw CancellationError()
-        try session.setActive(true, options: .notifyOthersOnDeactivation)
+            }
-        #endif
+            startInFlight = false
-        #if os(macOS)
+            activeOwner = nil
-        guard AVCaptureDevice.authorizationStatus(for: .audio) == .authorized else {
+            throw error
            throw RecorderError.microphoneAccessDenied
        }
        #endif
-        let outputURL = try makeOutputURL()
+        // Actor reentrancy: release/cancel may have ended this hold while the
-        let settings: [String: Any] = [
+        // blocking session activation was still in progress.
-            AVFormatIDKey: kAudioFormatMPEG4AAC,
+        guard activeOwner === owner, startInFlight else {
-            AVSampleRateKey: 16_000,
+            sessionCoordinator.release(token)
-            AVNumberOfChannelsKey: 1,
+            throw CancellationError()
-            AVEncoderBitRateKey: 16_000
+        }
-        ]
+        startInFlight = false
        sessionToken = token
-        let audioRecorder = try AVAudioRecorder(url: outputURL, settings: settings)
+        var outputURL: URL?
        do {
            let newURL = try makeOutputURL()
            outputURL = newURL
            let audioRecorder = try recorderFactory.makeRecorder(url: newURL)
            audioRecorder.isMeteringEnabled = true
-        audioRecorder.prepareToRecord()
+            guard audioRecorder.prepareToRecord() else {
-        audioRecorder.record(forDuration: maxRecordingDuration)
+                throw RecorderError.failedToStartRecording
            }
            guard audioRecorder.record(forDuration: maxRecordingDuration) else {
                throw RecorderError.failedToStartRecording
            }
            recorder = audioRecorder
-        currentURL = outputURL
+            currentURL = newURL
-        return outputURL
+            return newURL
        } catch {
            releaseSessionToken()
            recorder = nil
            currentURL = nil
            activeOwner = nil
            if let outputURL {
                try? FileManager.default.removeItem(at: outputURL)
            }
            throw error
        }
    }
-    func stopRecording() async -> URL? {
+    func stopRecording(owner: RecordingOwner) async -> URL? {
-        guard let recorder, recorder.isRecording else {
+        guard activeOwner === owner else { return nil }
-            return currentURL
+
        // `finish()` can race a still-suspended start on a direct caller even
        // though the UI normally routes quick releases through cancel().
        if startInFlight {
            activeOwner = nil
            startInFlight = false
            return nil
        }
        guard let activeRecorder = recorder else {
            let sessionURL = currentURL
            releaseSessionToken()
            currentURL = nil
            activeOwner = nil
            return sessionURL
        }
        let sessionURL = currentURL
        if activeRecorder.isRecording, paddingInterval > 0 {
            if let waitForStopPadding = testingHooks.waitForStopPadding {
                await waitForStopPadding(paddingInterval)
            } else {
                try? await Task.sleep(nanoseconds: UInt64(paddingInterval * 1_000_000_000))
            }
        }
-        recorder.stop()
+        // Cancellation or interruption may have run during the padding sleep.
        // Only the recorder whose stop began here may be finalized by it.
        guard activeOwner === owner,
              let recorder = self.recorder,
              recorder === activeRecorder
        else { return nil }
-        // A new session may have started during the sleep — don't touch its state
+        if activeRecorder.isRecording {
-        if self.recorder === recorder {
+            activeRecorder.stop()
-            cleanupSession()
+        }
        releaseSessionToken()
        self.recorder = nil
        currentURL = nil
-        }
+        activeOwner = nil
        return sessionURL
    }
-    func cancelRecording() {
+    func cancelRecording(owner: RecordingOwner) async {
        guard activeOwner === owner else { return }
        // Invalidate ownership before cleanup. An actor-reentrant start whose
        // session acquire resumes later will observe the mismatch and release
        // its token without opening the microphone.
        activeOwner = nil
        startInFlight = false
        if let recorder, recorder.isRecording {
            recorder.stop()
        }
-        cleanupSession()
+        releaseSessionToken()
        if let currentURL {
            try? FileManager.default.removeItem(at: currentURL)
        }
@@ -125,14 +246,45 @@ actor VoiceRecorder {
        currentURL = nil
    }
    /// The audio session was interrupted (call, Siri) or reconfigured: stop
    /// the recorder but keep `recorder`/`currentURL` so the caller's pending
    /// `stopRecording()` still returns the partial note.
    private func handleSessionInterruption(for owner: RecordingOwner) async {
        // A callback captured for a released token must never stop a newer
        // recording. Conversely, an interruption delivered while acquire is
        // still suspended invalidates that acquire before it can open the mic.
        guard activeOwner === owner else { return }
        if startInFlight {
            activeOwner = nil
            startInFlight = false
            return
        }
        startInFlight = false
        if let recorder, recorder.isRecording {
            recorder.stop()
        }
        releaseSessionToken()
    }
    // MARK: - Helpers
    private static func hasSystemPermission() -> Bool {
        #if os(iOS)
        AVAudioSession.sharedInstance().recordPermission == .granted
        #elseif os(macOS)
        AVCaptureDevice.authorizationStatus(for: .audio) == .authorized
        #else
        true
        #endif
    }
    private func makeOutputURL() throws -> URL {
        let formatter = DateFormatter()
        formatter.dateFormat = "yyyyMMdd_HHmmss"
-        let fileName = "voice_\(formatter.string(from: Date())).m4a"
+        let fileName = "voice_\(formatter.string(from: Date()))_\(UUID().uuidString).m4a"
-        let baseDirectory = try applicationFilesDirectory().appendingPathComponent("voicenotes/outgoing", isDirectory: true)
+        let baseDirectory = try outputDirectory
            ?? applicationFilesDirectory().appendingPathComponent("voicenotes/outgoing", isDirectory: true)
        try FileManager.default.createDirectory(at: baseDirectory, withIntermediateDirectories: true, attributes: nil)
        return baseDirectory.appendingPathComponent(fileName)
    }
@@ -147,9 +299,11 @@ actor VoiceRecorder {
        #endif
    }
-    private func cleanupSession() {
+    /// Fire-and-forget: the coordinator hops the blocking deactivation IPC
-        #if os(iOS)
+    /// onto its own queue.
-        try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
+    private func releaseSessionToken() {
-        #endif
+        guard let token = sessionToken else { return }
        sessionToken = nil
        sessionCoordinator.release(token)
    }
 }
@@ -56,12 +56,6 @@ final class WaveformCache {
        }
    }
    func purgeAll() {
        queue.async(flags: .barrier) { [weak self] in
            self?.cache.removeAll()
        }
    }
    private func computeWaveform(url: URL, bins: Int) -> [Float]? {
        guard bins > 0 else { return nil }
        // Use autoreleasepool to manage memory from audio buffer allocations
@@ -88,8 +88,6 @@ import BitFoundation
 /// Represents the ephemeral layer of identity - short-lived peer IDs that provide network privacy.
 /// These IDs rotate periodically to prevent tracking while maintaining cryptographic relationships.
 struct EphemeralIdentity {
    let peerID: PeerID          // 8 random bytes
    let sessionStart: Date
    var handshakeState: HandshakeState
 }
@@ -98,7 +96,6 @@ enum HandshakeState {
    case initiated
    case inProgress
    case completed(fingerprint: String)
    case failed(reason: String)
 }
 /// Represents the cryptographic layer of identity - the stable Noise Protocol static key pair.
@@ -110,7 +107,6 @@ struct CryptographicIdentity: Codable {
    // Optional Ed25519 signing public key (used to authenticate public messages)
    var signingPublicKey: Data? = nil
    let firstSeen: Date
    let lastHandshake: Date?
 }
 /// Represents the social layer of identity - user-assigned names and trust relationships.
@@ -126,11 +122,35 @@ struct SocialIdentity: Codable {
    var notes: String?
 }
 /// Trust ladder: unknown → casual → vouched → trusted → verified.
 ///
 /// Persistence compatibility: `TrustLevel` is stored by its *String* raw
 /// value ("unknown", "casual", …), not by ordinal position, so inserting
 /// `vouched` mid-ladder cannot corrupt previously persisted values — every
 /// pre-existing case keeps the exact raw value it was written with. The
 /// `vouched` tier is additionally never persisted into `SocialIdentity`
 /// (it's recomputed on read from stored vouches), so downgraded builds never
 /// encounter the unfamiliar raw value.
 enum TrustLevel: String, Codable {
-    case unknown = "unknown"
+    case unknown
-    case casual = "casual"
+    case casual
-    case trusted = "trusted"
+    /// Transitively trusted: vouched for by at least one peer *I* verified.
-    case verified = "verified"
+    /// Derived at read time — never written to persistent storage.
    case vouched
    case trusted
    case verified
 }
 // MARK: - Vouching (transitive verification)
 /// One accepted vouch: a peer I verified (the voucher) attested that they
 /// verified the vouchee. Validity is recomputed on read — a record only
 /// counts while its voucher remains in `verifiedFingerprints` and its
 /// timestamp is within `VouchAttestation.maxAge` — so unverifying a voucher
 /// silently invalidates the vouches they gave without a cascade delete.
 struct VouchRecord: Codable, Equatable {
    let voucherFingerprint: String
    let timestamp: Date
 }
 // MARK: - Identity Cache
@@ -155,8 +175,20 @@ struct IdentityCache: Codable {
    // Blocked Nostr pubkeys (lowercased hex) for geohash chats
    var blockedNostrPubkeys: Set<String> = []
-    // Schema version for future migrations
+    // Vouching (transitive verification). All three fields are Optional so
-    var version: Int = 1
+    // caches persisted before this feature decode cleanly — the synthesized
    // decoder uses decodeIfPresent for optionals, and a missing key must not
    // trip the "unreadable cache" recovery path that discards everything.
    // Vouchee fingerprint -> accepted vouches (capped per vouchee)
    var vouchesByVouchee: [String: [VouchRecord]]? = nil
    // Peer fingerprint -> when we last sent them a vouch batch (rate limit)
    var vouchBatchSentAt: [String: Date]? = nil
    // Fingerprint -> when we verified it (orders outgoing vouch batches;
    // entries verified before this field exists sort as oldest)
    var verifiedAt: [String: Date]? = nil
 }
 //
@@ -108,8 +108,6 @@ protocol SecureIdentityStateManagerProtocol {
    func updateSocialIdentity(_ identity: SocialIdentity)
    // MARK: Favorites Management
    func getFavorites() -> Set<String>
    func setFavorite(_ fingerprint: String, isFavorite: Bool)
    func isFavorite(fingerprint: String) -> Bool
    // MARK: Blocked Users Management
@@ -123,7 +121,6 @@ protocol SecureIdentityStateManagerProtocol {
    // MARK: Ephemeral Session Management
    func registerEphemeralSession(peerID: PeerID, handshakeState: HandshakeState)
    func updateHandshakeState(peerID: PeerID, state: HandshakeState)
    // MARK: Cleanup
    func clearAllIdentityData()
@@ -133,6 +130,16 @@ protocol SecureIdentityStateManagerProtocol {
    func setVerified(fingerprint: String, verified: Bool)
    func isVerified(fingerprint: String) -> Bool
    func getVerifiedFingerprints() -> Set<String>
    // MARK: Vouching (transitive verification)
    @discardableResult
    func recordVouch(voucheeFingerprint: String, voucherFingerprint: String, timestamp: Date) -> Bool
    func validVouchers(for fingerprint: String) -> [VouchRecord]
    func isVouched(fingerprint: String) -> Bool
    func lastVouchBatchSent(to fingerprint: String) -> Date?
    func markVouchBatchSent(to fingerprint: String, at date: Date)
    func signingPublicKey(forFingerprint fingerprint: String) -> Data?
    func mostRecentlyVerifiedFingerprints(limit: Int, excluding fingerprint: String) -> [String]
 }
 /// Singleton manager for secure identity state persistence and retrieval.
@@ -311,21 +318,13 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
                        fingerprint: fingerprint,
                        publicKey: noisePublicKey,
                        signingPublicKey: signingPublicKey ?? existing.signingPublicKey,
-                        firstSeen: existing.firstSeen,
+                        firstSeen: existing.firstSeen
                        lastHandshake: now
                    )
                    self.cryptographicIdentities[fingerprint] = existing
                } else {
-                    // Update signing key and lastHandshake
+                    // Update signing key
                    existing.signingPublicKey = signingPublicKey ?? existing.signingPublicKey
-                    let updated = CryptographicIdentity(
+                    self.cryptographicIdentities[fingerprint] = existing
                        fingerprint: existing.fingerprint,
                        publicKey: existing.publicKey,
                        signingPublicKey: existing.signingPublicKey,
                        firstSeen: existing.firstSeen,
                        lastHandshake: now
                    )
                    self.cryptographicIdentities[fingerprint] = updated
                }
                // Persist updated state (already assigned in branches above)
            } else {
@@ -334,8 +333,7 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
                    fingerprint: fingerprint,
                    publicKey: noisePublicKey,
                    signingPublicKey: signingPublicKey,
-                    firstSeen: now,
+                    firstSeen: now
                    lastHandshake: now
                )
                self.cryptographicIdentities[fingerprint] = entry
            }
@@ -500,11 +498,7 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
    func registerEphemeralSession(peerID: PeerID, handshakeState: HandshakeState = .none) {
        queue.async(flags: .barrier) {
-            self.ephemeralSessions[peerID] = EphemeralIdentity(
+            self.ephemeralSessions[peerID] = EphemeralIdentity(handshakeState: handshakeState)
                peerID: peerID,
                sessionStart: Date(),
                handshakeState: handshakeState
            )
        }
    }
@@ -550,8 +544,12 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
        queue.async(flags: .barrier) {
            if verified {
                self.cache.verifiedFingerprints.insert(fingerprint)
                var verifiedAt = self.cache.verifiedAt ?? [:]
                verifiedAt[fingerprint] = Date()
                self.cache.verifiedAt = verifiedAt
            } else {
                self.cache.verifiedFingerprints.remove(fingerprint)
                self.cache.verifiedAt?.removeValue(forKey: fingerprint)
            }
            // Update trust level if social identity exists
@@ -576,6 +574,159 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
        }
    }
    // MARK: - Vouching (transitive verification)
    /// Maximum vouchers retained per vouchee (most recent kept).
    static let maxVouchersPerVouchee = 8
    /// Records an accepted vouch, enforcing every accept-policy gate that can
    /// be evaluated against stored state (signature verification is the
    /// caller's job — it needs the sender's announce-bound signing key):
    /// - the voucher must be a fingerprint *I* verified
    /// - self-vouches are ignored
    /// - vouches for peers I already verified are ignored (nothing to add)
    /// - attestations outside the validity window are ignored
    /// - at most `maxVouchersPerVouchee` vouchers are kept per vouchee
    ///
    /// Returns true when the vouch was stored (or refreshed).
    @discardableResult
    func recordVouch(voucheeFingerprint: String, voucherFingerprint: String, timestamp: Date) -> Bool {
        recordVouch(
            voucheeFingerprint: voucheeFingerprint,
            voucherFingerprint: voucherFingerprint,
            timestamp: timestamp,
            now: Date()
        )
    }
    @discardableResult
    func recordVouch(voucheeFingerprint: String, voucherFingerprint: String, timestamp: Date, now: Date) -> Bool {
        queue.sync(flags: .barrier) {
            guard voucheeFingerprint != voucherFingerprint,
                  self.cache.verifiedFingerprints.contains(voucherFingerprint),
                  !self.cache.verifiedFingerprints.contains(voucheeFingerprint) else {
                return false
            }
            let age = now.timeIntervalSince(timestamp)
            guard age <= VouchAttestation.maxAge, age >= -VouchAttestation.maxClockSkew else {
                return false
            }
            var records = self.cache.vouchesByVouchee?[voucheeFingerprint] ?? []
            if let index = records.firstIndex(where: { $0.voucherFingerprint == voucherFingerprint }) {
                let newest = max(records[index].timestamp, timestamp)
                records[index] = VouchRecord(voucherFingerprint: voucherFingerprint, timestamp: newest)
            } else {
                records.append(VouchRecord(voucherFingerprint: voucherFingerprint, timestamp: timestamp))
            }
            // Keep the most recent vouchers up to the cap.
            records.sort { $0.timestamp > $1.timestamp }
            let capped = Array(records.prefix(Self.maxVouchersPerVouchee))
            guard capped.contains(where: { $0.voucherFingerprint == voucherFingerprint }) else {
                return false // Full of fresher vouches; nothing changed.
            }
            var vouches = self.cache.vouchesByVouchee ?? [:]
            vouches[voucheeFingerprint] = capped
            self.cache.vouchesByVouchee = vouches
            self.saveIdentityCache()
            return true
        }
    }
    /// The vouches that currently count for `fingerprint`. Validity is
    /// recomputed here rather than maintained by cascade deletes: a record
    /// only counts while its voucher is still verified-by-me and its
    /// timestamp is within the expiry window.
    func validVouchers(for fingerprint: String) -> [VouchRecord] {
        validVouchers(for: fingerprint, now: Date())
    }
    func validVouchers(for fingerprint: String, now: Date) -> [VouchRecord] {
        queue.sync {
            self.validVouchersLocked(for: fingerprint, now: now)
        }
    }
    /// Requires `queue`.
    private func validVouchersLocked(for fingerprint: String, now: Date) -> [VouchRecord] {
        guard let records = cache.vouchesByVouchee?[fingerprint] else { return [] }
        return records.filter { record in
            record.voucherFingerprint != fingerprint
                && cache.verifiedFingerprints.contains(record.voucherFingerprint)
                && now.timeIntervalSince(record.timestamp) <= VouchAttestation.maxAge
        }
    }
    /// True when the peer has at least one valid vouch and no explicit
    /// verification of ours.
    func isVouched(fingerprint: String) -> Bool {
        isVouched(fingerprint: fingerprint, now: Date())
    }
    func isVouched(fingerprint: String, now: Date) -> Bool {
        queue.sync {
            guard !self.cache.verifiedFingerprints.contains(fingerprint) else { return false }
            return !self.validVouchersLocked(for: fingerprint, now: now).isEmpty
        }
    }
    /// The trust level to display: explicit verification wins, then the
    /// persisted level, with `vouched` layered in (derived, never persisted)
    /// between `casual` and `trusted`.
    func effectiveTrustLevel(for fingerprint: String) -> TrustLevel {
        effectiveTrustLevel(for: fingerprint, now: Date())
    }
    func effectiveTrustLevel(for fingerprint: String, now: Date) -> TrustLevel {
        queue.sync {
            if self.cache.verifiedFingerprints.contains(fingerprint) { return .verified }
            let stored = self.cache.socialIdentities[fingerprint]?.trustLevel ?? .unknown
            let vouched = !self.validVouchersLocked(for: fingerprint, now: now).isEmpty
            switch stored {
            case .verified, .trusted:
                return stored
            case .vouched, .casual, .unknown:
                if vouched { return .vouched }
                // `.vouched` should never be persisted; degrade defensively.
                return stored == .vouched ? .casual : stored
            }
        }
    }
    func lastVouchBatchSent(to fingerprint: String) -> Date? {
        queue.sync { cache.vouchBatchSentAt?[fingerprint] }
    }
    func markVouchBatchSent(to fingerprint: String, at date: Date) {
        queue.async(flags: .barrier) {
            var sentAt = self.cache.vouchBatchSentAt ?? [:]
            sentAt[fingerprint] = date
            self.cache.vouchBatchSentAt = sentAt
            self.saveIdentityCache()
        }
    }
    /// The peer's announce-bound Ed25519 signing key, if seen this session.
    func signingPublicKey(forFingerprint fingerprint: String) -> Data? {
        queue.sync { cryptographicIdentities[fingerprint]?.signingPublicKey }
    }
    /// Verified fingerprints ordered most recently verified first (entries
    /// without a recorded verification time sort last), excluding the given
    /// fingerprint. Feeds the outgoing vouch batch.
    func mostRecentlyVerifiedFingerprints(limit: Int, excluding fingerprint: String) -> [String] {
        queue.sync {
            let verifiedAt = cache.verifiedAt ?? [:]
            let ordered = cache.verifiedFingerprints
                .filter { $0 != fingerprint }
                .sorted {
                    (verifiedAt[$0] ?? .distantPast, $0) > (verifiedAt[$1] ?? .distantPast, $1)
                }
            return Array(ordered.prefix(limit))
        }
    }
    var debugNicknameIndex: [String: Set<String>] {
        queue.sync { cache.nicknameIndex }
    }
@@ -31,6 +31,8 @@
 	</array>
 	<key>CFBundleVersion</key>
 	<string>$(CURRENT_PROJECT_VERSION)</string>
 	<key>LSApplicationCategoryType</key>
 	<string>public.app-category.social-networking</string>
 	<key>LSMinimumSystemVersion</key>
 	<string>$(MACOSX_DEPLOYMENT_TARGET)</string>
 	<key>NSBluetoothAlwaysUsageDescription</key>
@@ -40,9 +42,9 @@
 	<key>NSCameraUsageDescription</key>
 	<string>bitchat uses the camera to scan QR codes to verify peers.</string>
 	<key>NSLocationWhenInUseUsageDescription</key>
-	<string>bitchat uses your approximate location to compute local geohash channels for optional public chats. Exact GPS is never shared.</string>
+	<string>bitchat uses your location to compute optional geohash channels, bridge cells, and nearby place labels. Exact coordinates are not included in bitchat messages.</string>
 	<key>NSMicrophoneUsageDescription</key>
-	<string>bitchat uses the microphone to record voice notes that relay across the mesh.</string>
+	<string>bitchat uses the microphone while you record voice notes or hold live push-to-talk, then sends that audio to your selected mesh conversation.</string>
 	<key>NSPhotoLibraryUsageDescription</key>
 	<string>bitchat lets you pick images from your photo library to share with nearby peers.</string>
 	<key>UIBackgroundModes</key>
@@ -13,13 +13,6 @@ extension BitchatMessage {
    enum Media {
        case voice(URL)
        case image(URL)
        var url: URL {
            switch self {
            case .voice(let url), .image(let url):
                return url
            }
        }
    }
    // Cache the directory lookup to avoid repeated FileManager calls during view rendering
@@ -7,7 +7,6 @@ struct BitchatPeer: Equatable {
    let peerID: PeerID // Hex-encoded peer ID
    let noisePublicKey: Data
    let nickname: String
    let lastSeen: Date
    let isConnected: Bool
    let isReachable: Bool
@@ -77,14 +76,13 @@ struct BitchatPeer: Equatable {
        peerID: PeerID,
        noisePublicKey: Data,
        nickname: String,
-        lastSeen: Date = Date(),
+        lastSeen _: Date = Date(),
        isConnected: Bool = false,
        isReachable: Bool = false
    ) {
        self.peerID = peerID
        self.noisePublicKey = noisePublicKey
        self.nickname = nickname
        self.lastSeen = lastSeen
        self.isConnected = isConnected
        self.isReachable = isReachable
@@ -11,15 +11,24 @@ import Foundation
 // MARK: - CommandInfo Enum
 enum CommandInfo: String, Identifiable {
    // Raw values must match the aliases CommandProcessor actually accepts —
    // the suggestion panel is the app's only command-discovery surface, and
    // suggesting a spelling the processor rejects teaches users dead ends.
    case block
    case clear
    case group
    case help
    case hug
-    case message = "dm"
+    case message = "msg"
    case slap
    case pay
    case unblock
    case who
-    case favorite
+    case favorite = "fav"
-    case unfavorite
+    case unfavorite = "unfav"
    case ping
    case trace
    case drop
    var id: String { rawValue }
@@ -27,9 +36,15 @@ enum CommandInfo: String, Identifiable {
    var placeholder: String? {
        switch self {
-        case .block, .hug, .message, .slap, .unblock, .favorite, .unfavorite:
+        case .block, .hug, .message, .slap, .unblock, .favorite, .unfavorite, .ping, .trace:
            return "<" + String(localized: "content.input.nickname_placeholder") + ">"
-        case .clear, .who:
+        case .group:
            return "<" + String(localized: "content.input.group_placeholder") + ">"
        case .pay:
            return "<" + String(localized: "content.input.token_placeholder") + ">"
        case .drop:
            return "<" + String(localized: "content.input.note_placeholder") + ">"
        case .clear, .help, .who:
            return nil
        }
    }
@@ -38,21 +53,36 @@ enum CommandInfo: String, Identifiable {
        switch self {
        case .block:        String(localized: "content.commands.block")
        case .clear:        String(localized: "content.commands.clear")
        case .group:        String(localized: "content.commands.group")
        case .help:         String(localized: "content.commands.help")
        case .hug:          String(localized: "content.commands.hug")
        case .message:      String(localized: "content.commands.message")
        case .pay:          String(localized: "content.commands.pay")
        case .slap:         String(localized: "content.commands.slap")
        case .unblock:      String(localized: "content.commands.unblock")
        case .who:          String(localized: "content.commands.who")
        case .favorite:     String(localized: "content.commands.favorite")
        case .unfavorite:   String(localized: "content.commands.unfavorite")
        case .ping:         String(localized: "content.commands.ping")
        case .trace:        String(localized: "content.commands.trace")
        case .drop:         String(localized: "content.commands.drop")
        }
    }
    static func all(isGeoPublic: Bool, isGeoDM: Bool) -> [CommandInfo] {
-        let baseCommands: [CommandInfo] = [.block, .unblock, .clear, .hug, .message, .slap, .who]
+        var commands: [CommandInfo] = [.block, .unblock, .clear, .drop, .help, .hug, .message, .slap, .who]
-        if isGeoPublic || isGeoDM {
+        // Cashu tokens are bearer instruments: in a public geohash any nearby
-            return baseCommands + [.favorite, .unfavorite]
+        // stranger can redeem one, so don't *suggest* /pay there (the
        // processor still allows it behind an explicit "public" confirm).
        // Payments make sense in every DM and in mesh public.
        if !isGeoPublic {
            commands.append(.pay)
        }
-        return baseCommands
+        // The processor rejects favorites, groups, and mesh diagnostics in
        // geohash contexts, so only suggest them where they work: mesh.
        if isGeoPublic || isGeoDM {
            return commands
        }
        return commands + [.favorite, .unfavorite, .ping, .trace, .group]
    }
 }
@@ -1,10 +1,21 @@
 import BitFoundation
 import Foundation
 // REQUEST_SYNC payload TLV (type, length16, value)
 //  - 0x01: P (uint8) — Golomb-Rice parameter
 //  - 0x02: M (uint32, big-endian) — hash range (N * 2^P)
 //  - 0x03: data (opaque) — GR bitstream bytes (MSB-first)
 //  - 0x04: types (SyncTypeFlags) — packet types the filter covers
 //  - 0x05: sinceTimestamp (uint64, big-endian) — filter coverage cursor
 //  - 0x06: fragmentIdFilter (UTF-8) — comma-separated 16-hex-char (8-byte)
 //          fragment stream IDs; restricts the fragment diff to exactly those
 //          streams (targeted resync for stalled reassemblies)
 struct RequestSyncPacket {
    /// Maximum fragment IDs one 0x06 filter may carry. Each ID encodes as
    /// 16 hex chars plus a comma separator, so the largest encoded value is
    /// 60 * 17 - 1 = 1019 bytes, which fits the 1024-byte decoder cap.
    static let maxFragmentIdFilterCount = 60
    let p: Int
    let m: UInt32
    let data: Data
@@ -12,6 +23,29 @@ struct RequestSyncPacket {
    let sinceTimestamp: UInt64?
    let fragmentIdFilter: String?
    /// Encodes 8-byte fragment stream IDs as the 0x06 filter string,
    /// dropping malformed IDs and capping at `maxFragmentIdFilterCount`.
    static func encodeFragmentIdFilter(_ fragmentIDs: [Data]) -> String? {
        let tokens = fragmentIDs
            .filter { $0.count == 8 }
            .prefix(maxFragmentIdFilterCount)
            .map { $0.hexEncodedString() }
        guard !tokens.isEmpty else { return nil }
        return tokens.joined(separator: ",")
    }
    /// Decodes a 0x06 filter string back into 8-byte fragment stream IDs,
    /// ignoring malformed tokens and capping at `maxFragmentIdFilterCount`.
    static func decodeFragmentIdFilter(_ filter: String?) -> Set<Data>? {
        guard let filter else { return nil }
        var ids: Set<Data> = []
        for token in filter.split(separator: ",").prefix(maxFragmentIdFilterCount) {
            guard token.count == 16, let id = Data(hexString: String(token)) else { continue }
            ids.insert(id)
        }
        return ids.isEmpty ? nil : ids
    }
    init(p: Int, m: UInt32, data: Data, types: SyncTypeFlags? = nil, sinceTimestamp: UInt64? = nil, fragmentIdFilter: String? = nil) {
        self.p = p
        self.m = m
@@ -88,7 +122,9 @@ struct RequestSyncPacket {
                    sinceTimestamp = ts
                }
            case 0x06:
-                if let fid = String(data: v, encoding: .utf8) {
+                // Same acceptance cap as the GCS payload; an oversized filter
                // is ignored rather than failing the whole request.
                if v.count <= maxAcceptBytes, let fid = String(data: v, encoding: .utf8) {
                    fragmentIdFilter = fid
                }
            default:
@@ -93,6 +93,7 @@ enum NoisePattern {
    case XX  // Most versatile, mutual authentication
    case IK  // Initiator knows responder's static key
    case NK  // Anonymous initiator
    case X   // One-way: single message to a known static key (no response)
 }
 enum NoiseRole {
@@ -601,7 +602,7 @@ final class NoiseHandshakeState {
        switch pattern {
        case .XX:
            break // No pre-message keys
-        case .IK, .NK:
+        case .IK, .NK, .X:
            if role == .initiator, let remoteStatic = remoteStaticPublic {
                symmetricState.mixHash(remoteStatic.rawRepresentation)
            } else if role == .responder, let localStatic = localStaticPublic {
@@ -722,7 +723,7 @@ final class NoiseHandshakeState {
        return messageBuffer
    }
-    func readMessage(_ message: Data, expectedPayloadLength: Int = 0) throws -> Data {
+    func readMessage(_ message: Data, expectedPayloadLength _: Int = 0) throws -> Data {
        guard currentPattern < messagePatterns.count else {
            throw NoiseError.handshakeComplete
@@ -904,6 +905,7 @@ extension NoisePattern {
        case .XX: return "XX"
        case .IK: return "IK"
        case .NK: return "NK"
        case .X: return "X"
        }
    }
@@ -925,6 +927,10 @@ extension NoisePattern {
                [.e, .es],      // -> e, es
                [.e, .ee]       // <- e, ee
            ]
        case .X:
            return [
                [.e, .es, .s, .ss] // -> e, es, s, ss (single one-way message)
            ]
        }
    }
 }
@@ -21,12 +21,6 @@ enum NoiseSecurityConstants {
    // Maximum number of messages before rekey (2^64 - 1 is the nonce limit)
    static let maxMessagesPerSession: UInt64 = 1_000_000_000 // 1 billion messages
    // Handshake timeout - abandon incomplete handshakes
    static let handshakeTimeout: TimeInterval = 60 // 1 minute
    // Maximum concurrent sessions per peer
    static let maxSessionsPerPeer = 3
    // Rate limiting
    static let maxHandshakesPerMinute = 10
    static let maxMessagesPerSecond = 100
@@ -14,5 +14,4 @@ enum NoiseSecurityError: Error {
    case messageTooLarge
    case invalidPeerID
    case rateLimitExceeded
    case handshakeTimeout
 }
@@ -13,8 +13,6 @@ import BitFoundation
 final class NoiseSessionManager {
    private var sessions: [PeerID: NoiseSession] = [:]
    private let localStaticKey: Curve25519.KeyAgreement.PrivateKey
    private let keychain: KeychainManagerProtocol
    private let sessionFactory: (PeerID, NoiseRole) -> NoiseSession
    private let managerQueue = DispatchQueue(label: "chat.bitchat.noise.manager", attributes: .concurrent)
@@ -23,8 +21,6 @@ final class NoiseSessionManager {
    var onSessionFailed: ((PeerID, Error) -> Void)?
    init(localStaticKey: Curve25519.KeyAgreement.PrivateKey, keychain: KeychainManagerProtocol) {
        self.localStaticKey = localStaticKey
        self.keychain = keychain
        self.sessionFactory = { peerID, role in
            SecureNoiseSession(
                peerID: peerID,
@@ -37,12 +33,10 @@ final class NoiseSessionManager {
    #if DEBUG
    init(
-        localStaticKey: Curve25519.KeyAgreement.PrivateKey,
+        localStaticKey _: Curve25519.KeyAgreement.PrivateKey,
-        keychain: KeychainManagerProtocol,
+        keychain _: KeychainManagerProtocol,
        sessionFactory: @escaping (PeerID, NoiseRole) -> NoiseSession
    ) {
        self.localStaticKey = localStaticKey
        self.keychain = keychain
        self.sessionFactory = sessionFactory
    }
    #endif
@@ -6,14 +6,12 @@ struct NostrIdentity: Codable {
    let privateKey: Data
    let publicKey: Data
    let npub: String // Bech32-encoded public key
    let createdAt: Date
    /// Memberwise initializer
-    init(privateKey: Data, publicKey: Data, npub: String, createdAt: Date) {
+    init(privateKey: Data, publicKey: Data, npub: String, createdAt _: Date) {
        self.privateKey = privateKey
        self.publicKey = publicKey
        self.npub = npub
        self.createdAt = createdAt
    }
    /// Generate a new Nostr identity
@@ -39,12 +37,6 @@ struct NostrIdentity: Codable {
        self.privateKey = privateKeyData
        self.publicKey = xOnlyPubkey
        self.npub = try Bech32.encode(hrp: "npub", data: xOnlyPubkey)
        self.createdAt = Date()
    }
    /// Get signing key for event signatures
    func signingKey() throws -> P256K.Signing.PrivateKey {
        try P256K.Signing.PrivateKey(dataRepresentation: privateKey)
    }
    /// Get Schnorr signing key for Nostr event signatures
@@ -15,7 +15,7 @@ final class NostrIdentityBridge {
    private let keychain: KeychainManagerProtocol
-    init(keychain: KeychainManagerProtocol = KeychainManager()) {
+    init(keychain: KeychainManagerProtocol = KeychainManager.makeDefault()) {
        self.keychain = keychain
    }
@@ -37,14 +37,6 @@ final class NostrIdentityBridge {
        return nostrIdentity
    }
    /// Associate a Nostr identity with a Noise public key (for favorites)
    func associateNostrIdentity(_ nostrPubkey: String, with noisePublicKey: Data) {
        let key = "nostr-noise-\(noisePublicKey.base64EncodedString())"
        if let data = nostrPubkey.data(using: .utf8) {
            keychain.save(key: key, data: data, service: keychainService, accessible: nil)
        }
    }
    /// Get Nostr public key associated with a Noise public key
    func getNostrPublicKey(for noisePublicKey: Data) -> String? {
        let key = "nostr-noise-\(noisePublicKey.base64EncodedString())"
@@ -57,29 +49,10 @@ final class NostrIdentityBridge {
    /// Clear all Nostr identity associations and current identity
    func clearAllAssociations() {
-        let query: [String: Any] = [
+        // Must go through the injected keychain, not raw SecItem calls:
-            kSecClass as String: kSecClassGenericPassword,
+        // under test that keychain is in-memory, and a direct delete here
-            kSecAttrService as String: keychainService,
+        // would wipe the developer's real Nostr identity on every test run.
-            kSecMatchLimit as String: kSecMatchLimitAll,
+        keychain.deleteAll(service: keychainService)
            kSecReturnAttributes as String: true
        ]
        var result: AnyObject?
        let status = SecItemCopyMatching(query as CFDictionary, &result)
        if status == errSecSuccess, let items = result as? [[String: Any]] {
            for item in items {
                var deleteQuery: [String: Any] = [
                    kSecClass as String: kSecClassGenericPassword,
                    kSecAttrService as String: keychainService
                ]
                if let account = item[kSecAttrAccount as String] as? String {
                    deleteQuery[kSecAttrAccount as String] = account
                }
                SecItemDelete(deleteQuery as CFDictionary)
            }
        } else if status == errSecItemNotFound {
            // nothing persisted; no action needed
        }
        deviceSeedCache = nil
        // Also drop the in-memory derived per-geohash identities. These hold the
@@ -113,6 +86,13 @@ final class NostrIdentityBridge {
        return seed
    }
    /// Derive a deterministic, unlinkable Nostr identity for a mesh-bridge
    /// rendezvous cell. Distinct HMAC label keeps it unlinkable from the
    /// geohash-chat identity for the same cell string.
    func deriveIdentity(forBridgeRendezvous cell: String) throws -> NostrIdentity {
        try deriveIdentity(forGeohash: "bridge|" + cell)
    }
    /// Derive a deterministic, unlinkable Nostr identity for a given geohash.
    /// Uses HMAC-SHA256(deviceSeed, geohash) as private key material, with fallback rehashing
    /// if the candidate is not a valid secp256k1 private key.
@@ -0,0 +1,215 @@
 import BitFoundation
 import CryptoKit
 import Foundation
 /// NIP-13 proof-of-work for Nostr events.
 ///
 /// Outgoing kind-20000 geohash messages mine a `["nonce", "<value>", "<target>"]`
 /// tag so the event ID carries at least `target` leading zero bits. Inbound
 /// events are scored (never hard-rejected — the network has clients that do
 /// not mine): validated PoW at or above `rateLimitBypassBits` relaxes the
 /// per-sender public rate limit, everything else keeps the strict limits.
 enum NostrPoW {
    // MARK: - Tuning
    /// Difficulty (leading zero bits of the event ID) mined onto outgoing
    /// geohash messages. 8 bits is ~256 hash attempts — typically well under
    /// 100 ms on any supported device.
    static let targetBits = 8
    /// Inbound events whose validated NIP-13 difficulty is at least this many
    /// bits skip the per-sender rate-limit bucket (the content-flood bucket
    /// still applies). See `MessageRateLimiter.allow`.
    static let rateLimitBypassBits = 8
    /// Hard cap on mining wall-clock time. When it hits, the committed target
    /// steps down until a difficulty reachable in a small extra budget is
    /// found and the message is sent anyway — mining never blocks sending.
    static let miningTimeCap: TimeInterval = 2.0
    /// Budget for each stepped-down attempt after the main cap (or a task
    /// cancellation) hits.
    private static let fallbackTimeCap: TimeInterval = 0.15
    /// The hot loop checks the deadline and task cancellation every this many
    /// hash attempts.
    private static let checkInterval: UInt64 = 1024
    /// The nonce value is a fixed-width hex counter so the serialized event
    /// template can be mutated in place without reallocation.
    private static let nonceLength = 16
    // MARK: - Scoring
    /// Number of leading zero bits in a byte sequence (NIP-13 difficulty of
    /// an event-ID hash).
    static func leadingZeroBits<Bytes: Sequence<UInt8>>(_ bytes: Bytes) -> Int {
        var total = 0
        for byte in bytes {
            if byte == 0 {
                total += 8
            } else {
                total += byte.leadingZeroBitCount
                break
            }
        }
        return total
    }
    /// Validated NIP-13 difficulty of an inbound event.
    ///
    /// The committed target in the nonce tag is what counts: the actual
    /// leading zero bits of the ID must meet it (otherwise the claim is void
    /// and the event scores 0), and work beyond the commitment earns no extra
    /// credit — this stops spammers who mine a low target from getting lucky
    /// high scores. Events without a well-formed commitment score 0.
    static func validatedDifficulty(idHex: String, tags: [[String]]) -> Int {
        guard let nonceTag = tags.last(where: { $0.first == "nonce" }),
              nonceTag.count >= 3,
              let committed = Int(nonceTag[2]),
              committed > 0, committed <= 256,
              let idData = Data(hexString: idHex)
        else {
            return 0
        }
        return leadingZeroBits(idData) >= committed ? committed : 0
    }
    // MARK: - Mining
    /// Mine a `["nonce", value, target]` tag for the given unsigned-event
    /// fields. Nonisolated async: runs off the calling actor.
    ///
    /// Bounded by `miningTimeCap`: when the cap hits — or the surrounding
    /// task is cancelled — the committed target steps down (halving to 0,
    /// which any hash satisfies) so the event still ships promptly with an
    /// honest commitment at the difficulty actually reached. Returns nil only
    /// if canonical serialization fails; the caller then sends unmined.
    static func mineNonceTag(
        pubkey: String,
        createdAt: Int,
        kind: Int,
        tags: [[String]],
        content: String,
        targetBits: Int = NostrPoW.targetBits
    ) async -> [String]? {
        var target = min(max(targetBits, 0), 256)
        var budget = miningTimeCap
        while true {
            if let tag = mineAttempt(
                pubkey: pubkey,
                createdAt: createdAt,
                kind: kind,
                baseTags: tags,
                content: content,
                targetBits: target,
                budget: budget
            ) {
                return tag
            }
            // Target 0 succeeds on the first hash, so reaching it with nil
            // means serialization itself failed — give up on mining.
            if target == 0 { return nil }
            target /= 2
            budget = fallbackTimeCap
        }
    }
    /// One bounded mining pass at a fixed committed target. Allocation-light:
    /// the canonical serialization is built once and only the fixed-width
    /// nonce bytes are rewritten per attempt (the event ID is recomputed for
    /// every attempt, per NIP-13). Returns nil on timeout/cancellation or if
    /// the template could not be built.
    private static func mineAttempt(
        pubkey: String,
        createdAt: Int,
        kind: Int,
        baseTags: [[String]],
        content: String,
        targetBits: Int,
        budget: TimeInterval
    ) -> [String]? {
        let targetString = String(targetBits)
        guard let template = serializedTemplate(
            pubkey: pubkey,
            createdAt: createdAt,
            kind: kind,
            baseTags: baseTags,
            content: content,
            targetString: targetString
        ) else {
            return nil
        }
        var buffer = template.buffer
        let nonceRange = template.nonceRange
        let deadline = DispatchTime.now().uptimeNanoseconds &+ UInt64(budget * 1_000_000_000)
        let hexDigits = [UInt8]("0123456789abcdef".utf8)
        var nonce = UInt64.random(in: .min ... .max)
        var attempts: UInt64 = 0
        while true {
            // Write the nonce as 16 lowercase hex chars, in place.
            var value = nonce
            var index = nonceRange.upperBound
            while index > nonceRange.lowerBound {
                index -= 1
                buffer[index] = hexDigits[Int(value & 0xF)]
                value >>= 4
            }
            if leadingZeroBits(SHA256.hash(data: buffer)) >= targetBits {
                // Identical to the bytes just written into the buffer.
                return ["nonce", String(format: "%016llx", nonce), targetString]
            }
            nonce &+= 1
            attempts &+= 1
            if attempts % checkInterval == 0,
               Task.isCancelled || DispatchTime.now().uptimeNanoseconds >= deadline {
                return nil
            }
        }
    }
    /// Canonical NIP-01 serialization of the event with a placeholder nonce,
    /// plus the byte range of the nonce value inside it.
    ///
    /// The range is located by serializing twice with two same-length
    /// placeholders and diffing the buffers — the only differing bytes are
    /// the nonce value, so this stays correct however `JSONSerialization`
    /// escapes the surrounding fields (and even if the content contains the
    /// placeholder text itself).
    private static func serializedTemplate(
        pubkey: String,
        createdAt: Int,
        kind: Int,
        baseTags: [[String]],
        content: String,
        targetString: String
    ) -> (buffer: Data, nonceRange: Range<Int>)? {
        func serialize(noncePlaceholder: String) -> Data? {
            var tags = baseTags
            tags.append(["nonce", noncePlaceholder, targetString])
            let serialized: [Any] = [0, pubkey, createdAt, kind, tags, content]
            return try? JSONSerialization.data(withJSONObject: serialized, options: [.withoutEscapingSlashes])
        }
        guard let zeros = serialize(noncePlaceholder: String(repeating: "0", count: nonceLength)),
              let effs = serialize(noncePlaceholder: String(repeating: "f", count: nonceLength)),
              zeros.count == effs.count
        else {
            return nil
        }
        var firstDiff = -1
        var lastDiff = -1
        for index in 0..<zeros.count where zeros[index] != effs[index] {
            if firstDiff < 0 { firstDiff = index }
            lastDiff = index
        }
        guard firstDiff >= 0, lastDiff - firstDiff + 1 == nonceLength else { return nil }
        return (zeros, firstDiff..<(firstDiff + nonceLength))
    }
 }
@@ -19,6 +19,11 @@ struct NostrProtocol {
        case giftWrap = 1059 // NIP-59 gift wrap
        case ephemeralEvent = 20000
        case geohashPresence = 20001
        case deletion = 5 // NIP-09 event deletion request
        /// Sealed courier envelope parked on relays under its rotating
        /// recipient tag (`#x`). Regular (stored) kind so it survives until
        /// its NIP-40 expiration — the whole point is store-and-forward.
        case courierDrop = 1401
    }
    /// Create a NIP-17 private message
@@ -170,6 +175,63 @@ struct NostrProtocol {
        nickname: String? = nil,
        teleported: Bool = false
    ) throws -> NostrEvent {
        let event = NostrEvent(
            pubkey: senderIdentity.publicKeyHex,
            createdAt: Date(),
            kind: .ephemeralEvent,
            tags: ephemeralGeohashTags(geohash: geohash, nickname: nickname, teleported: teleported),
            content: content
        )
        let schnorrKey = try senderIdentity.schnorrSigningKey()
        return try event.sign(with: schnorrKey)
    }
    /// Create a kind-20000 geohash message carrying a NIP-13 proof-of-work
    /// nonce tag (see `NostrPoW`). Mining runs off the calling actor and is
    /// bounded by `NostrPoW.miningTimeCap`; when the cap hits (or the
    /// surrounding task is cancelled) the event ships at the highest
    /// committed difficulty still met, and if mining is impossible it ships
    /// unmined — sending is never blocked.
    static func createMinedEphemeralGeohashEvent(
        content: String,
        geohash: String,
        senderIdentity: NostrIdentity,
        nickname: String? = nil,
        teleported: Bool = false,
        powTargetBits: Int = NostrPoW.targetBits
    ) async throws -> NostrEvent {
        var tags = ephemeralGeohashTags(geohash: geohash, nickname: nickname, teleported: teleported)
        // Fix created_at up front: the mined nonce commits to the full
        // serialized event, so the signed event must reuse the exact value.
        let createdAt = Int(Date().timeIntervalSince1970)
        if let nonceTag = await NostrPoW.mineNonceTag(
            pubkey: senderIdentity.publicKeyHex,
            createdAt: createdAt,
            kind: EventKind.ephemeralEvent.rawValue,
            tags: tags,
            content: content,
            targetBits: powTargetBits
        ) {
            tags.append(nonceTag)
        }
        let event = NostrEvent(
            pubkey: senderIdentity.publicKeyHex,
            createdAt: Date(timeIntervalSince1970: TimeInterval(createdAt)),
            kind: .ephemeralEvent,
            tags: tags,
            content: content
        )
        let schnorrKey = try senderIdentity.schnorrSigningKey()
        return try event.sign(with: schnorrKey)
    }
    /// Tags for a kind-20000 geohash message (shared by the plain and mined
    /// variants).
    private static func ephemeralGeohashTags(
        geohash: String,
        nickname: String?,
        teleported: Bool
    ) -> [[String]] {
        var tags = [["g", geohash]]
        if let nickname = nickname?.trimmedOrNilIfEmpty {
            tags.append(["n", nickname])
@@ -177,15 +239,7 @@ struct NostrProtocol {
        if teleported {
            tags.append(["t", "teleport"])
        }
-        let event = NostrEvent(
+        return tags
            pubkey: senderIdentity.publicKeyHex,
            createdAt: Date(),
            kind: .ephemeralEvent,
            tags: tags,
            content: content
        )
        let schnorrKey = try senderIdentity.schnorrSigningKey()
        return try event.sign(with: schnorrKey)
    }
    /// Create a geohash presence heartbeat (kind 20001)
@@ -206,17 +260,115 @@ struct NostrProtocol {
        return try event.sign(with: schnorrKey)
    }
    // MARK: - Mesh bridge (rendezvous) events
    /// Create a mesh-bridge public message (kind 20000) for a geohash-cell
    /// rendezvous. The distinct `r` tag keeps bridge traffic out of geohash
    /// channel subscriptions (which filter on `#g`); `m` is
    /// `[stable ID, mesh sender ID, wire timestamp in ms]`. Element 1 is the
    /// content-stable mesh message ID (`MeshMessageIdentity`) for v1.7.0
    /// parsers, which key their dedup on `m[1]` unconditionally and need it
    /// per-message-unique. Current parsers key bridge rows by the authenticated
    /// event ID and recompute elements 2-3 only as a radio-copy hint; the mesh
    /// coordinates are public and cannot authenticate the Nostr signer.
    static func createBridgeMeshEvent(
        content: String,
        cell: String,
        senderIdentity: NostrIdentity,
        nickname: String? = nil,
        meshSenderID: String? = nil,
        meshTimestampMs: UInt64? = nil
    ) throws -> NostrEvent {
        var tags = [["r", cell]]
        if let nickname = nickname?.trimmedOrNilIfEmpty {
            tags.append(["n", nickname])
        }
        if let meshSenderID = meshSenderID?.trimmedOrNilIfEmpty, let meshTimestampMs {
            let stableID = MeshMessageIdentity.stableID(
                senderIDHex: meshSenderID,
                timestampMs: meshTimestampMs,
                content: content
            )
            tags.append(["m", stableID, meshSenderID, String(meshTimestampMs)])
        }
        let event = NostrEvent(
            pubkey: senderIdentity.publicKeyHex,
            createdAt: Date(),
            kind: .ephemeralEvent,
            tags: tags,
            content: content
        )
        let schnorrKey = try senderIdentity.schnorrSigningKey()
        return try event.sign(with: schnorrKey)
    }
    /// Create a mesh-bridge presence heartbeat (kind 20001) on a rendezvous
    /// cell: empty content, `r` tag only — the bridge analogue of geohash
    /// presence, counted into "people across the bridge".
    static func createBridgePresenceEvent(
        cell: String,
        senderIdentity: NostrIdentity
    ) throws -> NostrEvent {
        let event = NostrEvent(
            pubkey: senderIdentity.publicKeyHex,
            createdAt: Date(),
            kind: .geohashPresence,
            tags: [["r", cell]],
            content: ""
        )
        let schnorrKey = try senderIdentity.schnorrSigningKey()
        return try event.sign(with: schnorrKey)
    }
    /// Create a courier drop (kind 1401): an opaque sealed courier envelope
    /// parked on relays. `x` is the hex recipient tag the recipient (or a
    /// gateway acting for them) subscribes for; the NIP-40 expiration tracks
    /// the envelope expiry so honoring relays garbage-collect the drop. The
    /// signing identity should be a throwaway — the envelope authenticates
    /// its sender internally via Noise-X, and linking drops to a stable
    /// publisher key would leak courier traffic patterns.
    static func createCourierDropEvent(
        envelope: Data,
        recipientTagHex: String,
        expiresAt: Date,
        senderIdentity: NostrIdentity
    ) throws -> NostrEvent {
        let tags = [
            ["x", recipientTagHex],
            ["expiration", String(Int(expiresAt.timeIntervalSince1970))]
        ]
        let event = NostrEvent(
            pubkey: senderIdentity.publicKeyHex,
            createdAt: Date(),
            kind: .courierDrop,
            tags: tags,
            content: envelope.base64EncodedString()
        )
        let schnorrKey = try senderIdentity.schnorrSigningKey()
        return try event.sign(with: schnorrKey)
    }
    /// Create a persistent location note (kind 1: text note) tagged to a street-level geohash.
    /// An optional `expiresAt` adds a NIP-40 expiration tag so honoring relays
    /// drop the note in step with a bridged board post's expiry.
    static func createGeohashTextNote(
        content: String,
        geohash: String,
        senderIdentity: NostrIdentity,
-        nickname: String? = nil
+        nickname: String? = nil,
        expiresAt: Date? = nil,
        urgent: Bool = false
    ) throws -> NostrEvent {
        var tags = [["g", geohash]]
        if let nickname = nickname?.trimmedOrNilIfEmpty {
            tags.append(["n", nickname])
        }
        if let expiresAt {
            tags.append(["expiration", String(Int(expiresAt.timeIntervalSince1970))])
        }
        if urgent {
            tags.append(["t", "urgent"])
        }
        let event = NostrEvent(
            pubkey: senderIdentity.publicKeyHex,
            createdAt: Date(),
@@ -228,6 +380,24 @@ struct NostrProtocol {
        return try event.sign(with: schnorrKey)
    }
    /// Create a NIP-09 deletion request for one of our own events. Relays that
    /// honor NIP-09 drop the referenced event; it must be signed by the same
    /// key that signed the original.
    static func createDeleteEvent(
        ofEventID eventID: String,
        senderIdentity: NostrIdentity
    ) throws -> NostrEvent {
        let event = NostrEvent(
            pubkey: senderIdentity.publicKeyHex,
            createdAt: Date(),
            kind: .deletion,
            tags: [["e", eventID]],
            content: ""
        )
        let schnorrKey = try senderIdentity.schnorrSigningKey()
        return try event.sign(with: schnorrKey)
    }
    // MARK: - Private Methods
    private static func createSeal(
@@ -474,37 +644,6 @@ struct NostrProtocol {
        return sharedSecretData
    }
    // Direct version that doesn't try to add prefixes
    private static func deriveSharedSecretDirect(
        privateKey: P256K.Schnorr.PrivateKey,
        publicKey: Data
    ) throws -> Data {
        // Direct shared secret calculation
        // Convert Schnorr private key to KeyAgreement private key
        let keyAgreementPrivateKey = try P256K.KeyAgreement.PrivateKey(
            dataRepresentation: privateKey.dataRepresentation
        )
        // Use the public key as-is (should already have prefix)
        let keyAgreementPublicKey = try P256K.KeyAgreement.PublicKey(
            dataRepresentation: publicKey,
            format: .compressed
        )
        // Perform ECDH
        let sharedSecret = try keyAgreementPrivateKey.sharedSecretFromKeyAgreement(
            with: keyAgreementPublicKey,
            format: .compressed
        )
        // Convert SharedSecret to Data
        let sharedSecretData = sharedSecret.withUnsafeBytes { Data($0) }
        // Return raw ECDH shared secret; HKDF is applied by deriveNIP44V2Key
        return sharedSecretData
    }
    private static func randomizedTimestamp() -> Date {
        // Add random offset to current time for privacy
        // This prevents timing correlation attacks while the actual message timestamp
@@ -634,11 +773,8 @@ struct NostrEvent: Codable {
 enum NostrError: Error {
    case invalidPublicKey
    case invalidPrivateKey
    case invalidEvent
    case invalidCiphertext
    case signingFailed
    case encryptionFailed
 }
 // MARK: - NIP-44 v2 helpers (XChaCha20-Poly1305)
@@ -648,7 +784,7 @@ private extension NostrProtocol {
        let derivedKey = HKDF<CryptoKit.SHA256>.deriveKey(
            inputKeyMaterial: SymmetricKey(data: sharedSecretData),
            salt: Data(),
-            info: "nip44-v2".data(using: .utf8)!,
+            info: Data("nip44-v2".utf8),
            outputByteCount: 32
        )
        return derivedKey.withUnsafeBytes { Data($0) }
@@ -117,7 +117,6 @@ final class NostrRelayManager: ObservableObject {
        let url: String
        var isConnected: Bool = false
        var lastError: Error?
        var lastConnectedAt: Date?
        var messagesSent: Int = 0
        var messagesReceived: Int = 0
        var reconnectAttempts: Int = 0
@@ -137,6 +136,10 @@ final class NostrRelayManager: ObservableObject {
    @Published private(set) var relays: [Relay] = []
    @Published private(set) var isConnected = false
    /// Whether a relay that carries private messages is connected. DMs
    /// target the default (gift-wrap-capable) relay set, so a connected
    /// geohash/custom relay alone must not count — sends would still queue.
    @Published private(set) var isDMRelayConnected = false
    private let dependencies: NostrRelayManagerDependencies
    private var allowDefaultRelays: Bool = false
@@ -180,11 +183,26 @@ final class NostrRelayManager: ObservableObject {
    }
    private var subscriptionRequestState: [String: SubscriptionRequestState] = [:]
-    // Track EOSE per subscription to signal when initial stored events are done
+    // Track EOSE per subscription to signal when initial stored events are
    // done. Completion is scoped to relays the REQ actually reached: targets
    // still mid-connect must not hold the callback hostage until the fallback
    // timer (a dead relay of five used to pin "loading" for the full 10s).
    private struct EOSETracker {
-        var pendingRelays: Set<String>
+        /// Targets the REQ has not been delivered to yet (still connecting).
        var awaitingSend: Set<String>
        /// Relays that received the REQ and have not sent EOSE yet.
        var awaitingEOSE: Set<String>
        /// True once any relay received the REQ (or answered with EOSE) —
        /// completion with zero sends would mean "done" without ever asking.
        var didSend = false
        var callback: () -> Void
        let epoch: Int
        /// Done when every relay that got the REQ has resolved, provided at
        /// least one did — or when every target dropped out entirely.
        var isComplete: Bool {
            (didSend && awaitingEOSE.isEmpty) || (awaitingSend.isEmpty && awaitingEOSE.isEmpty)
        }
    }
    private var eoseTrackers: [String: EOSETracker] = [:]
    private var eoseTrackerEpoch = 0
@@ -198,6 +216,15 @@ final class NostrRelayManager: ObservableObject {
    }
    private var messageQueue: [PendingSend] = []
    private let messageQueueLock = NSLock()
    /// Non-queued sends whose callers require relay durability. A WebSocket
    /// write only proves bytes left this process; NIP-20 OK is the relay's
    /// accept/reject acknowledgment.
    private struct ConfirmedSendState {
        let token: UUID
        var awaitingRelays: Set<String>
        let completion: (Bool) -> Void
    }
    private var confirmedSends: [String: ConfirmedSendState] = [:]
    // Total pending sends dropped at the queue cap; drives the sampled
    // overflow warning (first + every Nth drop).
    private var pendingSendDropCount = 0
@@ -294,6 +321,9 @@ final class NostrRelayManager: ObservableObject {
        for (_, tracker) in trackers {
            tracker.callback()
        }
        let confirmed = confirmedSends.values.map(\.completion)
        confirmedSends.removeAll()
        confirmed.forEach { $0(false) }
        pendingTorConnectionURLs.removeAll()
        awaitingTorForConnections = false
        torReadyWaitAttempts = 0
@@ -327,6 +357,7 @@ final class NostrRelayManager: ObservableObject {
        duplicateInboundEventDropCountBySubscription.removeAll()
        inboundEventLogCount = 0
        Self.pendingGiftWrapIDs.removeAll()
        confirmedSends.removeAll()
        messageQueueLock.lock()
        messageQueue.removeAll()
@@ -343,7 +374,6 @@ final class NostrRelayManager: ObservableObject {
            relays[index].nextReconnectTime = nil
            if resetState {
                relays[index].lastError = nil
                relays[index].lastConnectedAt = nil
                relays[index].lastDisconnectedAt = nil
                relays[index].messagesSent = 0
                relays[index].messagesReceived = 0
@@ -402,6 +432,97 @@ final class NostrRelayManager: ObservableObject {
        }
    }
    /// Attempts an event only on currently connected target relays and
    /// reports whether at least one relay explicitly accepted it via NIP-20
    /// OK. A successful WebSocket write alone is not durable acceptance.
    /// Unlike `sendEvent`, this never enters the process-local pending queue;
    /// callers use it when success unlocks durable state or user-visible
    /// delivery progress.
    func sendEventImmediately(
        _ event: NostrEvent,
        to relayUrls: [String]? = nil,
        completion: @escaping (Bool) -> Void
    ) {
        guard dependencies.activationAllowed() else {
            completion(false)
            return
        }
        guard !(shouldUseTor && dependencies.torEnforced() && !dependencies.torIsReady()) else {
            completion(false)
            return
        }
        let requestedRelays = relayUrls ?? Self.defaultRelays
        let targetRelays = allowedRelayList(from: requestedRelays)
        let connectedTargets = targetRelays.compactMap { relayUrl -> (String, NostrRelayConnectionProtocol)? in
            guard let connection = connectedConnection(for: relayUrl) else { return nil }
            return (relayUrl, connection)
        }
        guard !connectedTargets.isEmpty else {
            completion(false)
            return
        }
        let token = UUID()
        let eventID = event.id
        if let replaced = confirmedSends.removeValue(forKey: eventID) {
            replaced.completion(false)
        }
        confirmedSends[eventID] = ConfirmedSendState(
            token: token,
            awaitingRelays: Set(connectedTargets.map(\.0)),
            completion: completion
        )
        dependencies.scheduleAfter(TransportConfig.nostrConfirmedSendAckTimeoutSeconds) { [weak self] in
            Task { @MainActor [weak self] in
                self?.timeoutConfirmedSend(eventID: eventID, token: token)
            }
        }
        for (relayUrl, connection) in connectedTargets {
            sendToRelay(event: event, connection: connection, relayUrl: relayUrl) { [weak self] succeeded in
                guard let self else { return }
                // Success only means the bytes reached the socket; wait for
                // the matching relay OK. A failed write settles this target
                // as rejected because no OK can arrive for it.
                if !succeeded {
                    self.resolveConfirmedSend(
                        eventID: eventID,
                        relayURL: relayUrl,
                        accepted: false,
                        token: token
                    )
                }
            }
        }
    }
    private func resolveConfirmedSend(
        eventID: String,
        relayURL: String,
        accepted: Bool,
        token: UUID? = nil
    ) {
        guard var state = confirmedSends[eventID],
              token == nil || state.token == token,
              state.awaitingRelays.remove(relayURL) != nil else { return }
        if accepted {
            confirmedSends.removeValue(forKey: eventID)
            state.completion(true)
        } else if state.awaitingRelays.isEmpty {
            confirmedSends.removeValue(forKey: eventID)
            state.completion(false)
        } else {
            confirmedSends[eventID] = state
        }
    }
    private func timeoutConfirmedSend(eventID: String, token: UUID) {
        guard let state = confirmedSends[eventID], state.token == token else { return }
        confirmedSends.removeValue(forKey: eventID)
        state.completion(false)
    }
    private func enqueuePendingSend(_ event: NostrEvent, pendingRelays: Set<String>) {
        messageQueueLock.lock()
        messageQueue.append(PendingSend(event: event, pendingRelays: pendingRelays))
@@ -791,7 +912,7 @@ final class NostrRelayManager: ObservableObject {
    private func startEOSETracking(id: String, relayURLs: Set<String>, callback: @escaping () -> Void) {
        eoseTrackerEpoch += 1
        let epoch = eoseTrackerEpoch
-        eoseTrackers[id] = EOSETracker(pendingRelays: relayURLs, callback: callback, epoch: epoch)
+        eoseTrackers[id] = EOSETracker(awaitingSend: relayURLs, awaitingEOSE: [], callback: callback, epoch: epoch)
        // Fallback timeout to avoid hanging if a relay never sends EOSE.
        dependencies.scheduleAfter(TransportConfig.nostrSubscriptionEOSEFallbackSeconds) { [weak self] in
            Task { @MainActor [weak self] in
@@ -906,6 +1027,7 @@ final class NostrRelayManager: ObservableObject {
        // Send initial ping to verify connection
        task.sendPing { [weak self] error in
            DispatchQueue.main.async {
                guard self?.connections[urlString] === task else { return }
                if error == nil {
                    SecureLogger.debug("✅ Connected to Nostr relay: \(urlString)", category: .session)
                    self?.updateRelayStatus(urlString, isConnected: true)
@@ -915,7 +1037,11 @@ final class NostrRelayManager: ObservableObject {
                    SecureLogger.error("❌ Failed to connect to Nostr relay \(urlString): \(error?.localizedDescription ?? "Unknown error")", category: .session)
                    self?.updateRelayStatus(urlString, isConnected: false, error: error)
                    // Trigger disconnection handler for proper backoff
-                    self?.handleDisconnection(relayUrl: urlString, error: error ?? NSError(domain: "NostrRelay", code: -1, userInfo: nil))
+                    self?.handleDisconnection(
                        relayUrl: urlString,
                        error: error ?? NSError(domain: "NostrRelay", code: -1, userInfo: nil),
                        connection: task
                    )
                }
            }
        }
@@ -931,8 +1057,19 @@ final class NostrRelayManager: ObservableObject {
            toSend[id] = state.messageString
        }
        for (id, messageString) in toSend {
-            if self.subscriptions[relayUrl]?.contains(id) == true { continue }
+            if self.subscriptions[relayUrl]?.contains(id) == true {
                // Already subscribed on this relay (e.g. a tracker promoted
                // after an earlier flush): its EOSE is coming, count it.
                markEOSESubscribed(id: id, relayUrl: relayUrl)
                continue
            }
            startPendingEOSETrackingIfNeeded(id: id)
            // Mark at send *initiation*, not in the async completion: a fast
            // relay's EOSE could otherwise complete the tracker while this
            // relay — REQ already on the wire — still sat in awaitingSend.
            // If the send fails the socket is going down with it, and the
            // disconnect settle (or the fallback timer) releases the wait.
            markEOSESubscribed(id: id, relayUrl: relayUrl)
            connection.send(.string(messageString)) { [weak self, weak connection] error in
                Task { @MainActor [weak self] in
                    guard let self else { return }
@@ -962,18 +1099,20 @@ final class NostrRelayManager: ObservableObject {
                Task.detached(priority: .utility) {
                    guard let parsed = ParsedInbound(message) else { return }
                    await MainActor.run {
                        guard self.connections[relayUrl] === task else { return }
                        self.handleParsedMessage(parsed, from: relayUrl)
                    }
                }
                // Continue receiving
                Task { @MainActor in
                    guard self.connections[relayUrl] === task else { return }
                    self.receiveMessage(from: task, relayUrl: relayUrl)
                }
            case .failure(let error):
                DispatchQueue.main.async {
-                    self.handleDisconnection(relayUrl: relayUrl, error: error)
+                    self.handleDisconnection(relayUrl: relayUrl, error: error, connection: task)
                }
            }
        }
@@ -1014,8 +1153,12 @@ final class NostrRelayManager: ObservableObject {
            }
        case .eose(let subId):
            if var tracker = eoseTrackers[subId] {
-                tracker.pendingRelays.remove(relayUrl)
+                // An EOSE proves the relay received the REQ even if the local
-                if tracker.pendingRelays.isEmpty {
+                // send completion hasn't run yet.
                tracker.awaitingSend.remove(relayUrl)
                tracker.awaitingEOSE.remove(relayUrl)
                tracker.didSend = true
                if tracker.isComplete {
                    eoseTrackers.removeValue(forKey: subId)
                    tracker.callback()
                } else {
@@ -1023,6 +1166,7 @@ final class NostrRelayManager: ObservableObject {
                }
            }
        case .ok(let eventId, let success, let reason):
            resolveConfirmedSend(eventID: eventId, relayURL: relayUrl, accepted: success)
            if success {
                _ = Self.pendingGiftWrapIDs.remove(eventId)
                SecureLogger.debug("✅ Accepted id=\(eventId.prefix(16))… relay=\(relayUrl)", category: .session)
@@ -1039,7 +1183,12 @@ final class NostrRelayManager: ObservableObject {
        }
    }
-    private func sendToRelay(event: NostrEvent, connection: NostrRelayConnectionProtocol, relayUrl: String) {
+    private func sendToRelay(
        event: NostrEvent,
        connection: NostrRelayConnectionProtocol,
        relayUrl: String,
        completion: ((Bool) -> Void)? = nil
    ) {
        let req = NostrRequest.event(event)
        do {
@@ -1052,17 +1201,20 @@ final class NostrRelayManager: ObservableObject {
                DispatchQueue.main.async {
                    if let error = error {
                        SecureLogger.error("❌ Failed to send event to \(relayUrl): \(error)", category: .session)
                        completion?(false)
                    } else {
                        // SecureLogger.debug("✅ Event sent to relay: \(relayUrl)", category: .session)
                        // Update relay stats
                        if let index = self?.relays.firstIndex(where: { $0.url == relayUrl }) {
                            self?.relays[index].messagesSent += 1
                        }
                        completion?(true)
                    }
                }
            }
        } catch {
            SecureLogger.error("Failed to encode event: \(error)", category: .session)
            completion?(false)
        }
    }
@@ -1071,7 +1223,6 @@ final class NostrRelayManager: ObservableObject {
            relays[index].isConnected = isConnected
            relays[index].lastError = error
            if isConnected {
                relays[index].lastConnectedAt = dependencies.now()
                relays[index].reconnectAttempts = 0  // Reset on successful connection
                relays[index].nextReconnectTime = nil
            } else {
@@ -1087,15 +1238,20 @@ final class NostrRelayManager: ObservableObject {
    private func updateConnectionStatus() {
        isConnected = relays.contains { $0.isConnected }
        // Relay URLs are normalized before entries are created, so direct
        // set membership is sound.
        isDMRelayConnected = relays.contains { $0.isConnected && Self.defaultRelaySet.contains($0.url) }
    }
    /// A relay that drops before sending EOSE must not stall initial-load
    /// callbacks; treat it as done and let the remaining relays (or the
    /// fallback timeout) drive completion.
    private func settleEOSETrackers(droppingRelay relayUrl: String) {
-        for (id, var tracker) in eoseTrackers where tracker.pendingRelays.contains(relayUrl) {
+        for (id, var tracker) in eoseTrackers
-            tracker.pendingRelays.remove(relayUrl)
+        where tracker.awaitingSend.contains(relayUrl) || tracker.awaitingEOSE.contains(relayUrl) {
-            if tracker.pendingRelays.isEmpty {
+            tracker.awaitingSend.remove(relayUrl)
            tracker.awaitingEOSE.remove(relayUrl)
            if tracker.isComplete {
                eoseTrackers.removeValue(forKey: id)
                tracker.callback()
            } else {
@@ -1104,9 +1260,38 @@ final class NostrRelayManager: ObservableObject {
        }
    }
-    private func handleDisconnection(relayUrl: String, error: Error) {
+    /// Whether any of `relayUrls` currently holds a live connection. Lets
    /// subscribers distinguish "loaded, empty" from "never reached a relay"
    /// when an EOSE fallback fires.
    func isAnyRelayConnected(among relayUrls: [String]) -> Bool {
        let targets = Set(relayUrls)
        return relays.contains { targets.contains($0.url) && $0.isConnected }
    }
    /// Marks the REQ as delivered to `relayUrl`: EOSE completion now waits on
    /// this relay instead of the never-connected remainder.
    private func markEOSESubscribed(id: String, relayUrl: String) {
        guard var tracker = eoseTrackers[id],
              tracker.awaitingSend.remove(relayUrl) != nil else { return }
        tracker.awaitingEOSE.insert(relayUrl)
        tracker.didSend = true
        eoseTrackers[id] = tracker
    }
    private func handleDisconnection(
        relayUrl: String,
        error: Error,
        connection: NostrRelayConnectionProtocol? = nil
    ) {
        if let connection, connections[relayUrl] !== connection { return }
        connections.removeValue(forKey: relayUrl)
        subscriptions.removeValue(forKey: relayUrl)
        let awaitingConfirmation = confirmedSends.compactMap { eventID, state in
            state.awaitingRelays.contains(relayUrl) ? eventID : nil
        }
        for eventID in awaitingConfirmation {
            resolveConfirmedSend(eventID: eventID, relayURL: relayUrl, accepted: false)
        }
        updateRelayStatus(relayUrl, isConnected: false, error: error)
        settleEOSETrackers(droppingRelay: relayUrl)
        // If networking is disallowed, do not schedule reconnection
@@ -1456,6 +1641,29 @@ struct NostrFilter: Encodable {
        filter.limit = limit
        return filter
    }
    // For the mesh bridge: rendezvous messages (kind 20000) and presence
    // (kind 20001) tagged `#r` with one or more cells (own + neighbors).
    static func bridgeRendezvous(_ cells: [String], since: Date? = nil, limit: Int = 200) -> NostrFilter {
        var filter = NostrFilter()
        filter.kinds = [20000, 20001]
        filter.since = since?.timeIntervalSince1970.toInt()
        filter.tagFilters = ["r": cells]
        filter.limit = limit
        return filter
    }
    // For courier drops: sealed envelopes (kind 1401) parked under rotating
    // recipient tags (`#x`, hex). Callers pass every candidate tag (adjacent
    // UTC days x recipients) in one filter.
    static func courierDrops(recipientTagsHex: [String], since: Date? = nil, limit: Int = 100) -> NostrFilter {
        var filter = NostrFilter()
        filter.kinds = [NostrProtocol.EventKind.courierDrop.rawValue]
        filter.since = since?.timeIntervalSince1970.toInt()
        filter.tagFilters = ["x": recipientTagsHex]
        filter.limit = limit
        return filter
    }
 }
 // Dynamic coding key for tag filters
@@ -132,4 +132,3 @@ private extension Data {
        replaceSubrange(offset..<(offset+4), with: bytes)
    }
 }
@@ -0,0 +1,41 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
 	<key>NSPrivacyTracking</key>
 	<false/>
 	<key>NSPrivacyTrackingDomains</key>
 	<array/>
 	<key>NSPrivacyCollectedDataTypes</key>
 	<array/>
 	<key>NSPrivacyAccessedAPITypes</key>
 	<array>
 		<dict>
 			<key>NSPrivacyAccessedAPIType</key>
 			<string>NSPrivacyAccessedAPICategoryFileTimestamp</string>
 			<key>NSPrivacyAccessedAPITypeReasons</key>
 			<array>
 				<string>C617.1</string>
 				<string>3B52.1</string>
 			</array>
 		</dict>
 		<dict>
 			<key>NSPrivacyAccessedAPIType</key>
 			<string>NSPrivacyAccessedAPICategorySystemBootTime</string>
 			<key>NSPrivacyAccessedAPITypeReasons</key>
 			<array>
 				<string>35F9.1</string>
 			</array>
 		</dict>
 		<dict>
 			<key>NSPrivacyAccessedAPIType</key>
 			<string>NSPrivacyAccessedAPICategoryUserDefaults</string>
 			<key>NSPrivacyAccessedAPITypeReasons</key>
 			<array>
 				<string>CA92.1</string>
 				<string>1C8F.1</string>
 			</array>
 		</dict>
 	</array>
 </dict>
 </plist>
@@ -18,7 +18,7 @@
 /// - Efficient binary message encoding
 /// - Message fragmentation for large payloads
 /// - TTL-based routing for mesh networks
-/// - Privacy features like padding and timing obfuscation
+/// - Privacy features: message padding and randomized relay jitter
 /// - Integration points for end-to-end encryption
 ///
 /// ## Protocol Design
@@ -38,18 +38,20 @@
 /// 7. **Decoding**: Binary data parsed back to message objects
 ///
 /// ## Security Considerations
-/// - Message padding obscures actual content length
+/// - Message padding (to 256/512/1024/2048-byte blocks) obscures actual content length
-/// - Timing obfuscation prevents traffic analysis
+/// - Randomized relay jitter reduces the traffic-analysis signal; there is no
 ///   cover traffic or per-message timing obfuscation
 /// - Integration with Noise Protocol for E2E encryption
 /// - No persistent identifiers in protocol headers
 ///
 /// ## Message Types
 /// - **Announce/Leave**: Peer presence notifications
-/// - **Message**: User chat messages (broadcast or directed)
+/// - **Message**: Public chat messages
 /// - **Fragment**: Multi-part message handling
-/// - **Delivery/Read**: Message acknowledgments
+/// - **NoiseHandshake/NoiseEncrypted**: Encrypted channel establishment and
-/// - **Noise**: Encrypted channel establishment
+///   all private payloads (messages, delivery acks, read receipts)
-/// - **Version**: Protocol version negotiation
+/// - **CourierEnvelope**: Sealed store-and-forward mail
 /// - **RequestSync/FileTransfer**: Gossip history sync and media transfer
 ///
 /// ## Future Extensions
 /// The protocol is designed to be extensible:
@@ -72,17 +74,28 @@ enum NoisePayloadType: UInt8 {
    case privateMessage = 0x01      // Private chat message
    case readReceipt = 0x02         // Message was read
    case delivered = 0x03           // Message was delivered
    // Private groups (0x04/0x05 reserved by other features)
    case groupInvite = 0x06         // Creator-signed group state (invite)
    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)
    // 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
    var description: String {
        switch self {
        case .privateMessage: return "privateMessage"
        case .readReceipt: return "readReceipt"
        case .delivered: return "delivered"
        case .groupInvite: return "groupInvite"
        case .groupKeyUpdate: return "groupKeyUpdate"
        case .voiceFrame: return "voiceFrame"
        case .verifyChallenge: return "verifyChallenge"
        case .verifyResponse: return "verifyResponse"
        case .vouch: return "vouch"
        }
    }
 }
@@ -114,6 +127,12 @@ protocol BitchatDelegate: AnyObject {
    // Low-level events for better separation of concerns
    func didReceiveNoisePayload(from peerID: PeerID, type: NoisePayloadType, payload: Data, timestamp: Date)
    // Encrypted group broadcast (opaque envelope; decrypted by the group coordinator)
    func didReceiveGroupMessage(payload: Data, timestamp: Date)
    // Public live-voice burst packet (signature-verified by the transport)
    func didReceivePublicVoiceFrame(from peerID: PeerID, nickname: String, payload: Data, timestamp: Date)
    // Bluetooth state updates for user notifications
    func didUpdateBluetoothState(_ state: CBManagerState)
    func didReceivePublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date, messageID: String?)
@@ -133,6 +152,14 @@ extension BitchatDelegate {
        // Default empty implementation
    }
    func didReceiveGroupMessage(payload: Data, timestamp: Date) {
        // Default empty implementation
    }
    func didReceivePublicVoiceFrame(from peerID: PeerID, nickname: String, payload: Data, timestamp: Date) {
        // Default empty implementation
    }
    func didReceivePublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date, messageID: String?) {
        // Default empty implementation
    }
@@ -0,0 +1,348 @@
 //
 // BoardPackets.swift
 // bitchat
 //
 // This is free and unencumbered software released into the public domain.
 // For more information, see <https://unlicense.org>
 //
 import CryptoKit
 import Foundation
 // MARK: - Board wire format (MessageType.boardPost payloads)
 //
 // TLV layout (type u8, length u16 big-endian, value), matching REQUEST_SYNC:
 //  - 0x01: kind (u8) — 0x01 post, 0x02 tombstone
 //  - 0x02: postID (16B random)
 //  - 0x03: geohash (UTF-8, empty = mesh-local board, max 12 chars)
 //  - 0x04: content (UTF-8, 1...512 bytes) [post]
 //  - 0x05: authorSigningKey (32B Ed25519 public key)
 //  - 0x06: authorNickname (UTF-8, max 64 bytes)
 //  - 0x07: createdAt (u64 big-endian, ms) [post]
 //  - 0x08: expiresAt (u64 big-endian, ms, max 7 days after createdAt) [post]
 //  - 0x09: flags (u8, bit0 = urgent) [post]
 //  - 0x0A: signature (64B Ed25519)
 //  - 0x0B: deletedAt (u64 big-endian, ms) [tombstone]
 // Unknown TLVs are skipped for forward compatibility.
 enum BoardWireConstants {
    static let postIDLength = 16
    static let signingKeyLength = 32
    static let signatureLength = 64
    static let contentMaxBytes = 512
    static let nicknameMaxBytes = 64
    static let geohashMaxLength = 12
    /// Posts may live at most 7 days past their creation timestamp.
    static let maxLifetimeMs: UInt64 = 7 * 24 * 60 * 60 * 1000
    static let postSigningContext = "bitchat-board-v1"
    static let tombstoneSigningContext = "bitchat-board-del-v1"
    static let geohashAlphabet = Set("0123456789bcdefghjkmnpqrstuvwxyz")
 }
 private enum BoardTLVType: UInt8 {
    case kind = 0x01
    case postID = 0x02
    case geohash = 0x03
    case content = 0x04
    case authorSigningKey = 0x05
    case authorNickname = 0x06
    case createdAt = 0x07
    case expiresAt = 0x08
    case flags = 0x09
    case signature = 0x0A
    case deletedAt = 0x0B
 }
 private enum BoardWireKind: UInt8 {
    case post = 0x01
    case tombstone = 0x02
 }
 /// A signed, persistent bulletin-board notice.
 struct BoardPostPacket: Equatable {
    let postID: Data
    /// Empty string scopes the post to the mesh-local board.
    let geohash: String
    let content: String
    let authorSigningKey: Data
    let authorNickname: String
    let createdAt: UInt64
    let expiresAt: UInt64
    let flags: UInt8
    let signature: Data
    static let urgentFlag: UInt8 = 0x01
    var isUrgent: Bool { flags & Self.urgentFlag != 0 }
    /// Canonical bytes covered by the Ed25519 signature. Variable-length
    /// fields are length-prefixed so no two field combinations can collide.
    static func signingBytes(
        postID: Data,
        geohash: String,
        content: String,
        authorSigningKey: Data,
        authorNickname: String,
        createdAt: UInt64,
        expiresAt: UInt64,
        flags: UInt8
    ) -> Data {
        var out = Data()
        BoardWireEncoding.appendContext(BoardWireConstants.postSigningContext, to: &out)
        out.append(postID)
        BoardWireEncoding.appendLengthPrefixed(Data(geohash.utf8), to: &out)
        BoardWireEncoding.appendLengthPrefixed(Data(content.utf8), to: &out)
        out.append(authorSigningKey)
        BoardWireEncoding.appendLengthPrefixed(Data(authorNickname.utf8), to: &out)
        BoardWireEncoding.appendUInt64(createdAt, to: &out)
        BoardWireEncoding.appendUInt64(expiresAt, to: &out)
        out.append(flags)
        return out
    }
    var signingBytes: Data {
        Self.signingBytes(
            postID: postID,
            geohash: geohash,
            content: content,
            authorSigningKey: authorSigningKey,
            authorNickname: authorNickname,
            createdAt: createdAt,
            expiresAt: expiresAt,
            flags: flags
        )
    }
    func verifySignature() -> Bool {
        BoardWireEncoding.verify(signature: signature, over: signingBytes, publicKey: authorSigningKey)
    }
 }
 /// A signed deletion marker. Only the author's key can produce one; receivers
 /// keep it until the post's original expiry so the delete outruns the post.
 struct BoardTombstonePacket: Equatable {
    let postID: Data
    let authorSigningKey: Data
    let deletedAt: UInt64
    let signature: Data
    static func signingBytes(postID: Data, deletedAt: UInt64) -> Data {
        var out = Data()
        BoardWireEncoding.appendContext(BoardWireConstants.tombstoneSigningContext, to: &out)
        out.append(postID)
        BoardWireEncoding.appendUInt64(deletedAt, to: &out)
        return out
    }
    var signingBytes: Data {
        Self.signingBytes(postID: postID, deletedAt: deletedAt)
    }
    func verifySignature() -> Bool {
        BoardWireEncoding.verify(signature: signature, over: signingBytes, publicKey: authorSigningKey)
    }
 }
 /// Decoded board payload: either a live post or a tombstone.
 enum BoardWire: Equatable {
    case post(BoardPostPacket)
    case tombstone(BoardTombstonePacket)
    func encode() -> Data {
        var out = Data()
        func putTLV(_ t: BoardTLVType, _ v: Data) {
            out.append(t.rawValue)
            let len = UInt16(v.count)
            out.append(UInt8((len >> 8) & 0xFF))
            out.append(UInt8(len & 0xFF))
            out.append(v)
        }
        switch self {
        case .post(let post):
            putTLV(.kind, Data([BoardWireKind.post.rawValue]))
            putTLV(.postID, post.postID)
            putTLV(.geohash, Data(post.geohash.utf8))
            putTLV(.content, Data(post.content.utf8))
            putTLV(.authorSigningKey, post.authorSigningKey)
            putTLV(.authorNickname, Data(post.authorNickname.utf8))
            putTLV(.createdAt, BoardWireEncoding.uint64Data(post.createdAt))
            putTLV(.expiresAt, BoardWireEncoding.uint64Data(post.expiresAt))
            putTLV(.flags, Data([post.flags]))
            putTLV(.signature, post.signature)
        case .tombstone(let tombstone):
            putTLV(.kind, Data([BoardWireKind.tombstone.rawValue]))
            putTLV(.postID, tombstone.postID)
            putTLV(.authorSigningKey, tombstone.authorSigningKey)
            putTLV(.deletedAt, BoardWireEncoding.uint64Data(tombstone.deletedAt))
            putTLV(.signature, tombstone.signature)
        }
        return out
    }
    /// Structural decode; the caller must still verify the signature before
    /// ingesting (`verifySignature()`).
    static func decode(from data: Data) -> BoardWire? {
        var off = data.startIndex
        var kind: BoardWireKind?
        var postID: Data?
        var geohash: String?
        var content: String?
        var contentBytes = 0
        var authorSigningKey: Data?
        var authorNickname: String?
        var nicknameBytes = 0
        var createdAt: UInt64?
        var expiresAt: UInt64?
        var flags: UInt8?
        var signature: Data?
        var deletedAt: UInt64?
        while off + 3 <= data.endIndex {
            let t = data[off]; off += 1
            let len = (Int(data[off]) << 8) | Int(data[off + 1]); off += 2
            guard off + len <= data.endIndex else { return nil }
            let v = data.subdata(in: off..<(off + len)); off += len
            switch BoardTLVType(rawValue: t) {
            case .kind:
                guard v.count == 1 else { return nil }
                kind = BoardWireKind(rawValue: v[v.startIndex])
            case .postID:
                guard v.count == BoardWireConstants.postIDLength else { return nil }
                postID = v
            case .geohash:
                guard v.count <= BoardWireConstants.geohashMaxLength else { return nil }
                geohash = String(data: v, encoding: .utf8)
            case .content:
                guard v.count <= BoardWireConstants.contentMaxBytes else { return nil }
                contentBytes = v.count
                content = String(data: v, encoding: .utf8)
            case .authorSigningKey:
                guard v.count == BoardWireConstants.signingKeyLength else { return nil }
                authorSigningKey = v
            case .authorNickname:
                guard v.count <= BoardWireConstants.nicknameMaxBytes else { return nil }
                nicknameBytes = v.count
                authorNickname = String(data: v, encoding: .utf8)
            case .createdAt:
                createdAt = BoardWireEncoding.uint64(from: v)
            case .expiresAt:
                expiresAt = BoardWireEncoding.uint64(from: v)
            case .flags:
                guard v.count == 1 else { return nil }
                flags = v[v.startIndex]
            case .signature:
                guard v.count == BoardWireConstants.signatureLength else { return nil }
                signature = v
            case .deletedAt:
                deletedAt = BoardWireEncoding.uint64(from: v)
            case nil:
                continue // forward compatible; ignore unknown TLVs
            }
        }
        guard let postID, let authorSigningKey, let signature else { return nil }
        switch kind {
        case .post:
            guard let geohash, let content, let authorNickname,
                  let createdAt, let expiresAt, let flags,
                  contentBytes >= 1,
                  nicknameBytes <= BoardWireConstants.nicknameMaxBytes,
                  isValidGeohashField(geohash),
                  expiresAt > createdAt,
                  expiresAt - createdAt <= BoardWireConstants.maxLifetimeMs else {
                return nil
            }
            return .post(BoardPostPacket(
                postID: postID,
                geohash: geohash,
                content: content,
                authorSigningKey: authorSigningKey,
                authorNickname: authorNickname,
                createdAt: createdAt,
                expiresAt: expiresAt,
                flags: flags,
                signature: signature
            ))
        case .tombstone:
            guard let deletedAt else { return nil }
            return .tombstone(BoardTombstonePacket(
                postID: postID,
                authorSigningKey: authorSigningKey,
                deletedAt: deletedAt,
                signature: signature
            ))
        case nil:
            return nil
        }
    }
    func verifySignature() -> Bool {
        switch self {
        case .post(let post): return post.verifySignature()
        case .tombstone(let tombstone): return tombstone.verifySignature()
        }
    }
    /// Cheap TLV peek for relay policy: is this payload an urgent post?
    /// Avoids a full decode on the hot relay path.
    static func urgentFlag(in data: Data) -> Bool {
        var off = data.startIndex
        while off + 3 <= data.endIndex {
            let t = data[off]; off += 1
            let len = (Int(data[off]) << 8) | Int(data[off + 1]); off += 2
            guard off + len <= data.endIndex else { return false }
            if t == BoardTLVType.flags.rawValue, len == 1 {
                return data[off] & BoardPostPacket.urgentFlag != 0
            }
            off += len
        }
        return false
    }
    /// Empty geohash = mesh-local board; otherwise 1-12 chars of the geohash
    /// base32 alphabet.
    private static func isValidGeohashField(_ geohash: String) -> Bool {
        geohash.isEmpty || geohash.allSatisfy { BoardWireConstants.geohashAlphabet.contains($0) }
    }
 }
 enum BoardWireEncoding {
    static func appendContext(_ context: String, to out: inout Data) {
        let bytes = Data(context.utf8)
        out.append(UInt8(min(bytes.count, 255)))
        out.append(bytes.prefix(255))
    }
    static func appendLengthPrefixed(_ value: Data, to out: inout Data) {
        let len = UInt16(min(value.count, Int(UInt16.max)))
        out.append(UInt8((len >> 8) & 0xFF))
        out.append(UInt8(len & 0xFF))
        out.append(value.prefix(Int(UInt16.max)))
    }
    static func appendUInt64(_ value: UInt64, to out: inout Data) {
        var be = value.bigEndian
        withUnsafeBytes(of: &be) { out.append(contentsOf: $0) }
    }
    static func uint64Data(_ value: UInt64) -> Data {
        var out = Data()
        appendUInt64(value, to: &out)
        return out
    }
    static func uint64(from data: Data) -> UInt64? {
        guard data.count == 8 else { return nil }
        var value: UInt64 = 0
        for byte in data { value = (value << 8) | UInt64(byte) }
        return value
    }
    static func verify(signature: Data, over message: Data, publicKey: Data) -> Bool {
        guard let key = try? Curve25519.Signing.PublicKey(rawRepresentation: publicKey) else {
            return false
        }
        return key.isValidSignature(signature, for: message)
    }
 }
@@ -10,11 +10,11 @@ enum Geohash {
        return map
    }()
-    /// Validates a geohash string for building-level precision (8 characters).
+    /// Validates a geohash string at any channel precision (1-12 characters).
    /// - Parameter geohash: The geohash string to validate
-    /// - Returns: true if valid 8-character base32 geohash, false otherwise
+    /// - Returns: true if a non-empty base32 geohash of at most 12 characters
-    static func isValidBuildingGeohash(_ geohash: String) -> Bool {
+    static func isValidGeohash(_ geohash: String) -> Bool {
-        guard geohash.count == 8 else { return false }
+        guard (1...12).contains(geohash.count) else { return false }
        return geohash.lowercased().allSatisfy { base32Map[$0] != nil }
    }
@@ -0,0 +1,32 @@
 //
 // MeshMessageIdentity.swift
 // bitchat
 //
 // This is free and unencumbered software released into the public domain.
 // For more information, see <https://unlicense.org>
 //
 import BitFoundation
 import Foundation
 /// Content-derived identity for public mesh messages.
 ///
 /// The BLE wire carries no message ID for public broadcasts, so every device
 /// recomputes the same stable ID from the signed wire fields (sender ID,
 /// millisecond timestamp, content). That gives the mesh bridge a
 /// cross-device-consistent radio identity with zero wire change. Bridge events
 /// carry this value only as a hint for detecting a radio copy that is already
 /// present: sender/timestamp/content are public, so a different Nostr signer
 /// can copy them and must never be allowed to reserve the genuine event's
 /// authenticated dedup slot.
 enum MeshMessageIdentity {
    /// Matches the wire truncation in `BLEService.sendMessage`.
    static func millisecondTimestamp(_ date: Date) -> UInt64 {
        UInt64(date.timeIntervalSince1970 * 1000)
    }
    static func stableID(senderIDHex: String, timestampMs: UInt64, content: String) -> String {
        let input = senderIDHex.lowercased() + "|" + String(timestampMs) + "|" + content.trimmed
        return String(Data(input.utf8).sha256Hex().prefix(32))
    }
 }
@@ -0,0 +1,144 @@
 //
 // NostrCarrierPacket.swift
 // bitchat
 //
 // This is free and unencumbered software released into the public domain.
 // For more information, see <https://unlicense.org>
 //
 import BitFoundation
 import Foundation
 /// Wire payload for `MessageType.nostrCarrier` (0x28): a complete, signed
 /// Nostr event ferried over the mesh between a mesh-only peer and an
 /// internet gateway peer.
 ///
 /// - `toGateway` rides a DIRECTED packet (recipientID = the gateway peer):
 ///   a mesh-only sender asks the gateway to publish its locally signed
 ///   geohash event to Nostr relays.
 /// - `fromGateway` rides a BROADCAST packet (default TTL): the gateway
 ///   rebroadcasts inbound relay events so mesh-only peers see the channel.
 ///
 /// The carried event is public geohash chat — already plaintext on Nostr —
 /// so the carrier adds no encryption. It IS signed by the originator's
 /// per-geohash identity, so neither the gateway nor any mesh relay can forge
 /// or alter it undetected: gateways and receivers verify the Schnorr
 /// signature before acting on it.
 ///
 /// TLV encoding with 2-byte big-endian lengths (the event JSON exceeds the
 /// 1-byte TLV range used by smaller packets). Unknown TLV types are skipped
 /// for forward compatibility.
 struct NostrCarrierPacket: Equatable {
    enum Direction: UInt8 {
        case toGateway = 0x01
        case fromGateway = 0x02
        /// Mesh-bridge uplink: a mesh-only peer asks a bridge gateway to
        /// publish its signed rendezvous event. Directed, like `toGateway`.
        case toBridge = 0x03
        /// Mesh-bridge downlink: a bridge gateway rebroadcasts a rendezvous
        /// event from a remote island. Broadcast, like `fromGateway`.
        /// Old clients fail the Direction decode on 0x03/0x04 and drop the
        /// carrier quietly — bridge traffic degrades to invisible, not junk.
        case fromBridge = 0x04
    }
    let direction: Direction
    let geohash: String
    /// Complete signed Nostr event JSON (id, pubkey, created_at, kind, tags,
    /// content, sig).
    let eventJSON: Data
    /// BLE airtime cap for a carried event.
    static let maxEventJSONBytes = 16 * 1024
    static let maxGeohashLength = 12
    private enum TLVType: UInt8 {
        case direction = 0x01
        case geohash = 0x02
        case eventJSON = 0x03
    }
    init?(direction: Direction, geohash: String, eventJSON: Data) {
        let geohashBytes = Data(geohash.utf8)
        guard !geohashBytes.isEmpty,
              geohashBytes.count <= Self.maxGeohashLength,
              !eventJSON.isEmpty,
              eventJSON.count <= Self.maxEventJSONBytes else {
            return nil
        }
        self.direction = direction
        self.geohash = geohash
        self.eventJSON = eventJSON
    }
    init?(direction: Direction, geohash: String, event: NostrEvent) {
        guard let json = try? event.jsonString(), !json.isEmpty else { return nil }
        self.init(direction: direction, geohash: geohash, eventJSON: Data(json.utf8))
    }
    /// Decodes the carried event. Callers MUST still verify
    /// `event.isValidSignature()` before publishing or displaying it.
    func event() -> NostrEvent? {
        guard let dict = try? JSONSerialization.jsonObject(with: eventJSON) as? [String: Any] else {
            return nil
        }
        return try? NostrEvent(from: dict)
    }
    func encode() -> Data? {
        var data = Data()
        data.reserveCapacity(eventJSON.count + geohash.utf8.count + 12)
        func appendTLV(_ type: TLVType, _ value: Data) {
            data.append(type.rawValue)
            data.append(UInt8((value.count >> 8) & 0xFF))
            data.append(UInt8(value.count & 0xFF))
            data.append(value)
        }
        appendTLV(.direction, Data([direction.rawValue]))
        appendTLV(.geohash, Data(geohash.utf8))
        appendTLV(.eventJSON, eventJSON)
        return data
    }
    static func decode(_ data: Data) -> NostrCarrierPacket? {
        // Defensive slice re-base (Data slices keep parent indices).
        let data = Data(data)
        var offset = 0
        var direction: Direction?
        var geohash: String?
        var eventJSON: Data?
        while offset + 3 <= data.count {
            let typeRaw = data[offset]
            let length = (Int(data[offset + 1]) << 8) | Int(data[offset + 2])
            offset += 3
            guard offset + length <= data.count else { return nil }
            let value = data.subdata(in: offset..<offset + length)
            offset += length
            switch TLVType(rawValue: typeRaw) {
            case .direction:
                guard value.count == 1, let parsed = Direction(rawValue: value[0]) else { return nil }
                direction = parsed
            case .geohash:
                guard let parsed = String(data: value, encoding: .utf8) else { return nil }
                geohash = parsed
            case .eventJSON:
                eventJSON = value
            case nil:
                // Unknown TLV; skip (tolerant decoder for forward compatibility).
                continue
            }
        }
        guard offset == data.count,
              let direction,
              let geohash,
              let eventJSON else {
            return nil
        }
        return NostrCarrierPacket(direction: direction, geohash: geohash, eventJSON: eventJSON)
    }
 }
@@ -1,3 +1,4 @@
 import BitFoundation
 import Foundation
 // MARK: - Protocol TLV Packets
@@ -7,12 +8,35 @@ struct AnnouncementPacket {
    let noisePublicKey: Data            // Noise static public key (Curve25519.KeyAgreement)
    let signingPublicKey: Data          // Ed25519 public key for signing
    let directNeighbors: [Data]?        // 8-byte peer IDs
    let capabilities: PeerCapabilities? // advertised feature bits; nil when absent (old clients)
    /// Rendezvous geohash cell this peer bridges, when advertising `.bridge`.
    /// Coarse (cell-level) by design; lets mesh-only peers compose correctly
    /// tagged rendezvous events without their own location fix.
    let bridgeGeohash: String?
    init(
        nickname: String,
        noisePublicKey: Data,
        signingPublicKey: Data,
        directNeighbors: [Data]?,
        capabilities: PeerCapabilities? = nil,
        bridgeGeohash: String? = nil
    ) {
        self.nickname = nickname
        self.noisePublicKey = noisePublicKey
        self.signingPublicKey = signingPublicKey
        self.directNeighbors = directNeighbors
        self.capabilities = capabilities
        self.bridgeGeohash = bridgeGeohash
    }
    private enum TLVType: UInt8 {
        case nickname = 0x01
        case noisePublicKey = 0x02
        case signingPublicKey = 0x03
        case directNeighbors = 0x04
        case capabilities = 0x05
        case bridgeGeohash = 0x06
    }
    func encode() -> Data? {
@@ -48,6 +72,24 @@ struct AnnouncementPacket {
            }
        }
        // TLV for capabilities (optional)
        if let capabilities = capabilities {
            let capabilityBytes = capabilities.encoded()
            guard capabilityBytes.count <= 255 else { return nil }
            data.append(TLVType.capabilities.rawValue)
            data.append(UInt8(capabilityBytes.count))
            data.append(capabilityBytes)
        }
        // TLV for bridge rendezvous cell (optional; old clients skip it)
        if let bridgeGeohash = bridgeGeohash,
           let cellData = bridgeGeohash.data(using: .utf8),
           !cellData.isEmpty, cellData.count <= 12 {
            data.append(TLVType.bridgeGeohash.rawValue)
            data.append(UInt8(cellData.count))
            data.append(cellData)
        }
        return data
    }
@@ -57,6 +99,8 @@ struct AnnouncementPacket {
        var noisePublicKey: Data?
        var signingPublicKey: Data?
        var directNeighbors: [Data]?
        var capabilities: PeerCapabilities?
        var bridgeGeohash: String?
        while offset + 2 <= data.count {
            let typeRaw = data[offset]
@@ -87,6 +131,12 @@ struct AnnouncementPacket {
                        }
                        directNeighbors = neighbors
                    }
                case .capabilities:
                    capabilities = PeerCapabilities(encoded: Data(value))
                case .bridgeGeohash:
                    if length <= 12 {
                        bridgeGeohash = String(data: value, encoding: .utf8)
                    }
                }
            } else {
                // Unknown TLV; skip (tolerant decoder for forward compatibility)
@@ -99,7 +149,9 @@ struct AnnouncementPacket {
            nickname: nickname,
            noisePublicKey: noisePublicKey,
            signingPublicKey: signingPublicKey,
-            directNeighbors: directNeighbors
+            directNeighbors: directNeighbors,
            capabilities: capabilities,
            bridgeGeohash: bridgeGeohash
        )
    }
 }
@@ -0,0 +1,7 @@
 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]
 }
@@ -0,0 +1,220 @@
 //
 // VoiceBurstPacket.swift
 // bitchat
 //
 // This is free and unencumbered software released into the public domain.
 // For more information, see <https://unlicense.org>
 //
 import Foundation
 import Security
 /// Audio codec of a live voice burst. START packets carry it so receivers can
 /// reject bursts they can't decode instead of feeding garbage to the decoder.
 enum VoiceBurstCodec: UInt8 {
    /// AAC-LC, 16 kHz, mono, ~16 kbps — matches the voice-note recorder, so
    /// the finalized `.m4a` and the live frames come from the same encoder
    /// settings.
    case aacLC16kMono = 0x01
 }
 /// One packet of a live push-to-talk voice burst (the inner payload of
 /// `NoisePayloadType.voiceFrame`, and — for public mesh bursts — the payload
 /// of `MessageType.voiceFrame`).
 ///
 /// Wire format:
 /// ```
 /// [burstID: 8][seq: UInt16 BE][flags: UInt8][payload…]
 /// ```
 /// - flags 0x01 (START): payload = [codec: UInt8]
 /// - flags 0x02 (END):   payload = [totalDataPackets: UInt16 BE][durationMs: UInt32 BE]
 /// - flags 0x04 (CANCELED): empty payload; receivers discard the burst
 /// - flags 0x00 (data):  payload = repeated [length: UInt16 BE][AAC frame]
 struct VoiceBurstPacket: Equatable {
    enum Kind: Equatable {
        case start(codec: VoiceBurstCodec)
        case frames([Data])
        case end(totalDataPackets: UInt16, durationMs: UInt32)
        case canceled
    }
    static let burstIDSize = 8
    private static let headerSize = burstIDSize + 2 + 1
    /// Sanity cap on frames per packet; real packets carry 1-2 frames.
    static let maxFramesPerPacket = 8
    private enum Flags {
        static let start: UInt8 = 0x01
        static let end: UInt8 = 0x02
        static let canceled: UInt8 = 0x04
    }
    let burstID: Data
    let seq: UInt16
    let kind: Kind
    init?(burstID: Data, seq: UInt16, kind: Kind) {
        guard burstID.count == Self.burstIDSize else { return nil }
        if case .frames(let frames) = kind {
            guard !frames.isEmpty,
                  frames.count <= Self.maxFramesPerPacket,
                  frames.allSatisfy({ !$0.isEmpty && $0.count <= Int(UInt16.max) })
            else { return nil }
        }
        self.burstID = burstID
        self.seq = seq
        self.kind = kind
    }
    func encode() -> Data {
        var data = Data(capacity: Self.headerSize + payloadSize)
        data.append(burstID)
        data.append(UInt8((seq >> 8) & 0xFF))
        data.append(UInt8(seq & 0xFF))
        switch kind {
        case .start(let codec):
            data.append(Flags.start)
            data.append(codec.rawValue)
        case .frames(let frames):
            data.append(0)
            for frame in frames {
                let length = UInt16(frame.count)
                data.append(UInt8((length >> 8) & 0xFF))
                data.append(UInt8(length & 0xFF))
                data.append(frame)
            }
        case .end(let totalDataPackets, let durationMs):
            data.append(Flags.end)
            data.append(UInt8((totalDataPackets >> 8) & 0xFF))
            data.append(UInt8(totalDataPackets & 0xFF))
            for shift in stride(from: 24, through: 0, by: -8) {
                data.append(UInt8((durationMs >> UInt32(shift)) & 0xFF))
            }
        case .canceled:
            data.append(Flags.canceled)
        }
        return data
    }
    static func decode(_ data: Data) -> VoiceBurstPacket? {
        // Work on a re-based copy so subscripting is offset-safe.
        let data = Data(data)
        guard data.count >= headerSize else { return nil }
        let burstID = data.prefix(burstIDSize)
        let seq = (UInt16(data[burstIDSize]) << 8) | UInt16(data[burstIDSize + 1])
        let flags = data[burstIDSize + 2]
        let payload = data.dropFirst(headerSize)
        let kind: Kind
        switch flags {
        case Flags.start:
            guard let codecByte = payload.first,
                  let codec = VoiceBurstCodec(rawValue: codecByte)
            else { return nil }
            kind = .start(codec: codec)
        case Flags.end:
            guard payload.count >= 6 else { return nil }
            let bytes = Array(payload)
            let total = (UInt16(bytes[0]) << 8) | UInt16(bytes[1])
            let duration = bytes[2...5].reduce(UInt32(0)) { ($0 << 8) | UInt32($1) }
            kind = .end(totalDataPackets: total, durationMs: duration)
        case Flags.canceled:
            kind = .canceled
        case 0:
            var frames: [Data] = []
            var offset = payload.startIndex
            while offset < payload.endIndex {
                guard payload.distance(from: offset, to: payload.endIndex) >= 2 else { return nil }
                let length = (Int(payload[offset]) << 8) | Int(payload[payload.index(after: offset)])
                offset = payload.index(offset, offsetBy: 2)
                guard length > 0,
                      payload.distance(from: offset, to: payload.endIndex) >= length,
                      frames.count < maxFramesPerPacket
                else { return nil }
                let end = payload.index(offset, offsetBy: length)
                frames.append(Data(payload[offset..<end]))
                offset = end
            }
            guard !frames.isEmpty else { return nil }
            kind = .frames(frames)
        default:
            return nil
        }
        return VoiceBurstPacket(burstID: Data(burstID), seq: seq, kind: kind)
    }
    static func makeBurstID() -> Data {
        var bytes = Data(count: burstIDSize)
        let result = bytes.withUnsafeMutableBytes {
            SecRandomCopyBytes(kSecRandomDefault, burstIDSize, $0.baseAddress!)
        }
        guard result == errSecSuccess else {
            return Data((0..<burstIDSize).map { _ in UInt8.random(in: .min ... .max) })
        }
        return bytes
    }
    private var payloadSize: Int {
        switch kind {
        case .start: return 1
        case .frames(let frames): return frames.reduce(0) { $0 + 2 + $1.count }
        case .end: return 6
        case .canceled: return 0
        }
    }
 }
 /// Greedy packetizer for outgoing bursts: batches encoded frames into
 /// `VoiceBurstPacket`s without exceeding the byte budget that keeps each
 /// packet in a single BLE frame after Noise encryption and padding.
 /// Not thread-safe — confine to one queue.
 struct VoiceBurstPacketizer {
    let burstID: Data
    private let budget: Int
    private var pendingFrames: [Data] = []
    private var pendingSize = 0
    /// seq 0 is reserved for START; data packets start at 1.
    private(set) var nextSeq: UInt16 = 1
    private(set) var dataPacketCount: UInt16 = 0
    init(burstID: Data, budget: Int = TransportConfig.pttMaxBurstContentBytes) {
        self.burstID = burstID
        self.budget = budget
    }
    /// Adds one encoded frame, returning any packets that became full.
    /// Frames larger than the budget are dropped (the encoder's ~130-byte
    /// frames never hit this; it guards against misconfiguration looping).
    mutating func add(_ frame: Data) -> [Data] {
        let frameCost = 2 + frame.count
        guard VoiceBurstPacket.burstIDSize + 3 + frameCost <= budget else { return [] }
        var packets: [Data] = []
        if !pendingFrames.isEmpty,
           VoiceBurstPacket.burstIDSize + 3 + pendingSize + frameCost > budget
            || pendingFrames.count >= VoiceBurstPacket.maxFramesPerPacket {
            packets.append(contentsOf: flush())
        }
        pendingFrames.append(frame)
        pendingSize += frameCost
        return packets
    }
    /// Emits any buffered frames as a final data packet.
    mutating func flush() -> [Data] {
        guard !pendingFrames.isEmpty,
              let packet = VoiceBurstPacket(burstID: burstID, seq: nextSeq, kind: .frames(pendingFrames))
        else {
            pendingFrames = []
            pendingSize = 0
            return []
        }
        pendingFrames = []
        pendingSize = 0
        nextSeq &+= 1
        dataPacketCount &+= 1
        return [packet.encode()]
    }
 }
@@ -0,0 +1,225 @@
 //
 // VouchAttestation.swift
 // bitchat
 //
 // This is free and unencumbered software released into the public domain.
 // For more information, see <https://unlicense.org>
 //
 import CryptoKit
 import Foundation
 /// A signed statement that the *sender of the enclosing Noise payload* has
 /// verified the identity described here ("transitive verification").
 ///
 /// The voucher's identity is deliberately implicit: attestations only travel
 /// inside an authenticated Noise session (`NoisePayloadType.vouch`), so the
 /// receiver verifies the Ed25519 signature against the session peer's
 /// announce-bound signing key and stores the vouch keyed by that peer's
 /// fingerprint. Nothing in the attestation names the voucher, so a captured
 /// attestation cannot be replayed by a third party whose signing key doesn't
 /// match.
 ///
 /// Wire format — single attestation (TLV, 1-byte type + 1-byte length):
 /// - `0x01` voucheeFingerprint: 32 bytes, SHA-256 of the vouchee's Noise static key
 /// - `0x02` voucheeSigningKey: 32 bytes, Ed25519; anchors the vouch to a concrete identity
 /// - `0x03` timestamp: 8 bytes big-endian, milliseconds since 1970
 /// - `0x04` signature: 64 bytes, Ed25519 by the VOUCHER's signing key over
 ///   `"bitchat-vouch-v1" | voucheeFingerprint | voucheeSigningKey | timestamp`
 ///
 /// Unknown TLV types are skipped for forward compatibility.
 ///
 /// Batch format (the `vouch` Noise payload body):
 /// `[count: UInt8]` then per attestation `[length: UInt16 BE][attestation TLV]`.
 struct VouchAttestation: Equatable {
    static let signingContext = "bitchat-vouch-v1"
    /// Receiver-side expiry for attestations.
    static let maxAge: TimeInterval = 30 * 24 * 60 * 60
    /// Tolerated clock skew for attestations timestamped in the future.
    static let maxClockSkew: TimeInterval = 60 * 60
    /// Upper bound of attestations carried/accepted in one batch payload.
    static let maxBatchCount = 16
    static let fingerprintSize = 32
    static let signingKeySize = 32
    static let signatureSize = 64
    let voucheeFingerprint: Data  // 32 bytes
    let voucheeSigningKey: Data   // 32 bytes
    let timestampMs: UInt64
    let signature: Data           // 64 bytes
    private enum TLVType: UInt8 {
        case voucheeFingerprint = 0x01
        case voucheeSigningKey = 0x02
        case timestamp = 0x03
        case signature = 0x04
    }
    var voucheeFingerprintHex: String { voucheeFingerprint.hexEncodedString() }
    var timestamp: Date { Date(timeIntervalSince1970: TimeInterval(timestampMs) / 1000) }
    /// The exact bytes the voucher signs.
    static func signableBytes(
        voucheeFingerprint: Data,
        voucheeSigningKey: Data,
        timestampMs: UInt64
    ) -> Data {
        var message = Data(signingContext.utf8)
        message.append(voucheeFingerprint)
        message.append(voucheeSigningKey)
        var timestampBE = timestampMs.bigEndian
        withUnsafeBytes(of: &timestampBE) { message.append(contentsOf: $0) }
        return message
    }
    var signableBytes: Data {
        Self.signableBytes(
            voucheeFingerprint: voucheeFingerprint,
            voucheeSigningKey: voucheeSigningKey,
            timestampMs: timestampMs
        )
    }
    /// Builds and signs an attestation. `sign` is the voucher's Ed25519
    /// signing primitive (e.g. `Transport.noiseSignData`).
    static func build(
        voucheeFingerprint: Data,
        voucheeSigningKey: Data,
        timestampMs: UInt64 = UInt64(Date().timeIntervalSince1970 * 1000),
        sign: (Data) -> Data?
    ) -> VouchAttestation? {
        guard voucheeFingerprint.count == fingerprintSize,
              voucheeSigningKey.count == signingKeySize else { return nil }
        let message = signableBytes(
            voucheeFingerprint: voucheeFingerprint,
            voucheeSigningKey: voucheeSigningKey,
            timestampMs: timestampMs
        )
        guard let signature = sign(message), signature.count == signatureSize else { return nil }
        return VouchAttestation(
            voucheeFingerprint: voucheeFingerprint,
            voucheeSigningKey: voucheeSigningKey,
            timestampMs: timestampMs,
            signature: signature
        )
    }
    /// Verifies the Ed25519 signature against the voucher's announce-bound
    /// signing key.
    func verifySignature(voucherSigningKey: Data) -> Bool {
        guard let publicKey = try? Curve25519.Signing.PublicKey(rawRepresentation: voucherSigningKey) else {
            return false
        }
        return publicKey.isValidSignature(signature, for: signableBytes)
    }
    /// Whether the attestation is outside its validity window (older than
    /// `maxAge`, or timestamped implausibly far in the future).
    func isExpired(now: Date = Date()) -> Bool {
        let age = now.timeIntervalSince(timestamp)
        return age > Self.maxAge || age < -Self.maxClockSkew
    }
    // MARK: - Encoding
    func encode() -> Data? {
        guard voucheeFingerprint.count == Self.fingerprintSize,
              voucheeSigningKey.count == Self.signingKeySize,
              signature.count == Self.signatureSize else { return nil }
        var data = Data()
        func appendTLV(_ type: TLVType, _ value: Data) {
            data.append(type.rawValue)
            data.append(UInt8(value.count))
            data.append(value)
        }
        appendTLV(.voucheeFingerprint, voucheeFingerprint)
        appendTLV(.voucheeSigningKey, voucheeSigningKey)
        var timestampBE = timestampMs.bigEndian
        appendTLV(.timestamp, withUnsafeBytes(of: &timestampBE) { Data($0) })
        appendTLV(.signature, signature)
        return data
    }
    static func decode(from data: Data) -> VouchAttestation? {
        var fingerprint: Data?
        var signingKey: Data?
        var timestampMs: UInt64?
        var signature: Data?
        var offset = data.startIndex
        while offset < data.endIndex {
            guard data.index(offset, offsetBy: 2, limitedBy: data.endIndex) != nil,
                  offset + 1 < data.endIndex else { return nil }
            let type = data[offset]
            let length = Int(data[offset + 1])
            let valueStart = offset + 2
            guard let valueEnd = data.index(valueStart, offsetBy: length, limitedBy: data.endIndex) else {
                return nil
            }
            let value = Data(data[valueStart..<valueEnd])
            switch TLVType(rawValue: type) {
            case .voucheeFingerprint:
                guard value.count == fingerprintSize else { return nil }
                fingerprint = value
            case .voucheeSigningKey:
                guard value.count == signingKeySize else { return nil }
                signingKey = value
            case .timestamp:
                guard value.count == 8 else { return nil }
                timestampMs = value.reduce(UInt64(0)) { ($0 << 8) | UInt64($1) }
            case .signature:
                guard value.count == signatureSize else { return nil }
                signature = value
            case nil:
                break // Unknown TLV: skip for forward compatibility.
            }
            offset = valueEnd
        }
        guard let fingerprint, let signingKey, let timestampMs, let signature else { return nil }
        return VouchAttestation(
            voucheeFingerprint: fingerprint,
            voucheeSigningKey: signingKey,
            timestampMs: timestampMs,
            signature: signature
        )
    }
    // MARK: - Batch encoding
    /// Encodes up to `maxBatchCount` attestations into one payload body.
    static func encodeList(_ attestations: [VouchAttestation]) -> Data? {
        guard !attestations.isEmpty, attestations.count <= maxBatchCount else { return nil }
        var data = Data()
        data.append(UInt8(attestations.count))
        for attestation in attestations {
            guard let encoded = attestation.encode(), encoded.count <= Int(UInt16.max) else { return nil }
            var lengthBE = UInt16(encoded.count).bigEndian
            withUnsafeBytes(of: &lengthBE) { data.append(contentsOf: $0) }
            data.append(encoded)
        }
        return data
    }
    /// Decodes a batch payload, dropping malformed entries and ignoring
    /// anything beyond `maxBatchCount` (sender-declared count is not trusted).
    static func decodeList(from data: Data) -> [VouchAttestation] {
        guard data.count > 1 else { return [] }
        let declaredCount = Int(data[data.startIndex])
        let limit = min(declaredCount, maxBatchCount)
        var attestations: [VouchAttestation] = []
        var offset = data.startIndex + 1
        while attestations.count < limit, offset < data.endIndex {
            guard let lengthEnd = data.index(offset, offsetBy: 2, limitedBy: data.endIndex) else { break }
            let length = Int(data[offset]) << 8 | Int(data[offset + 1])
            guard let entryEnd = data.index(lengthEnd, offsetBy: length, limitedBy: data.endIndex) else { break }
            if let attestation = decode(from: Data(data[lengthEnd..<entryEnd])) {
                attestations.append(attestation)
            }
            offset = entryEnd
        }
        return attestations
    }
 }
@@ -11,13 +11,6 @@ import Foundation
 /// Manages autocomplete functionality for chat
 final class AutocompleteService {
    private let mentionRegex = try? NSRegularExpression(pattern: "@([\\p{L}0-9_]*)$", options: [])
    private let commandRegex = try? NSRegularExpression(pattern: "^/([a-z]*)$", options: [])
    private let commands = [
        "/msg", "/who", "/clear",
        "/hug", "/slap", "/fav", "/unfav",
        "/block", "/unblock"
    ]
    /// Get autocomplete suggestions for current text
    func getSuggestions(for text: String, peers: [String], cursorPosition: Int) -> (suggestions: [String], range: NSRange?) {
@@ -73,26 +66,6 @@ final class AutocompleteService {
        return suggestions.isEmpty ? nil : (Array(suggestions), fullRange)
    }
    private func getCommandSuggestions(_ text: String) -> ([String], NSRange)? {
        guard let regex = commandRegex else { return nil }
        let nsText = text as NSString
        let matches = regex.matches(in: text, options: [], range: NSRange(location: 0, length: nsText.length))
        guard let match = matches.last else { return nil }
        let fullRange = match.range(at: 0)
        let captureRange = match.range(at: 1)
        let prefix = nsText.substring(with: captureRange).lowercased()
        let suggestions = commands
            .filter { $0.hasPrefix("/\(prefix)") }
            .sorted()
            .prefix(5)
        return suggestions.isEmpty ? nil : (Array(suggestions), fullRange)
    }
    private func needsArgument(command: String) -> Bool {
        switch command {
        case "/who", "/clear":
@@ -20,6 +20,12 @@ struct BLEAnnounceHandlerEnvironment {
    let verifySignature: (_ packet: BitchatPacket, _ signingPublicKey: Data) -> Bool
    /// Direct link state for the peer (BLE-queue read).
    let linkState: (PeerID) -> (hasPeripheral: Bool, hasCentral: Bool)
    /// Whether the link this packet arrived on is already bound to a
    /// different peer ID (ingress-registry + BLE-queue read). Directness
    /// rides on the unsigned TTL, so a replayed announce can look "direct"
    /// on the replayer's link; that link must not shortcut an absent peer
    /// into "connected".
    let linkBoundToOtherPeer: (_ packet: BitchatPacket, _ peerID: PeerID) -> Bool
    /// Runs the registry mutation phase under the collections barrier.
    let withRegistryBarrier: (() -> Void) -> Void
    /// Upserts the verified announce into the peer registry.
@@ -59,6 +65,15 @@ struct BLEAnnounceHandlerEnvironment {
    let scheduleAfterglow: (TimeInterval) -> Void
 }
 /// Outcome of an accepted announce, surfaced so the service can run
 /// follow-up work (e.g. courier handover) that keys off the announce.
 struct BLEAnnounceHandlingResult {
    let peerID: PeerID
    let announcement: AnnouncementPacket
    let isDirectAnnounce: Bool
    let isVerified: Bool
 }
 /// Orchestrates inbound announce packets: preflight validation, signature
 /// trust, registry/topology updates, identity persistence, UI notification,
 /// gossip tracking, and the reciprocal announce response.
@@ -69,7 +84,8 @@ final class BLEAnnounceHandler {
        self.environment = environment
    }
-    func handle(_ packet: BitchatPacket, from peerID: PeerID) {
+    @discardableResult
    func handle(_ packet: BitchatPacket, from peerID: PeerID) -> BLEAnnounceHandlingResult? {
        let env = environment
        let now = env.now()
        let preflight = BLEAnnouncePreflightPolicy.evaluate(
@@ -85,15 +101,15 @@ final class BLEAnnounceHandler {
            announcement = acceptance.announcement
        case .reject(.malformed):
            SecureLogger.error("❌ Failed to decode announce packet from \(peerID.id.prefix(8))…", category: .session)
-            return
+            return nil
        case .reject(.senderMismatch(let derivedFromKey)):
            SecureLogger.warning("⚠️ Announce sender mismatch: derived \(derivedFromKey.id.prefix(8))… vs packet \(peerID.id.prefix(8))…", category: .security)
-            return
+            return nil
        case .reject(.selfAnnounce):
-            return
+            return nil
        case .reject(.stale(let ageSeconds)):
            SecureLogger.debug("⏰ Ignoring stale announce from \(peerID.id.prefix(8))… (age: \(ageSeconds)s)", category: .session)
-            return
+            return nil
        }
        // Suppress announce logs to reduce noise
@@ -125,6 +141,23 @@ final class BLEAnnounceHandler {
        var isReconnectedPeer = false
        let directLinkState = env.linkState(peerID)
        let isDirectAnnounce = packet.ttl == env.messageTTL
        // A "direct" announce arriving on a link that another peer already
        // owns is either a rotation heal or a replay with its TTL restored;
        // both are ambiguous, so only the rebind (which containment-checks
        // the claimed identity) may promote it — never this shortcut.
        //
        // Known limitation: denying the shortcut cannot prevent forged
        // presence outright. A rebind that passes the containment checks
        // promotes the claimed peer to connected — it must, or a legitimate
        // rotation on an open link would read as disconnected — so a replay
        // that wins the rebind (absent victim, cooldown clear) still forges
        // presence. That residue is presence display only: DMs stay gated on
        // canDeliverSecurely (no Noise session means retain + courier, see
        // MessageRouter.sendPrivate). What this check buys: the ambiguous
        // announce alone never flips presence — forging requires winning the
        // containment-checked rebind (never steals an identity that owns a
        // live link; at most one rebind per link per cooldown window).
        let linkBoundToOtherPeer = isDirectAnnounce && env.linkBoundToOtherPeer(packet, peerID)
        env.withRegistryBarrier {
            let hasPeripheralConnection = directLinkState.hasPeripheral
@@ -142,7 +175,7 @@ final class BLEAnnounceHandler {
            let update = env.upsertVerifiedAnnounce(
                peerID,
                announcement,
-                isDirectAnnounce || hasPeripheralConnection || hasCentralSubscription,
+                hasPeripheralConnection || hasCentralSubscription || (isDirectAnnounce && !linkBoundToOtherPeer),
                now
            )
            isNewPeer = update.isNewPeer
@@ -210,5 +243,12 @@ final class BLEAnnounceHandler {
            let delay = Double.random(in: 0.3...0.6)
            env.scheduleAfterglow(delay)
        }
        return BLEAnnounceHandlingResult(
            peerID: peerID,
            announcement: announcement,
            isDirectAnnounce: isDirectAnnounce,
            isVerified: verifiedAnnounce
        )
    }
 }
@@ -15,20 +15,58 @@ enum BLEFanoutSelector {
        excludedLinks: Set<BLEIngressLinkID> = [],
        peripheralPeerBindings: [String: PeerID] = [:],
        centralPeerBindings: [String: PeerID] = [:],
        preferredPeripheralPerPeer: [PeerID: String] = [:],
        collapseDuplicatePeerLinks: Bool = true,
        directedPeerHint: PeerID?,
        requireDirectPeerLink: Bool = false,
        packetType: UInt8,
        messageID: String
    ) -> BLEFanoutSelection {
-        let allowed = collapseDuplicateLinksPerPeer(
+        let rawAllowed = allowedLinks(
            allowedLinks(
            peripheralIDs: peripheralIDs,
            centralIDs: centralIDs,
            ingressLink: ingressLink,
            excludedLinks: excludedLinks
-            ),
+        )
        if let directedPeerHint,
           let directedSelection = directLinks(
               to: directedPeerHint,
               links: rawAllowed,
               peripheralPeerBindings: peripheralPeerBindings,
               centralPeerBindings: centralPeerBindings,
               preferredPeripheralPerPeer: preferredPeripheralPerPeer
           ) {
            return directedSelection
        }
        if directedPeerHint != nil, requireDirectPeerLink {
            return BLEFanoutSelection(peripheralIDs: [], centralIDs: [])
        }
        if let directedPeerHint,
           hasBoundLink(
               to: directedPeerHint,
               peripheralIDs: peripheralIDs,
               centralIDs: centralIDs,
               peripheralPeerBindings: peripheralPeerBindings,
               centralPeerBindings: centralPeerBindings
           ) {
            return BLEFanoutSelection(peripheralIDs: [], centralIDs: [])
        }
        // Direct announces are the packet that binds a link to its peer
        // (BLEService's raw bind and verified rebind). Collapsing them per
        // peer starves duplicate same-peer links of the announce they need to
        // become bound — the duplicates then look "pre-announce" forever and
        // every broadcast sprays down all of them. Announces are small and
        // throttled, so they go on every live link.
        let allowed = collapseDuplicatePeerLinks
            ? collapseDuplicateLinksPerPeer(
                rawAllowed,
                peripheralPeerBindings: peripheralPeerBindings,
                centralPeerBindings: centralPeerBindings,
                preferredPeripheralPerPeer: preferredPeripheralPerPeer
            )
            : rawAllowed
        guard shouldSubset(packetType: packetType, directedPeerHint: directedPeerHint) else {
            return BLEFanoutSelection(
@@ -71,6 +109,44 @@ enum BLEFanoutSelector {
        return (allowedPeripheralIDs, allowedCentralIDs)
    }
    private static func directLinks(
        to peerID: PeerID,
        links: (peripheralIDs: [String], centralIDs: [String]),
        peripheralPeerBindings: [String: PeerID],
        centralPeerBindings: [String: PeerID],
        preferredPeripheralPerPeer: [PeerID: String]
    ) -> BLEFanoutSelection? {
        let directLinks = collapseDuplicateLinksPerPeer(
            (
                peripheralIDs: links.peripheralIDs.filter { peripheralPeerBindings[$0] == peerID },
                centralIDs: links.centralIDs.filter { centralPeerBindings[$0] == peerID }
            ),
            peripheralPeerBindings: peripheralPeerBindings,
            centralPeerBindings: centralPeerBindings,
            preferredPeripheralPerPeer: preferredPeripheralPerPeer
        )
        guard !directLinks.peripheralIDs.isEmpty || !directLinks.centralIDs.isEmpty else {
            return nil
        }
        return BLEFanoutSelection(
            peripheralIDs: Set(directLinks.peripheralIDs),
            centralIDs: Set(directLinks.centralIDs)
        )
    }
    private static func hasBoundLink(
        to peerID: PeerID,
        peripheralIDs: [String],
        centralIDs: [String],
        peripheralPeerBindings: [String: PeerID],
        centralPeerBindings: [String: PeerID]
    ) -> Bool {
        peripheralIDs.contains { peripheralPeerBindings[$0] == peerID }
            || centralIDs.contains { centralPeerBindings[$0] == peerID }
    }
    // Dual-role pairs hold two live links (we-as-central writing to their
    // peripheral, and they-as-central subscribed to ours). Sending the same
    // packet down both doubles airtime for nothing — the receiver's assembler
@@ -82,7 +158,8 @@ enum BLEFanoutSelector {
    private static func collapseDuplicateLinksPerPeer(
        _ links: (peripheralIDs: [String], centralIDs: [String]),
        peripheralPeerBindings: [String: PeerID],
-        centralPeerBindings: [String: PeerID]
+        centralPeerBindings: [String: PeerID],
        preferredPeripheralPerPeer: [PeerID: String]
    ) -> (peripheralIDs: [String], centralIDs: [String]) {
        guard !peripheralPeerBindings.isEmpty || !centralPeerBindings.isEmpty else {
            return links
@@ -90,13 +167,30 @@ enum BLEFanoutSelector {
        var seenPeers = Set<PeerID>()
        var keptPeripheralIDs: [String] = []
        // When a peer has several bound peripheral links (duplicate
        // connections after a restore), collapse onto its preferred one (the
        // most recently bound) instead of dictionary order — an arbitrary
        // pick could route a peer's single collapsed copy down a stale link.
        for id in links.peripheralIDs {
-            if let peer = peripheralPeerBindings[id], !seenPeers.insert(peer).inserted {
+            guard let peer = peripheralPeerBindings[id],
-                continue
+                  preferredPeripheralPerPeer[peer] == id,
                  seenPeers.insert(peer).inserted else { continue }
            keptPeripheralIDs.append(id)
        }
        for id in links.peripheralIDs {
            if let peer = peripheralPeerBindings[id] {
                if preferredPeripheralPerPeer[peer] == id { continue }
                if !seenPeers.insert(peer).inserted { continue }
            }
            keptPeripheralIDs.append(id)
        }
        // Known limitation: centrals collapse in subscription order (oldest
        // first) — there is no recency signal like the peripheral reverse
        // map. A central-only peer with duplicate subscriptions rides the
        // oldest one until the remote side (which owns those connections)
        // consolidates on its next verified announce (bounded by its
        // retirement cooldown).
        var keptCentralIDs: [String] = []
        for id in links.centralIDs {
            if let peer = centralPeerBindings[id], !seenPeers.insert(peer).inserted {
@@ -14,6 +14,8 @@ struct BLEFileTransferHandlerEnvironment {
    let localNickname: () -> String
    /// Snapshot of known peers keyed by ID (registry read).
    let peersSnapshot: () -> [PeerID: BLEPeerInfo]
    /// Verifies a packet's signature against a candidate signing key (registry path).
    let verifyPacketSignature: (_ packet: BitchatPacket, _ signingPublicKey: Data) -> Bool
    /// 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.
@@ -44,25 +46,32 @@ final class BLEFileTransferHandler {
        self.environment = environment
    }
-    func handle(_ packet: BitchatPacket, from peerID: PeerID) {
+    /// 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
-        if BLEFileTransferPolicy.isSelfEcho(packet: packet, from: peerID, localPeerID: env.localPeerID()) { return }
+        if BLEFileTransferPolicy.isSelfEcho(packet: packet, from: peerID, localPeerID: env.localPeerID()) { return true }
        let peersSnapshot = env.peersSnapshot()
        guard let senderNickname = BLEPeerSenderDisplayName.resolveKnownPeer(
            peerID: peerID,
            localPeerID: env.localPeerID(),
            localNickname: env.localNickname(),
            peers: peersSnapshot,
            allowConnectedUnverified: true
        ) ?? env.signedSenderDisplayName(packet, peerID) else {
            SecureLogger.warning("🚫 Dropping file transfer from unverified or unknown peer \(peerID.id.prefix(8))…", category: .security)
            return
        }
        guard let deliveryPlan = BLEFileTransferPolicy.deliveryPlan(packet: packet, localPeerID: env.localPeerID()) else {
-            return
+            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 file transfer from unverified or unknown peer \(peerID.id.prefix(8))…", category: .security)
            return false
        }
        if deliveryPlan.shouldTrackForSync {
            env.trackPacketSeen(packet)
        }
@@ -75,16 +84,16 @@ final class BLEFileTransferHandler {
            mime = acceptance.mime
        case .failure(.malformedPayload):
            SecureLogger.error("❌ Failed to decode file transfer payload", category: .session)
-            return
+            return true
        case .failure(.payloadTooLarge(let bytes)):
            SecureLogger.warning("🚫 Dropping file transfer exceeding size cap (\(bytes) bytes)", category: .security)
-            return
+            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
+            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
+            return true
        }
        // BCH-01-002: Enforce storage quota before saving
@@ -97,7 +106,7 @@ final class BLEFileTransferHandler {
            mime.defaultExtension,
            mime.category.rawValue
        ) else {
-            return
+            return true
        }
        if deliveryPlan.isPrivateMessage {
@@ -113,11 +122,66 @@ final class BLEFileTransferHandler {
            originalSender: nil,
            isPrivate: deliveryPlan.isPrivateMessage,
            recipientNickname: nil,
-            senderPeerID: peerID
+            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)
        env.deliverMessage(message)
        return true
    }
    /// 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 isBroadcast else {
            return BLEPeerSenderDisplayName.resolveKnownPeer(
                peerID: peerID,
                localPeerID: env.localPeerID(),
                localNickname: env.localNickname(),
                peers: peers,
                allowConnectedUnverified: true
            ) ?? env.signedSenderDisplayName(packet, peerID)
        }
        // 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: env.localPeerID(),
            localNickname: env.localNickname(),
            peers: peers,
            allowConnectedUnverified: false
        ) ?? signedDisplayName
    }
 }
@@ -61,9 +61,11 @@ struct BLEFragmentAssemblyBuffer {
    }
    private struct Metadata {
        let type: UInt8
        let total: Int
        let timestamp: Date
        let isBroadcast: Bool
        var lastFragmentAt: Date
        var lastResyncRequestAt: Date?
    }
    private var fragmentsByKey: [BLEFragmentKey: [Int: Data]] = [:]
@@ -105,7 +107,15 @@ struct BLEFragmentAssemblyBuffer {
            return .oversized(header: header, projectedSize: projectedSize, limit: limit, started: started)
        }
        // Only actual progress resets the stall clock: fragment packets
        // bypass the packet deduplicator, so relayed duplicates of an
        // already-held index must not keep suppressing the targeted
        // REQUEST_SYNC for a stalled stream.
        let isNewIndex = fragmentsByKey[header.key]?[header.index] == nil
        fragmentsByKey[header.key]?[header.index] = header.fragmentData
        if isNewIndex {
            metadataByKey[header.key]?.lastFragmentAt = now
        }
        guard let fragments = fragmentsByKey[header.key],
              fragments.count == header.total else {
@@ -138,10 +148,58 @@ struct BLEFragmentAssemblyBuffer {
        }
        fragmentsByKey[header.key] = [:]
-        metadataByKey[header.key] = Metadata(type: header.originalType, total: header.total, timestamp: now)
+        metadataByKey[header.key] = Metadata(
            total: header.total,
            timestamp: now,
            isBroadcast: header.isBroadcastFragment,
            lastFragmentAt: now
        )
        return true
    }
    /// Fragment stream IDs (8-byte, big-endian) of incomplete broadcast
    /// reassemblies that have not seen a new fragment for `stalledAfter`
    /// seconds — candidates for a targeted REQUEST_SYNC. Each returned
    /// stream is marked so it is not re-requested within `retryAfter`.
    /// At most `RequestSyncPacket.maxFragmentIdFilterCount` streams are
    /// returned per pass — the wire filter cannot carry more — selected
    /// oldest-stall first; overflow streams stay unmarked and eligible for
    /// the next pass. Directed reassemblies are excluded: peers only archive
    /// broadcast fragments for gossip sync, so a targeted request cannot
    /// recover them.
    mutating func stalledBroadcastFragmentIDs(
        stalledAfter: TimeInterval,
        retryAfter: TimeInterval,
        now: Date = Date()
    ) -> [Data] {
        var candidates: [(key: BLEFragmentKey, lastFragmentAt: Date)] = []
        for (key, metadata) in metadataByKey {
            guard metadata.isBroadcast,
                  let fragments = fragmentsByKey[key],
                  fragments.count < metadata.total,
                  now.timeIntervalSince(metadata.lastFragmentAt) >= stalledAfter else { continue }
            if let lastRequest = metadata.lastResyncRequestAt,
               now.timeIntervalSince(lastRequest) < retryAfter { continue }
            candidates.append((key: key, lastFragmentAt: metadata.lastFragmentAt))
        }
        // Mark only the streams that will actually go on the wire, so the
        // overflow is not silently suppressed for `retryAfter`.
        let selected = candidates
            .sorted {
                if $0.lastFragmentAt != $1.lastFragmentAt {
                    return $0.lastFragmentAt < $1.lastFragmentAt
                }
                return ($0.key.sender, $0.key.id) < ($1.key.sender, $1.key.id)
            }
            .prefix(RequestSyncPacket.maxFragmentIdFilterCount)
        return selected.map { candidate in
            metadataByKey[candidate.key]?.lastResyncRequestAt = now
            return withUnsafeBytes(of: candidate.key.id.bigEndian) { Data($0) }
        }
    }
    private static func assemblyLimit(for originalType: UInt8) -> Int {
        if originalType == MessageType.fileTransfer.rawValue {
            // Allow headroom for TLV metadata and binary framing overhead.
@@ -33,13 +33,21 @@ final class BLEFragmentHandler {
    func handle(_ packet: BitchatPacket, from peerID: PeerID) {
        let env = environment
-        // Don't process our own fragments
+        guard let header = BLEFragmentHeader(packet: packet) else { return }
        // Sync replay legitimately hands us our own fragments back (the RSR
        // ttl=0 restore path): after a relaunch the fragment store starts
        // empty, so our sync filter doesn't cover them and peers re-offer
        // them. Record them as seen — the next round's filter then covers
        // them and the redelivery stops — but skip assembly: we authored
        // the original, there is nothing to reassemble.
        if peerID == env.localPeerID() {
            if header.isBroadcastFragment {
                env.trackPacketSeen(packet)
            }
            return
        }
        guard let header = BLEFragmentHeader(packet: packet) else { return }
        if header.isBroadcastFragment {
            env.trackPacketSeen(packet)
        }
@@ -5,7 +5,16 @@ import Foundation
 struct BLEIncomingFileStore {
    private static let quotaBytes: Int64 = 100 * 1024 * 1024
-    private let fileManager: FileManager
+    /// Name prefix of in-flight live voice captures (progressively written by
    /// `ChatLiveVoiceCoordinator`). Quota eviction skips them by pattern —
    /// deleting one mid-stream unlinks the inode under an open `FileHandle`
    /// and kills playback — and the coordinator's startup sweep deletes any
    /// orphans a previous session left behind.
    static let liveCapturePrefix = "voice_live_"
    /// Exposed so callers that write progressively into the store's
    /// directories (live voice captures) share the same file manager.
    let fileManager: FileManager
    private let baseDirectory: URL?
    private let dateProvider: () -> Date
@@ -15,6 +24,14 @@ struct BLEIncomingFileStore {
        self.dateProvider = dateProvider
    }
    /// Resolves (and creates) an incoming-media directory for callers that
    /// write progressively instead of via `save` (live voice captures).
    func incomingDirectory(subdirectory: String) throws -> URL {
        let directory = try filesDirectory().appendingPathComponent(subdirectory, isDirectory: true)
        try fileManager.createDirectory(at: directory, withIntermediateDirectories: true, attributes: nil)
        return directory
    }
    func save(
        data: Data,
        preferredName: String?,
@@ -39,6 +56,11 @@ struct BLEIncomingFileStore {
        }
    }
    /// 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 —
    /// a finalized transfer can arrive at quota while a burst is still
    /// streaming — but they still count toward usage.
    func enforceQuota(reservingBytes: Int) {
        do {
            let base = try filesDirectory()
@@ -72,6 +94,7 @@ struct BLEIncomingFileStore {
            var freedSpace: Int64 = 0
            for file in allFiles.sorted(by: { $0.modified < $1.modified }) {
                guard freedSpace < needToFree else { break }
                guard !file.url.lastPathComponent.hasPrefix(Self.liveCapturePrefix) else { continue }
                do {
                    try fileManager.removeItem(at: file.url)
                    freedSpace += file.size
@@ -78,11 +78,22 @@ struct BLEIngressLinkRegistry {
            return .failure(.selfLoopback(packetType: packet.type))
        }
-        if let boundPeerID,
+        if let boundPeerID, boundPeerID != claimedSenderID {
-           boundPeerID != claimedSenderID,
+            if requiresDirectSenderBinding(packet) {
           requiresDirectSenderBinding(packet, directAnnounceTTL: directAnnounceTTL) {
                return .failure(.directSenderMismatch(boundPeerID: boundPeerID, claimedSenderID: claimedSenderID))
            }
            // A direct announce claiming a new sender on a bound link is either
            // a spoof or a legitimate peer-ID rotation on a connection that
            // outlived the old ID. Attribute it to the claimed sender and let
            // it through: announces are self-authenticating, and only a
            // signature-verified announce may rebind the link (BLEService).
            if isDirectAnnounce(packet, directAnnounceTTL: directAnnounceTTL) {
                return .success(BLEIngressPacketContext(
                    receivedFromPeerID: claimedSenderID,
                    validationPeerID: claimedSenderID
                ))
            }
        }
        let receivedFromPeerID = boundPeerID ?? claimedSenderID
        let validationPeerID = packet.isRSR ? receivedFromPeerID : claimedSenderID
@@ -98,7 +109,14 @@ struct BLEIngressLinkRegistry {
        return "\(senderID)-\(packet.timestamp)-\(packet.type)-\(digestPrefix)"
    }
-    private static func requiresDirectSenderBinding(_ packet: BitchatPacket, directAnnounceTTL: UInt8) -> Bool {
+    private static func requiresDirectSenderBinding(_ packet: BitchatPacket) -> Bool {
        // REQUEST_SYNC is never relayed, so on a bound link the claimed sender
        // must be the link peer — it elicits a full store replay, and the
        // response is addressed to whoever the sender claims to be.
        packet.type == MessageType.requestSync.rawValue
    }
    static func isDirectAnnounce(_ packet: BitchatPacket, directAnnounceTTL: UInt8) -> Bool {
        packet.type == MessageType.announce.rawValue && packet.ttl == directAnnounceTTL
    }
@@ -164,7 +164,11 @@ final class BLELinkStateStore {
        guard let peerID else { return [] }
        var links: Set<BLEIngressLinkID> = []
-        if let peripheralUUID = peerToPeripheralUUID[peerID] {
+        // Scan all states rather than the 1:1 reverse map: after a state
        // restoration the same device can hold several live peripheral links
        // bound to one peer (it reappears under a fresh UUID while the
        // restored connection lives on).
        for (peripheralUUID, state) in peripherals where state.peerID == peerID {
            links.insert(.peripheral(peripheralUUID))
        }
        for (centralUUID, mappedPeerID) in centralToPeerID where mappedPeerID == peerID {
@@ -173,6 +177,13 @@ final class BLELinkStateStore {
        return links
    }
    /// The peer's most recently bound peripheral link, per peer. Used to keep
    /// duplicate-link fanout collapse deterministic (see BLEFanoutSelector).
    var preferredPeripheralBindings: [PeerID: String] {
        assertOwned()
        return peerToPeripheralUUID
    }
    func peerID(forPeripheralID peripheralID: String) -> PeerID? {
        assertOwned()
        return peripherals[peripheralID]?.peerID
@@ -203,17 +214,38 @@ final class BLELinkStateStore {
    func bindPeripheral(_ peripheralUUID: String, to peerID: PeerID) {
        assertOwned()
-        if updatePeripheral(peripheralUUID, { $0.peerID = peerID }) != nil {
+        var previousPeerID: PeerID?
-            peerToPeripheralUUID[peerID] = peripheralUUID
+        let updated = updatePeripheral(peripheralUUID) {
            previousPeerID = $0.peerID
            $0.peerID = peerID
        }
        guard updated != nil else { return }
        // Rebinding (peer-ID rotation): drop the retired ID's reverse mapping
        // so the old peer no longer claims this link.
        if let previousPeerID, previousPeerID != peerID,
           peerToPeripheralUUID[previousPeerID] == peripheralUUID {
            peerToPeripheralUUID.removeValue(forKey: previousPeerID)
        }
        peerToPeripheralUUID[peerID] = peripheralUUID
    }
    func removePeripheral(_ peripheralID: String) -> PeerID? {
        assertOwned()
        let peerID = peripherals.removeValue(forKey: peripheralID)?.peerID
-        if let peerID {
+        // Only clear (or repair) the reverse map when it points at the removed
        // link: with duplicate links to one peer, removing a stale duplicate
        // must not strand the peer's surviving bound link.
        if let peerID, peerToPeripheralUUID[peerID] == peripheralID {
            // Prefer a writable survivor: repairing onto a link that is
            // mid-service-rediscovery would strand directed sends until the
            // characteristic comes back.
            let survivors = peripherals.filter { $0.value.peerID == peerID && $0.value.isConnected }
            if let survivorUUID = survivors.first(where: { $0.value.characteristic != nil })?.key ?? survivors.first?.key {
                peerToPeripheralUUID[peerID] = survivorUUID
            } else {
                peerToPeripheralUUID.removeValue(forKey: peerID)
            }
        }
        return peerID
    }
@@ -25,9 +25,4 @@ final class BLELogRateLimiter {
        }
    }
    func removeAll() {
        queue.sync {
            lastLogTimeByKey.removeAll()
        }
    }
 }
@@ -7,11 +7,54 @@ struct BLEOutboundFragmentTransferRequest {
    let maxChunk: Int?
    let directedPeer: PeerID?
    let transferId: String?
    let requireDirectPeerLink: Bool
    let requireNoiseAuthenticatedPeerLink: Bool
    init(
        packet: BitchatPacket,
        pad: Bool,
        maxChunk: Int?,
        directedPeer: PeerID?,
        transferId: String?,
        requireDirectPeerLink: Bool = false,
        requireNoiseAuthenticatedPeerLink: Bool = false
    ) {
        self.packet = packet
        self.pad = pad
        self.maxChunk = maxChunk
        self.directedPeer = directedPeer
        self.transferId = transferId
        self.requireDirectPeerLink = requireDirectPeerLink
        self.requireNoiseAuthenticatedPeerLink = requireNoiseAuthenticatedPeerLink
    }
    var resolvedTransferId: String? {
        guard packet.type == MessageType.fileTransfer.rawValue else { return nil }
        return transferId ?? packet.payload.sha256Hex()
    }
    /// Content identity independent of the caller-chosen transfer ID: the
    /// same file resent through another path (gossip-sync replay, retry)
    /// arrives with a different explicit transferId but identical payload.
    var contentKey: String? {
        guard packet.type == MessageType.fileTransfer.rawValue else { return nil }
        return packet.payload.sha256Hex()
    }
 }
 /// Transactional admission for strict fragment trains. Durable callers may
 /// commit only when every fragment was accepted; the first rejection stops
 /// the train and reports failure so the original remains retryable.
 enum BLEStrictFragmentAdmission {
    static func admitAll<Fragment>(
        _ fragments: [Fragment],
        accepting: (Fragment) -> Bool
    ) -> Bool {
        for fragment in fragments where !accepting(fragment) {
            return false
        }
        return true
    }
 }
 struct BLEOutboundFragmentTransferScheduler {
@@ -23,6 +66,16 @@ struct BLEOutboundFragmentTransferScheduler {
    enum SubmitResult {
        case start(request: BLEOutboundFragmentTransferRequest, reservedTransferId: String?)
        case queued(request: BLEOutboundFragmentTransferRequest, transferId: String?, position: QueuePosition)
        /// Strict direct-link requests are transactional: returning false to
        /// their durable owner must mean no process-local copy remains that
        /// can transmit later. They are therefore start-or-reject, never
        /// admitted to `pendingTransfers`.
        case rejectedStrict(request: BLEOutboundFragmentTransferRequest, transferId: String?)
        /// The same file is already being (or waiting to be) fragmented out
        /// to an audience covering this request; sending it again would just
        /// double the airtime (field-verified: one 41KB voice file went out
        /// as two complete fragment streams).
        case droppedDuplicate(request: BLEOutboundFragmentTransferRequest, activeTransferId: String?)
    }
    enum CancelResult {
@@ -38,14 +91,34 @@ struct BLEOutboundFragmentTransferScheduler {
    }
    private struct ActiveTransferState {
-        let totalFragments: Int
+        var totalFragments: Int
        var sentFragments: Int
        var workItems: [DispatchWorkItem]
        var contentKey: String?
        var directedPeer: PeerID?
    }
    private var activeTransfers: [String: ActiveTransferState] = [:]
    private var pendingTransfers: [BLEOutboundFragmentTransferRequest] = []
    /// A transfer of the same content whose audience covers `directedPeer`:
    /// a broadcast covers every peer; a directed transfer covers only its
    /// recipient. A directed resend to a peer NOT covered by what's in
    /// flight (different recipient of a private file) is never a duplicate.
    private func coveringDuplicate(contentKey: String, directedPeer: PeerID?) -> String? {
        for (transferId, state) in activeTransfers where state.contentKey == contentKey {
            if state.directedPeer == nil || state.directedPeer == directedPeer {
                return transferId
            }
        }
        for request in pendingTransfers where request.contentKey == contentKey {
            if request.directedPeer == nil || request.directedPeer == directedPeer {
                return request.resolvedTransferId
            }
        }
        return nil
    }
    var activeCount: Int {
        activeTransfers.count
    }
@@ -69,17 +142,39 @@ struct BLEOutboundFragmentTransferScheduler {
            return .start(request: request, reservedTransferId: nil)
        }
        // Only requests without an explicit transferId are dropped as
        // duplicates: those are resend paths (gossip-sync replay, directed
        // spool) with no UI waiting on them. An app-initiated send carries a
        // transferId whose progress events the UI tracks, so it always runs.
        if request.transferId == nil,
           let contentKey = request.contentKey,
           let coveringId = coveringDuplicate(contentKey: contentKey, directedPeer: request.directedPeer) {
            return .droppedDuplicate(request: request, activeTransferId: coveringId)
        }
        guard activeTransfers.count < maxConcurrentTransfers else {
            if request.requireDirectPeerLink {
                return .rejectedStrict(request: request, transferId: transferId)
            }
            pendingTransfers.append(request)
            return .queued(request: request, transferId: transferId, position: .back)
        }
        guard activeTransfers[transferId] == nil else {
            if request.requireDirectPeerLink {
                return .rejectedStrict(request: request, transferId: transferId)
            }
            pendingTransfers.insert(request, at: 0)
            return .queued(request: request, transferId: transferId, position: .front)
        }
-        activeTransfers[transferId] = ActiveTransferState(totalFragments: 0, sentFragments: 0, workItems: [])
+        activeTransfers[transferId] = ActiveTransferState(
            totalFragments: 0,
            sentFragments: 0,
            workItems: [],
            contentKey: request.contentKey,
            directedPeer: request.directedPeer
        )
        return .start(request: request, reservedTransferId: transferId)
    }
@@ -88,12 +183,11 @@ struct BLEOutboundFragmentTransferScheduler {
        totalFragments: Int,
        workItems: [DispatchWorkItem]
    ) -> Bool {
-        guard activeTransfers[transferId] != nil else { return false }
+        guard var state = activeTransfers[transferId] else { return false }
-        activeTransfers[transferId] = ActiveTransferState(
+        state.totalFragments = totalFragments
-            totalFragments: totalFragments,
+        state.sentFragments = 0
-            sentFragments: 0,
+        state.workItems = workItems
-            workItems: workItems
+        activeTransfers[transferId] = state
        )
        return true
    }
@@ -149,13 +243,25 @@ struct BLEOutboundFragmentTransferScheduler {
        while availableSlots > 0, !pendingTransfers.isEmpty {
            let request = pendingTransfers.removeFirst()
            availableSlots -= 1
            guard let transferId = request.resolvedTransferId else {
                availableSlots -= 1
                results.append(.start(request: request, reservedTransferId: nil))
                continue
            }
            // A queued duplicate of content that started while it waited
            // must not resend the whole file once the slot frees up (same
            // explicit-transferId exemption as submit).
            if request.transferId == nil,
               let contentKey = request.contentKey,
               let coveringId = coveringDuplicate(contentKey: contentKey, directedPeer: request.directedPeer) {
                results.append(.droppedDuplicate(request: request, activeTransferId: coveringId))
                continue
            }
            availableSlots -= 1
            guard activeTransfers.count < maxConcurrentTransfers else {
                pendingTransfers.insert(request, at: 0)
                results.append(.queued(request: request, transferId: transferId, position: .front))
@@ -168,7 +274,13 @@ struct BLEOutboundFragmentTransferScheduler {
                continue
            }
-            activeTransfers[transferId] = ActiveTransferState(totalFragments: 0, sentFragments: 0, workItems: [])
+            activeTransfers[transferId] = ActiveTransferState(
                totalFragments: 0,
                sentFragments: 0,
                workItems: [],
                contentKey: request.contentKey,
                directedPeer: request.directedPeer
            )
            results.append(.start(request: request, reservedTransferId: transferId))
        }
@@ -20,22 +20,15 @@ enum BLEOutboundLinkPlanner {
        excludedLinks: Set<BLEIngressLinkID>,
        peripheralPeerBindings: [String: PeerID] = [:],
        centralPeerBindings: [String: PeerID] = [:],
-        directedOnlyPeer: PeerID?
+        preferredPeripheralPerPeer: [PeerID: String] = [:],
        directAnnounceTTL: UInt8 = TransportConfig.messageTTLDefault,
        directedOnlyPeer: PeerID?,
        requireDirectPeerLink: Bool = false
    ) -> BLEOutboundLinkPlan {
        if let minLimit = minimumLinkLimit(
            peripheralWriteLimits: peripheralWriteLimits,
            centralNotifyLimits: centralNotifyLimits
        ), packet.type != MessageType.fragment.rawValue,
           dataCount > minLimit {
            return BLEOutboundLinkPlan(
                directedPeerHint: directedPeerHint(for: packet, explicitPeer: directedOnlyPeer),
                fragmentChunkSize: BLEOutboundPacketPolicy.fragmentChunkSize(forLinkLimit: minLimit),
                selectedLinks: BLEFanoutSelection(peripheralIDs: [], centralIDs: []),
                shouldSpoolDirectedPacket: false
            )
        }
        let directedPeerHint = directedPeerHint(for: packet, explicitPeer: directedOnlyPeer)
        // Direct announces bypass the per-peer duplicate-link collapse so
        // every live link gets bound (see BLEFanoutSelector.selectLinks).
        let isDirectAnnounce = packet.type == MessageType.announce.rawValue && packet.ttl == directAnnounceTTL
        let selectedLinks = BLEFanoutSelector.selectLinks(
            peripheralIDs: peripheralIDs,
            centralIDs: centralIDs,
@@ -43,11 +36,37 @@ enum BLEOutboundLinkPlanner {
            excludedLinks: excludedLinks,
            peripheralPeerBindings: peripheralPeerBindings,
            centralPeerBindings: centralPeerBindings,
            preferredPeripheralPerPeer: preferredPeripheralPerPeer,
            collapseDuplicatePeerLinks: !isDirectAnnounce,
            directedPeerHint: directedPeerHint,
            requireDirectPeerLink: requireDirectPeerLink,
            packetType: packet.type,
            messageID: BLEOutboundPacketPolicy.messageID(for: packet)
        )
        // Fragment only for links that this packet can actually use. Looking
        // at every connected link before directed-peer selection lets an
        // unrelated peer's MTU make an oversized directed send look routable,
        // even though every resulting fragment will select zero target links.
        let selectedPeripheralLimits = zip(peripheralIDs, peripheralWriteLimits).compactMap { id, limit in
            selectedLinks.peripheralIDs.contains(id) ? limit : nil
        }
        let selectedCentralLimits = zip(centralIDs, centralNotifyLimits).compactMap { id, limit in
            selectedLinks.centralIDs.contains(id) ? limit : nil
        }
        if let minLimit = minimumLinkLimit(
            peripheralWriteLimits: selectedPeripheralLimits,
            centralNotifyLimits: selectedCentralLimits
        ), packet.type != MessageType.fragment.rawValue,
           dataCount > minLimit {
            return BLEOutboundLinkPlan(
                directedPeerHint: directedPeerHint,
                fragmentChunkSize: BLEOutboundPacketPolicy.fragmentChunkSize(forLinkLimit: minLimit),
                selectedLinks: selectedLinks,
                shouldSpoolDirectedPacket: false
            )
        }
        return BLEOutboundLinkPlan(
            directedPeerHint: directedPeerHint,
            fragmentChunkSize: nil,
@@ -44,4 +44,16 @@ struct BLEOutboundNotificationBuffer<Target> {
        guard !pending.isEmpty else { return }
        notifications.insert(contentsOf: pending, at: 0)
    }
    /// Removes a disconnected target from target-specific retries. Broadcast
    /// entries (`targets == nil`) remain valid for the surviving subscriber
    /// set; an entry with no targets left is discarded entirely.
    mutating func removeTarget(where matches: (Target) -> Bool) {
        notifications = notifications.compactMap { notification in
            guard let targets = notification.targets else { return notification }
            let remaining = targets.filter { !matches($0) }
            guard !remaining.isEmpty else { return nil }
            return BLEPendingNotification(data: notification.data, targets: remaining)
        }
    }
 }
@@ -12,12 +12,15 @@ enum BLEOutboundPacketPolicy {
        switch MessageType(rawValue: packetType) {
        case .noiseEncrypted, .noiseHandshake:
            return true
-        case .none, .announce, .message, .leave, .requestSync, .fragment, .fileTransfer:
+        // voiceFrame is deliberately unpadded: padding to the 512 block would
        // push every ~490-byte signed voice packet over the MTU into the
        // fragment path.
        case .none, .announce, .message, .leave, .requestSync, .fragment, .fileTransfer, .courierEnvelope, .boardPost, .ping, .pong, .nostrCarrier, .prekeyBundle, .groupMessage, .voiceFrame:
            return false
        }
    }
-    static func priority(for packet: BitchatPacket, data: Data) -> BLEOutboundWritePriority {
+    static func priority(for packet: BitchatPacket, data _: Data) -> BLEOutboundWritePriority {
        guard let messageType = MessageType(rawValue: packet.type) else { return .low }
        switch messageType {
        case .fragment:
@@ -46,8 +46,25 @@ struct BLEOutboundWriteBuffer {
        priority: BLEOutboundWritePriority,
        capBytes: Int
    ) -> EnqueueResult {
        enqueueReportingAcceptance(
            data: data,
            for: peripheralID,
            priority: priority,
            capBytes: capBytes
        ).result
    }
    /// Enqueues while also reporting whether the newly offered write survived
    /// priority trimming. `EnqueueResult.enqueued` alone cannot express that:
    /// a full queue may immediately trim the new lowest-priority item.
    mutating func enqueueReportingAcceptance(
        data: Data,
        for peripheralID: String,
        priority: BLEOutboundWritePriority,
        capBytes: Int
    ) -> (result: EnqueueResult, accepted: Bool) {
        guard data.count <= capBytes else {
-            return .oversized(bytes: data.count)
+            return (.oversized(bytes: data.count), false)
        }
        var queue = writesByPeripheralID[peripheralID] ?? []
@@ -65,7 +82,8 @@ struct BLEOutboundWriteBuffer {
        }
        writesByPeripheralID[peripheralID] = queue.isEmpty ? nil : queue
-        return .enqueued(trimmedBytes: trimmedBytes, remainingBytes: total)
+        let accepted = insertIndex < queue.count
        return (.enqueued(trimmedBytes: trimmedBytes, remainingBytes: total), accepted)
    }
    mutating func takeAll(for peripheralID: String) -> [BLEPendingWrite] {
@@ -74,6 +92,13 @@ struct BLEOutboundWriteBuffer {
        return items
    }
    /// Drops link-specific ciphertext when that physical link is gone. Keeping
    /// the dictionary entry would let rotating peripheral UUIDs accumulate a
    /// fresh per-link byte cap indefinitely.
    mutating func discardAll(for peripheralID: String) {
        writesByPeripheralID[peripheralID] = nil
    }
    mutating func prepend(_ items: [BLEPendingWrite], for peripheralID: String) {
        guard !items.isEmpty else { return }
        var existing = writesByPeripheralID[peripheralID] ?? []
@@ -9,6 +9,9 @@ struct BLEPeerInfo: Equatable {
    var signingPublicKey: Data?
    var isVerifiedNickname: Bool
    var lastSeen: Date
    var capabilities: PeerCapabilities = []
    /// Rendezvous cell from the peer's announce when it advertises `.bridge`.
    var bridgeGeohash: String?
 }
 struct BLEPeerAnnounceUpdate: Equatable {
@@ -107,6 +110,24 @@ struct BLEPeerRegistry {
        peers[peerID]?.noisePublicKey?.sha256Fingerprint()
    }
    func capabilities(for peerID: PeerID) -> PeerCapabilities {
        peers[peerID.toShort()]?.capabilities ?? []
    }
    /// Peers whose last verified announce advertised the given capability.
    func peers(advertising capability: PeerCapabilities) -> [PeerID] {
        peers.values.filter { $0.capabilities.contains(capability) }.map(\.peerID)
    }
    /// A rendezvous cell advertised by any bridge-capable peer, if one is
    /// known — lets location-less devices join the island's rendezvous.
    func advertisedBridgeGeohash() -> String? {
        peers.values
            .filter { $0.capabilities.contains(.bridge) }
            .compactMap(\.bridgeGeohash)
            .first
    }
    func displayNicknames(selfNickname: String) -> [PeerID: String] {
        let connected = peers.filter { $0.value.isConnected }
        let tuples = connected.map { ($0.key, $0.value.nickname, true) }
@@ -125,25 +146,28 @@ struct BLEPeerRegistry {
                nickname: resolvedNames[info.peerID] ?? info.nickname,
                isConnected: info.isConnected,
                noisePublicKey: info.noisePublicKey,
-                lastSeen: info.lastSeen
+                lastSeen: info.lastSeen,
                isVerified: info.isVerifiedNickname
            )
        }
    }
    func collisionResolvedNickname(for peerID: PeerID, selfNickname: String) -> String? {
        guard let info = peers[peerID], info.isVerifiedNickname else { return nil }
        let hasCollision = peers.values.contains {
            $0.isConnected && $0.nickname == info.nickname && $0.peerID != peerID
        } || selfNickname == info.nickname
        return hasCollision ? info.nickname + "#" + String(peerID.id.prefix(4)) : info.nickname
    }
    mutating func markDisconnected(_ peerID: PeerID) {
        guard var info = peers[peerID] else { return }
        info.isConnected = false
        peers[peerID] = info
    }
    /// Flips an already-known peer to connected. Returns false when the peer
    /// is unknown or already connected (nothing changed).
    @discardableResult
    mutating func markConnected(_ peerID: PeerID) -> Bool {
        guard var info = peers[peerID], !info.isConnected else { return false }
        info.isConnected = true
        peers[peerID] = info
        return true
    }
    mutating func updateLastSeen(_ peerID: PeerID, at date: Date) {
        guard var peer = peers[peerID] else { return }
        peer.lastSeen = date
@@ -156,7 +180,9 @@ struct BLEPeerRegistry {
        noisePublicKey: Data,
        signingPublicKey: Data?,
        isConnected: Bool,
-        now: Date
+        now: Date,
        capabilities: PeerCapabilities = [],
        bridgeGeohash: String? = nil
    ) -> BLEPeerAnnounceUpdate {
        let existing = peers[peerID]
        let update = BLEPeerAnnounceUpdate(
@@ -172,7 +198,9 @@ struct BLEPeerRegistry {
            noisePublicKey: noisePublicKey,
            signingPublicKey: signingPublicKey,
            isVerifiedNickname: true,
-            lastSeen: now
+            lastSeen: now,
            capabilities: capabilities,
            bridgeGeohash: bridgeGeohash
        )
        return update
@@ -122,10 +122,18 @@ final class BLEPublicMessageHandler {
        SecureLogger.debug("💬 [\(senderNickname)] TTL:\(packet.ttl) (\(pathTag)) chars=\(content.count) bytes=\(packet.payload.count)", category: .session)
        let ts = Date(timeIntervalSince1970: Double(packet.timestamp) / 1000)
-        var resolvedSelfMessageID: String? = nil
+        let messageID: String?
        if peerID == env.localPeerID() {
-            resolvedSelfMessageID = env.takeSelfBroadcastMessageID(packet)
+            messageID = env.takeSelfBroadcastMessageID(packet)
        } else {
            // The wire carries no message ID; derive the stable one every
            // device agrees on so bridged copies dedup against the radio copy.
            messageID = MeshMessageIdentity.stableID(
                senderIDHex: peerID.id,
                timestampMs: packet.timestamp,
                content: content
            )
        }
-        env.deliverPublicMessage(peerID, senderNickname, content, ts, resolvedSelfMessageID)
+        env.deliverPublicMessage(peerID, senderNickname, content, ts, messageID)
    }
 }
@@ -27,8 +27,15 @@ enum BLEPublicMessagePolicy {
        }
        let isBroadcast = BLEPacketFreshnessPolicy.isBroadcastRecipient(packet.recipientID)
        // Acceptance window matches the gossip-sync serving window: a peer
        // walking between partitions carries hours of public history, so the
        // receive side must not drop what sync legitimately serves.
        if isBroadcast,
-           BLEPacketFreshnessPolicy.isStale(timestampMilliseconds: packet.timestamp, now: now) {
+           BLEPacketFreshnessPolicy.isStale(
               timestampMilliseconds: packet.timestamp,
               now: now,
               maxAgeSeconds: TransportConfig.syncPublicMessageMaxAgeSeconds
           ) {
            return .reject(.staleBroadcast(ageSeconds: BLEPacketFreshnessPolicy.ageSeconds(
                timestampMilliseconds: packet.timestamp,
                now: now
@@ -48,11 +48,29 @@ struct BLEReceivePipeline {
            senderIsSelf: senderID == localPeerID,
            recipientIsSelf: PeerID(hexData: packet.recipientID) == localPeerID,
            isEncrypted: packet.type == MessageType.noiseEncrypted.rawValue,
-            isDirectedEncrypted: packet.type == MessageType.noiseEncrypted.rawValue && packet.recipientID != nil,
+            // Courier envelopes are directed opaque ciphertext like DMs; a
            // remote handover toward a relayed announce rides this same
            // deterministic relay treatment instead of the broadcast clamp.
            // Ping/pong diagnostics ride it too: probes need the same
            // deterministic multi-hop relay as DMs (always relay, jitter,
            // no TTL cap) so RTT and hop counts reflect the real path.
            // Directed nostrCarrier uplinks (mesh-only peer -> gateway) need
            // the same multi-hop treatment to reach a non-adjacent gateway.
            isDirectedEncrypted: (packet.type == MessageType.noiseEncrypted.rawValue
                || packet.type == MessageType.courierEnvelope.rawValue
                || packet.type == MessageType.ping.rawValue
                || packet.type == MessageType.pong.rawValue
                || packet.type == MessageType.nostrCarrier.rawValue) && packet.recipientID != nil,
            isFragment: packet.type == MessageType.fragment.rawValue,
            isDirectedFragment: packet.type == MessageType.fragment.rawValue && packet.recipientID != nil,
            isHandshake: packet.type == MessageType.noiseHandshake.rawValue,
            isAnnounce: packet.type == MessageType.announce.rawValue,
            isRequestSync: packet.type == MessageType.requestSync.rawValue,
            // Board posts relay like broadcast messages; urgent ones get the
            // announce-class TTL headroom so alerts travel the extra hop.
            isUrgentBoardPost: packet.type == MessageType.boardPost.rawValue
                && BoardWire.urgentFlag(in: packet.payload),
            isVoiceFrame: packet.type == MessageType.voiceFrame.rawValue,
            degree: degree,
            highDegreeThreshold: highDegreeThreshold
        )
--- a/Show More
+++ b/Show More
		`@@ -0,0 +1 @@`
							{"v1":{"usrs":["param-buf-arti_bootstrap_summary(_:_:)-s:3Tor22arti_bootstrap_summary33_954FD7701B4E47ABB5F166D1CF862DC9LLys5Int32VSpys4Int8VG_AEtF","param-dataDir-arti_start(_:_:)-s:3Tor10arti_start33_954FD7701B4E47ABB5F166D1CF862DC9LLys5Int32VSPys4Int8VG_s6UInt16VtF","param-len-arti_bootstrap_summary(_:_:)-s:3Tor22arti_bootstrap_summary33_954FD7701B4E47ABB5F166D1CF862DC9LLys5Int32VSpys4Int8VG_AEtF","param-socksPort-arti_start(_:_:)-s:3Tor10arti_start33_954FD7701B4E47ABB5F166D1CF862DC9LLys5Int32VSPys4Int8VG_s6UInt16VtF","s:13BitFoundation16PeerCapabilitiesV8wifiBulkACvpZ","s:13BitFoundation18KeychainReadResultO18isRecoverableErrorSbvp","s:13BitFoundation23KeychainManagerProtocolP11secureClearyySSzF","s:18bitchatTests_macOS12MockKeychainC11secureClearyySSzF","s:18bitchatTests_macOS20TrackingMockKeychainC11resetCountsyyF","s:18bitchatTests_macOS20TrackingMockKeychainC11secureClearyySSzF","s:18bitchatTests_macOS20TrackingMockKeychainC25totalSecureClearCallCountSivp","s:18bitchatTests_macOS20TrackingMockKeychainC26secureClearStringCallCountSivp","s:18bitchatTests_macOS20TrackingMockKeychainC27_secureClearStringCallCount06_AB6D1M24FD239F2969C82F4108818260LLSivp","s:18bitchatTests_macOS24FailingCacheSaveKeychain33_22380C7A11A569A0B83FA83F34C498A7LLC11secureClearyySSzF","s:18bitchatTests_macOS24MockGeohashPresenceTimer33_483587EFB96650EE130EFB09BBA2A1AALLC7handleryycvp","s:3Tor0A7ManagerC21goDormantOnBackgroundyyF","s:7bitchat10AppRuntimeC24handleScreenshotCaptured33_C8B369AD8BC1D9963A50CEDA77A4332ALLyyF","s:7bitchat10AppRuntimeC33handleDidBecomeActiveNotificationyyF","s:7bitchat10BLEServiceC18logBluetoothStatus33_69191C53E68500C17D98DBCF2BDA7100LLyySSF","s:7bitchat10BLEServiceC20centralRestorationID33_69191C53E68500C17D98DBCF2BDA7100LLSSvpZ","s:7bitchat10BLEServiceC22captureBluetoothStatus33_69191C53E68500C17D98DBCF2BDA7100LL7contextySS_tF","s:7bitchat10BLEServiceC23peripheralRestorationID33_69191C53E68500C17D98DBCF2BDA7100LLSSvpZ","s:7bitchat10BLEServiceC29scheduleBluetoothStatusSample33_69191C53E68500C17D98DBCF2BDA7100LL5after7contextySd_SStF","s:7bitchat10QRScanViewV8isActiveSbvp","s:7bitchat15BLEPeerRegistryV5countSivp","s:7bitchat15KeychainManagerC11secureClearyySSzF","s:7bitchat15PaymentChipViewV7openURL33_10AC50641B1EBCD52E5092A2E521D236LL7SwiftUI13OpenURLActionVvp","s:7bitchat15TransportConfigO29uiBatchDispatchStaggerSecondsSdvpZ","s:7bitchat15TransportConfigO35uiShareExtensionDismissDelaySecondsSdvpZ","s:7bitchat15TransportConfigO38bleBackgroundPendingConnectSlotReserveSivpZ","s:7bitchat17GossipSyncManagerC10persistNowyyF","s:7bitchat17NostrRelayManagerC15InboundEventKey33_E4160FE8A9A2C9D6308EAAD5A8B5CB07LLV7eventIDSSvp","s:7bitchat25LocationNotesDependenciesV3now10Foundation4DateVycvp","s:7bitchat25NWPathReachabilityMonitorC7monitor33_84633C9DBCAF57538179C1E04DB8E015LL7Network0bD0CSgvp"]}}