Merge branch 'main' into avoid-recreating-session

.github/workflows/fetch_georelays.yml

@@ -7,7 +7,6 @@ on:
 
 permissions:
   contents: write
-  pull-requests: write
 
 jobs:
   update-relay-data:
@@ -18,54 +17,24 @@ jobs:
         uses: actions/checkout@v4
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
-          fetch-depth: 0
-
+      
       - name: Fetch GeoRelays
         run: |
-          wget -q https://raw.githubusercontent.com/permissionlesstech/georelays/refs/heads/main/nostr_relays.csv
+          wget https://raw.githubusercontent.com/permissionlesstech/georelays/refs/heads/main/nostr_relays.csv
           mv nostr_relays.csv ./relays/online_relays_gps.csv
 
-      - name: Configure git
+      - name: Check for changes
+        id: git-check
         run: |
-          git config user.email "action@github.com"
-          git config user.name "GitHub Action"
-
-      - name: Create update branch if changes
-        id: create_branch
+          git diff --exit-code || echo "changes=true" >> $GITHUB_OUTPUT
+    
+      - name: Commit and push changes
+        if: steps.git-check.outputs.changes == 'true'
         run: |
-          # exit early if no changes
-          if git diff --quiet --relays/online_relays_gps.csv; then
-            echo "changed=false" >> $GITHUB_OUTPUT
-            exit 0
-          fi
-
-          # branch name with timestamp
-          BRANCH="update-georelays-$(date -u +%Y%m%dT%H%M%SZ)"
-          git checkout -b "$BRANCH"
-
+          git config --local user.email "action@github.com"
+          git config --local user.name "GitHub Action"
           git add relays/online_relays_gps.csv
-          git commit -m "Automated update of relay data - $(date -u --rfc-3339=seconds)"
-          echo "changed=true" >> $GITHUB_OUTPUT
-          echo "branch=$BRANCH" >> $GITHUB_OUTPUT
-
-      - name: Push branch
-        if: steps.create_branch.outputs.changed == 'true'
-        run: |
-          git push --set-upstream origin "${{ steps.create_branch.outputs.branch }}"
-
-      - name: Create pull request
-        if: steps.create_branch.outputs.changed == 'true'
-        uses: peter-evans/create-pull-request@v5
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          commit-message: Automated update of relay data
-          branch: ${{ steps.create_branch.outputs.branch }}
-          base: main
-          title: Automated update of relay data
-          body: |
-            This PR was created automatically by the scheduled workflow. It updates relays/online_relays_gps.csv from the GeoRelays source.
-          labels: automated, georelays
-
-      - name: No changes
-        if: steps.create_branch.outputs.changed != 'true'
-        run: echo "No changes to relays/online_relays_gps.csv"
+          git commit -m "Automated update of relay data - $(date -u)"
+          git push
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Configs/Release.xcconfig

@@ -1,4 +1,4 @@
-MARKETING_VERSION = 1.5.0
+MARKETING_VERSION = 1.4.4
 CURRENT_PROJECT_VERSION = 1
 
 IPHONEOS_DEPLOYMENT_TARGET = 16.0

Justfile

@@ -14,11 +14,8 @@ default:
 # Check prerequisites
 check:
     @echo "Checking prerequisites..."
-    @command -v xcodebuild >/dev/null 2>&1 || (echo "❌ xcodebuild not found. Install Xcode from App Store" && exit 1)
-    @xcode-select -p | grep -q "Xcode.app" || (echo "❌ Full Xcode required, not just command line tools. Install from App Store and run:\n   sudo xcode-select -s /Applications/Xcode.app/Contents/Developer" && exit 1)
-    @test -d "/Applications/Xcode.app" || (echo "❌ Xcode.app not found in Applications folder. Install from App Store" && exit 1)
-    @xcodebuild -version >/dev/null 2>&1 || (echo "❌ Xcode not properly configured. Try:\n   sudo xcode-select -s /Applications/Xcode.app/Contents/Developer" && exit 1)
-    @security find-identity -v -p codesigning | grep -q "Apple Development\|Developer ID" || (echo "⚠️  No Developer ID found - code signing may fail" && exit 0)
+    @command -v xcodebuild >/dev/null 2>&1 || (echo "❌ Xcode not found. Install Xcode from App Store" && exit 1)
+    @security find-identity -v -p codesigning | grep -q "Developer ID" || (echo "⚠️  No Developer ID found - code signing may fail" && exit 0)
     @echo "✅ All prerequisites met"
 
 # Backup original files

bitchat.xcodeproj/xcshareddata/xcschemes/bitchat (iOS).xcscheme

@@ -98,8 +98,8 @@
       </BuildableProductRunnable>
       <EnvironmentVariables>
          <EnvironmentVariable
-            key = "BITCHAT_LOG_LEVEL"
-            value = "debug"
+            key = "-DBITCHAT_DEV_ALLOW_CLEARNET"
+            value = ""
             isEnabled = "YES">
          </EnvironmentVariable>
       </EnvironmentVariables>

bitchat/BitchatApp.swift

@@ -57,9 +57,11 @@ struct BitchatApp: App {
                         let npub = try? idBridge.getCurrentNostrIdentity()?.npub
                         _ = VerificationService.shared.buildMyQRString(nickname: chatViewModel.nickname, npub: npub)
                     }
-
+                    #if os(iOS)
                     appDelegate.chatViewModel = chatViewModel
-
+                    #elseif os(macOS)
+                    appDelegate.chatViewModel = chatViewModel
+                    #endif
                     // Initialize network activation policy; will start Tor/Nostr only when allowed
                     NetworkActivationService.shared.start()
                     // Check for shared content
@@ -187,10 +189,6 @@ final class AppDelegate: NSObject, UIApplicationDelegate {
     func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
         return true
     }
-    
-    func applicationWillTerminate(_ application: UIApplication) {
-        chatViewModel?.applicationWillTerminate()
-    }
 }
 #endif
 
@@ -248,7 +246,7 @@ final class NotificationDelegate: NSObject, UNUserNotificationCenterDelegate {
             // Get peer ID from userInfo
             if let peerID = userInfo["peerID"] as? String {
                 // Don't show notification if the private chat is already open
-                if chatViewModel?.selectedPrivateChatPeer == PeerID(str: peerID) {
+                if chatViewModel?.selectedPrivateChatPeer == peerID {
                     completionHandler([])
                     return
                 }

bitchat/Features/media/ImageUtils.swift

@@ -1,203 +0,0 @@
-import Foundation
-import ImageIO
-import UniformTypeIdentifiers
-#if os(iOS)
-import UIKit
-#else
-import AppKit
-#endif
-
-enum ImageUtilsError: Error {
-    case invalidImage
-    case encodingFailed
-}
-
-enum ImageUtils {
-    private static let compressionQuality: CGFloat = 0.82
-    private static let targetImageBytes: Int = 45_000
-
-    static func processImage(at url: URL, maxDimension: CGFloat = 448) throws -> URL {
-        // Security H1: Check file size BEFORE reading into memory
-        let attrs = try FileManager.default.attributesOfItem(atPath: url.path)
-        guard let fileSize = attrs[.size] as? Int else {
-            throw ImageUtilsError.invalidImage
-        }
-        // Allow up to 10MB source images (will be scaled down)
-        guard fileSize <= 10 * 1024 * 1024 else {
-            throw ImageUtilsError.invalidImage
-        }
-
-        let data = try Data(contentsOf: url)
-        #if os(iOS)
-        guard let image = UIImage(data: data) else { throw ImageUtilsError.invalidImage }
-        return try processImage(image, maxDimension: maxDimension)
-        #else
-        guard let image = NSImage(data: data) else { throw ImageUtilsError.invalidImage }
-        return try processImage(image, maxDimension: maxDimension)
-        #endif
-    }
-
-    #if os(iOS)
-    static func processImage(_ image: UIImage, maxDimension: CGFloat = 448) throws -> URL {
-        return try autoreleasepool {
-            // Scale the image first
-            let scaled = scaledImage(image, maxDimension: maxDimension)
-
-            // Get CGImage from UIImage - this is the key to stripping metadata
-            guard let cgImage = scaled.cgImage else {
-                throw ImageUtilsError.encodingFailed
-            }
-
-            // Use CGImageDestination to encode without metadata (same as macOS)
-            var quality = compressionQuality
-            guard var jpegData = encodeJPEG(from: cgImage, quality: quality) else {
-                throw ImageUtilsError.encodingFailed
-            }
-
-            // Compress to target size
-            while jpegData.count > targetImageBytes && quality > 0.3 {
-                quality -= 0.1
-                autoreleasepool {
-                    if let next = encodeJPEG(from: cgImage, quality: quality) {
-                        jpegData = next
-                    }
-                }
-            }
-
-            let outputURL = try makeOutputURL()
-            try jpegData.write(to: outputURL, options: .atomic)
-            return outputURL
-        }
-    }
-
-    private static func scaledImage(_ image: UIImage, maxDimension: CGFloat) -> UIImage {
-        let size = image.size
-        let maxSide = max(size.width, size.height)
-        guard maxSide > maxDimension else { return image }
-        let scale = maxDimension / maxSide
-        let newSize = CGSize(width: size.width * scale, height: size.height * scale)
-
-        // Draw into a new context to get a clean CGImage without metadata
-        UIGraphicsBeginImageContextWithOptions(newSize, true, 1.0)
-        image.draw(in: CGRect(origin: .zero, size: newSize))
-        let rendered = UIGraphicsGetImageFromCurrentImageContext()
-        UIGraphicsEndImageContext()
-        return rendered ?? image
-    }
-
-    // Shared EXIF-stripping JPEG encoder for both iOS and macOS
-    private static func encodeJPEG(from cgImage: CGImage, quality: CGFloat) -> Data? {
-        guard let data = CFDataCreateMutable(nil, 0) else {
-            return nil
-        }
-        guard let destination = CGImageDestinationCreateWithData(data, UTType.jpeg.identifier as CFString, 1, nil) else {
-            return nil
-        }
-        // Security: Strip ALL metadata (EXIF, GPS, TIFF, IPTC, XMP)
-        // By only specifying compression quality and no metadata keys,
-        // we ensure a clean JPEG with no privacy-leaking information
-        let options: [CFString: Any] = [
-            kCGImageDestinationLossyCompressionQuality: quality
-        ]
-        CGImageDestinationAddImage(destination, cgImage, options as CFDictionary)
-        guard CGImageDestinationFinalize(destination) else {
-            return nil
-        }
-        return data as Data
-    }
-    #else
-    static func processImage(_ image: NSImage, maxDimension: CGFloat = 448) throws -> URL {
-        return try autoreleasepool {
-            let scaled = scaledImage(image, maxDimension: maxDimension)
-            guard let inputCG = scaled.cgImage(forProposedRect: nil, context: nil, hints: nil) else {
-                throw ImageUtilsError.encodingFailed
-            }
-            let width = inputCG.width
-            let height = inputCG.height
-            let colorSpace = CGColorSpace(name: CGColorSpace.sRGB) ?? CGColorSpaceCreateDeviceRGB()
-            guard let context = CGContext(
-                data: nil,
-                width: width,
-                height: height,
-                bitsPerComponent: 8,
-                bytesPerRow: 0,
-                space: colorSpace,
-                bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
-            ) else {
-                throw ImageUtilsError.encodingFailed
-            }
-            context.draw(inputCG, in: CGRect(x: 0, y: 0, width: width, height: height))
-            guard let cgImage = context.makeImage() else {
-                throw ImageUtilsError.encodingFailed
-            }
-            var quality = compressionQuality
-            guard var jpegData = encodeJPEG(from: cgImage, quality: quality) else {
-                throw ImageUtilsError.encodingFailed
-            }
-            while jpegData.count > targetImageBytes && quality > 0.3 {
-                quality -= 0.1
-                autoreleasepool {
-                    if let next = encodeJPEG(from: cgImage, quality: quality) {
-                        jpegData = next
-                    }
-                }
-            }
-            let outputURL = try makeOutputURL()
-            try jpegData.write(to: outputURL, options: .atomic)
-            return outputURL
-        }
-    }
-
-    private static func scaledImage(_ image: NSImage, maxDimension: CGFloat) -> NSImage {
-        let size = image.size
-        let maxSide = max(size.width, size.height)
-        guard maxSide > maxDimension else { return image }
-        let scale = maxDimension / maxSide
-        let newSize = NSSize(width: size.width * scale, height: size.height * scale)
-        let scaledImage = NSImage(size: newSize)
-        scaledImage.lockFocus()
-        image.draw(in: NSRect(origin: .zero, size: newSize),
-                   from: NSRect(origin: .zero, size: size),
-                   operation: .copy,
-                   fraction: 1.0)
-        scaledImage.unlockFocus()
-        return scaledImage
-    }
-
-    // Shared EXIF-stripping JPEG encoder for both iOS and macOS
-    private static func encodeJPEG(from cgImage: CGImage, quality: CGFloat) -> Data? {
-        guard let data = CFDataCreateMutable(nil, 0) else {
-            return nil
-        }
-        guard let destination = CGImageDestinationCreateWithData(data, UTType.jpeg.identifier as CFString, 1, nil) else {
-            return nil
-        }
-        // Security: Strip ALL metadata (EXIF, GPS, TIFF, IPTC, XMP)
-        // By only specifying compression quality and no metadata keys,
-        // we ensure a clean JPEG with no privacy-leaking information
-        let options: [CFString: Any] = [
-            kCGImageDestinationLossyCompressionQuality: quality
-        ]
-        CGImageDestinationAddImage(destination, cgImage, options as CFDictionary)
-        guard CGImageDestinationFinalize(destination) else {
-            return nil
-        }
-        return data as Data
-    }
-    #endif
-
-    private static func makeOutputURL() throws -> URL {
-        let formatter = DateFormatter()
-        formatter.dateFormat = "yyyyMMdd_HHmmss"
-        let fileName = "img_\(formatter.string(from: Date())).jpg"
-
-        let directory = try applicationFilesDirectory().appendingPathComponent("images/outgoing", isDirectory: true)
-        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true, attributes: nil)
-        return directory.appendingPathComponent(fileName)
-    }
-
-    private static func applicationFilesDirectory() throws -> URL {
-        let base = try FileManager.default.url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
-        return base.appendingPathComponent("files", isDirectory: true)
-    }
-}

bitchat/Features/voice/VoiceNotePlaybackController.swift

@@ -1,193 +0,0 @@
-import Foundation
-import AVFoundation
-import BitLogger
-
-/// Controls playback for a single voice note and coordinates exclusive playback across the app.
-final class VoiceNotePlaybackController: NSObject, ObservableObject, AVAudioPlayerDelegate {
-    @Published private(set) var isPlaying: Bool = false
-    @Published private(set) var currentTime: TimeInterval = 0
-    @Published private(set) var duration: TimeInterval = 0
-    @Published private(set) var progress: Double = 0
-
-    private var player: AVAudioPlayer?
-    private var timer: Timer?
-    private var url: URL
-
-    init(url: URL) {
-        self.url = url
-        super.init()
-        // Don't load anything eagerly - wait until user interaction or view is fully displayed
-    }
-
-    func loadDuration() {
-        guard duration == 0 else { return }
-
-        DispatchQueue.global(qos: .utility).async { [weak self] in
-            guard let self = self else { return }
-            do {
-                let player = try AVAudioPlayer(contentsOf: self.url)
-                let loadedDuration = player.duration
-                DispatchQueue.main.async { [weak self] in
-                    guard let self = self, self.duration == 0 else { return }
-                    self.duration = loadedDuration
-                }
-            } catch {
-                SecureLogger.error("Failed to load audio duration: \(error)", category: .session)
-            }
-        }
-    }
-
-    deinit {
-        timer?.invalidate()
-    }
-
-    func replaceURL(_ url: URL) {
-        guard url != self.url else { return }
-        stop()
-        self.url = url
-        player = nil
-        duration = 0
-        // Duration will be loaded on demand when needed
-    }
-
-    func togglePlayback() {
-        isPlaying ? pause() : play()
-    }
-
-    func play() {
-        guard ensurePlayerReady() else { return }
-        VoiceNotePlaybackCoordinator.shared.activate(self)
-        player?.play()
-        startTimer()
-        updateProgress()
-        isPlaying = true
-    }
-
-    func pause() {
-        player?.pause()
-        stopTimer()
-        updateProgress()
-        isPlaying = false
-    }
-
-    func stop() {
-        player?.stop()
-        player?.currentTime = 0
-        stopTimer()
-        updateProgress()
-        isPlaying = false
-        VoiceNotePlaybackCoordinator.shared.deactivate(self)
-    }
-
-    func seek(to fraction: Double) {
-        guard ensurePlayerReady() else { return }
-        let clamped = max(0, min(1, fraction))
-        if let player = player {
-            player.currentTime = clamped * player.duration
-            if isPlaying {
-                player.play()
-            }
-            updateProgress()
-        }
-    }
-
-    // MARK: - AVAudioPlayerDelegate
-
-    func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer, successfully flag: Bool) {
-        // Delegate callback may be on background thread - ensure main thread for UI updates
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else { return }
-            self.stopTimer()
-            self.updateProgress()
-            self.isPlaying = false
-            VoiceNotePlaybackCoordinator.shared.deactivate(self)
-        }
-    }
-
-    // MARK: - Private Helpers
-
-    private func preparePlayer(for url: URL) {
-        // Prepare player synchronously (only called when playback is requested)
-        do {
-            let player = try AVAudioPlayer(contentsOf: url)
-            player.delegate = self
-            player.prepareToPlay()
-            self.player = player
-            duration = player.duration
-            currentTime = player.currentTime
-            progress = duration > 0 ? currentTime / duration : 0
-        } catch {
-            SecureLogger.error("Voice note playback failed for \(url.lastPathComponent): \(error)", category: .session)
-            player = nil
-            duration = 0
-            currentTime = 0
-            progress = 0
-        }
-    }
-
-    private func ensurePlayerReady() -> Bool {
-        if player == nil {
-            preparePlayer(for: url)
-        }
-        #if os(iOS)
-        let session = AVAudioSession.sharedInstance()
-        do {
-            try session.setCategory(.playback, mode: .spokenAudio, options: [.mixWithOthers])
-            try session.setActive(true, options: [])
-        } catch {
-            SecureLogger.error("Failed to activate audio session: \(error)", category: .session)
-        }
-        #endif
-        return player != nil
-    }
-
-    private func startTimer() {
-        if timer != nil { return }
-        timer = Timer.scheduledTimer(withTimeInterval: 0.05, repeats: true) { [weak self] _ in
-            self?.updateProgress()
-        }
-        if let timer = timer {
-            RunLoop.main.add(timer, forMode: .common)
-        }
-    }
-
-    private func stopTimer() {
-        timer?.invalidate()
-        timer = nil
-    }
-
-    private func updateProgress() {
-        guard let player = player else {
-            currentTime = 0
-            duration = 0
-            progress = 0
-            return
-        }
-        currentTime = player.currentTime
-        duration = player.duration
-        progress = duration > 0 ? currentTime / duration : 0
-    }
-}
-
-/// Ensures only one voice note plays at a time.
-final class VoiceNotePlaybackCoordinator {
-    static let shared = VoiceNotePlaybackCoordinator()
-
-    private weak var activeController: VoiceNotePlaybackController?
-
-    private init() {}
-
-    func activate(_ controller: VoiceNotePlaybackController) {
-        if activeController === controller {
-            return
-        }
-        activeController?.pause()
-        activeController = controller
-    }
-
-    func deactivate(_ controller: VoiceNotePlaybackController) {
-        if activeController === controller {
-            activeController = nil
-        }
-    }
-}

bitchat/Features/voice/VoiceRecorder.swift

@@ -1,170 +0,0 @@
-import Foundation
-import AVFoundation
-
-/// Manages audio capture for mesh voice notes with predictable encoding settings.
-/// Recording runs on an internal serial queue to avoid AVAudioSession contention.
-final class VoiceRecorder: NSObject, AVAudioRecorderDelegate {
-    enum RecorderError: Error {
-        case microphoneAccessDenied
-        case recorderInitializationFailed
-        case recordingInProgress
-    }
-
-    static let shared = VoiceRecorder()
-
-    private let queue = DispatchQueue(label: "com.bitchat.voice-recorder")
-    private let paddingInterval: TimeInterval = 0.5
-    private let maxRecordingDuration: TimeInterval = 120
-
-    private var recorder: AVAudioRecorder?
-    private var currentURL: URL?
-    private var stopWorkItem: DispatchWorkItem?
-
-    private override init() {
-        super.init()
-    }
-
-    // MARK: - Permissions
-
-    @discardableResult
-    func requestPermission() async -> Bool {
-        #if os(iOS)
-        return await withCheckedContinuation { continuation in
-            AVAudioSession.sharedInstance().requestRecordPermission { granted in
-                continuation.resume(returning: granted)
-            }
-        }
-        #elseif os(macOS)
-        return await withCheckedContinuation { continuation in
-            AVCaptureDevice.requestAccess(for: .audio) { granted in
-                continuation.resume(returning: granted)
-            }
-        }
-        #else
-        return true
-        #endif
-    }
-
-    // MARK: - Recording Lifecycle
-
-    func startRecording() throws -> URL {
-        try queue.sync {
-            if recorder?.isRecording == true {
-                throw RecorderError.recordingInProgress
-            }
-
-            #if os(iOS)
-            let session = AVAudioSession.sharedInstance()
-            guard session.recordPermission == .granted else {
-                throw RecorderError.microphoneAccessDenied
-            }
-            try session.setCategory(
-                .playAndRecord,
-                mode: .default,
-                options: [.defaultToSpeaker, .allowBluetoothA2DP, .allowBluetoothHFP]
-            )
-            try session.setActive(true, options: .notifyOthersOnDeactivation)
-            #endif
-            #if os(macOS)
-            guard AVCaptureDevice.authorizationStatus(for: .audio) == .authorized else {
-                throw RecorderError.microphoneAccessDenied
-            }
-            #endif
-
-            let outputURL = try makeOutputURL()
-            let settings: [String: Any] = [
-                AVFormatIDKey: kAudioFormatMPEG4AAC,
-                AVSampleRateKey: 16_000,
-                AVNumberOfChannelsKey: 1,
-                AVEncoderBitRateKey: 16_000
-            ]
-
-            let audioRecorder = try AVAudioRecorder(url: outputURL, settings: settings)
-            audioRecorder.delegate = self
-            audioRecorder.isMeteringEnabled = true
-            audioRecorder.prepareToRecord()
-            audioRecorder.record(forDuration: maxRecordingDuration)
-
-            recorder = audioRecorder
-            currentURL = outputURL
-            stopWorkItem?.cancel()
-            stopWorkItem = nil
-            return outputURL
-        }
-    }
-
-    func stopRecording(completion: @escaping (URL?) -> Void) {
-        queue.async { [weak self] in
-            guard let self = self, let recorder = self.recorder, recorder.isRecording else {
-                completion(self?.currentURL)
-                return
-            }
-
-            let item = DispatchWorkItem { [weak self] in
-                guard let self = self else { return }
-                recorder.stop()
-                self.cleanupSession()
-                let url = self.currentURL
-                self.recorder = nil
-                self.currentURL = url
-                completion(url)
-            }
-            self.stopWorkItem = item
-            self.queue.asyncAfter(deadline: .now() + self.paddingInterval, execute: item)
-        }
-    }
-
-    func cancelRecording() {
-        queue.async { [weak self] in
-            guard let self = self else { return }
-            self.stopWorkItem?.cancel()
-            self.stopWorkItem = nil
-            if let recorder = self.recorder, recorder.isRecording {
-                recorder.stop()
-            }
-            self.cleanupSession()
-            if let url = self.currentURL {
-                try? FileManager.default.removeItem(at: url)
-            }
-            self.recorder = nil
-            self.currentURL = nil
-        }
-    }
-
-    // MARK: - Metering
-
-    func currentAveragePower() -> Float {
-        queue.sync {
-            recorder?.updateMeters()
-            return recorder?.averagePower(forChannel: 0) ?? -160
-        }
-    }
-
-    // MARK: - Helpers
-
-    private func makeOutputURL() throws -> URL {
-        let formatter = DateFormatter()
-        formatter.dateFormat = "yyyyMMdd_HHmmss"
-        let fileName = "voice_\(formatter.string(from: Date())).m4a"
-
-        let baseDirectory = try applicationFilesDirectory().appendingPathComponent("voicenotes/outgoing", isDirectory: true)
-        try FileManager.default.createDirectory(at: baseDirectory, withIntermediateDirectories: true, attributes: nil)
-        return baseDirectory.appendingPathComponent(fileName)
-    }
-
-    private func applicationFilesDirectory() throws -> URL {
-        #if os(iOS)
-        return try FileManager.default.url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
-            .appendingPathComponent("files", isDirectory: true)
-        #else
-        let base = try FileManager.default.url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
-        return base.appendingPathComponent("files", isDirectory: true)
-        #endif
-    }
-
-    private func cleanupSession() {
-        #if os(iOS)
-        try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
-        #endif
-    }
-}

bitchat/Features/voice/Waveform.swift

@@ -1,113 +0,0 @@
-import AVFoundation
-import Foundation
-import BitLogger
-
-/// Generates and caches downsampled waveforms for audio files so UI rendering is cheap.
-final class WaveformCache {
-    static let shared = WaveformCache()
-
-    private let queue = DispatchQueue(label: "com.bitchat.waveform-cache", attributes: .concurrent)
-    private var cache: [URL: (waveform: [Float], lastAccess: Date)] = [:]
-    private let maxCacheSize = 20  // Limit cache to prevent unbounded memory growth
-
-    private init() {}
-
-    func cachedWaveform(for url: URL) -> [Float]? {
-        queue.sync {
-            guard let entry = cache[url] else { return nil }
-            return entry.waveform
-        }
-    }
-
-    func waveform(for url: URL, bins: Int = 120, completion: @escaping ([Float]) -> Void) {
-        queue.async { [weak self] in
-            guard let self = self else { return }
-
-            // Check cache (read-only, no update needed on cache hit for performance)
-            if let entry = self.cache[url] {
-                DispatchQueue.main.async { completion(entry.waveform) }
-                return
-            }
-
-            guard let computed = self.computeWaveform(url: url, bins: bins) else {
-                DispatchQueue.main.async { completion([]) }
-                return
-            }
-
-            self.queue.async(flags: .barrier) { [weak self] in
-                guard let self = self else { return }
-
-                // Evict oldest entry if cache is full
-                if self.cache.count >= self.maxCacheSize {
-                    if let oldest = self.cache.min(by: { $0.value.lastAccess < $1.value.lastAccess }) {
-                        self.cache.removeValue(forKey: oldest.key)
-                    }
-                }
-
-                self.cache[url] = (computed, Date())
-            }
-            DispatchQueue.main.async { completion(computed) }
-        }
-    }
-
-    func purge(url: URL) {
-        queue.async(flags: .barrier) { [weak self] in
-            self?.cache.removeValue(forKey: url)
-        }
-    }
-
-    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
-        return autoreleasepool {
-            do {
-                let audioFile = try AVAudioFile(forReading: url)
-                let length = Int(audioFile.length)
-                guard length > 0 else { return nil }
-
-                guard let buffer = AVAudioPCMBuffer(pcmFormat: audioFile.processingFormat, frameCapacity: AVAudioFrameCount(length)) else {
-                    return nil
-                }
-                try audioFile.read(into: buffer, frameCount: AVAudioFrameCount(length))
-                guard let channelData = buffer.floatChannelData else { return nil }
-
-                let channelCount = Int(audioFile.processingFormat.channelCount)
-                let frameLength = Int(buffer.frameLength)
-                let samplesPerBin = max(1, frameLength / bins)
-
-                var magnitudes: [Float] = Array(repeating: 0, count: bins)
-                for bin in 0..<bins {
-                    let start = bin * samplesPerBin
-                    let end = min(frameLength, start + samplesPerBin)
-                    if start >= end { break }
-
-                    var sum: Float = 0
-                    var sampleCount = 0
-                    for frame in start..<end {
-                        var sampleValue: Float = 0
-                        for channel in 0..<channelCount {
-                            sampleValue += fabsf(channelData[channel][frame])
-                        }
-                        sum += sampleValue / Float(channelCount)
-                        sampleCount += 1
-                    }
-                    magnitudes[bin] = sampleCount > 0 ? sum / Float(sampleCount) : 0
-                }
-
-                if let maxMagnitude = magnitudes.max(), maxMagnitude > 0 {
-                    magnitudes = magnitudes.map { min($0 / maxMagnitude, 1.0) }
-                }
-                return magnitudes
-            } catch {
-                SecureLogger.error("Waveform extraction failed for \(url.lastPathComponent): \(error)", category: .session)
-                return nil
-            }
-        }
-    }
-}

bitchat/Info.plist

@@ -37,10 +37,6 @@
 	<string>bitchat uses Bluetooth to discover and connect with other bitchat users nearby.</string>
 	<key>NSCameraUsageDescription</key>
 	<string>bitchat uses the camera to scan QR codes to verify peers.</string>
-	<key>NSPhotoLibraryUsageDescription</key>
-	<string>bitchat lets you pick images from your photo library to share with nearby peers.</string>
-	<key>NSMicrophoneUsageDescription</key>
-	<string>bitchat uses the microphone to record voice notes that relay across the mesh.</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>
 	<key>UIBackgroundModes</key>

bitchat/Models/BitchatPacket.swift

@@ -21,10 +21,9 @@ struct BitchatPacket: Codable {
     let payload: Data
     var signature: Data?
     var ttl: UInt8
-    var route: [Data]?
     
-    init(type: UInt8, senderID: Data, recipientID: Data?, timestamp: UInt64, payload: Data, signature: Data?, ttl: UInt8, version: UInt8 = 1, route: [Data]? = nil) {
-        self.version = version
+    init(type: UInt8, senderID: Data, recipientID: Data?, timestamp: UInt64, payload: Data, signature: Data?, ttl: UInt8) {
+        self.version = 1
         self.type = type
         self.senderID = senderID
         self.recipientID = recipientID
@@ -32,7 +31,6 @@ struct BitchatPacket: Codable {
         self.payload = payload
         self.signature = signature
         self.ttl = ttl
-        self.route = route
     }
     
     // Convenience initializer for new binary format
@@ -55,7 +53,6 @@ struct BitchatPacket: Codable {
         self.payload = payload
         self.signature = nil
         self.ttl = ttl
-        self.route = nil
     }
     
     var data: Data? {
@@ -83,9 +80,7 @@ struct BitchatPacket: Codable {
             timestamp: timestamp,
             payload: payload,
             signature: nil, // Remove signature for signing
-            ttl: 0, // Use fixed TTL=0 for signing to ensure relay compatibility
-            version: version,
-            route: route
+            ttl: 0 // Use fixed TTL=0 for signing to ensure relay compatibility
         )
         return BinaryProtocol.encode(unsignedPacket)
     }

bitchat/Models/CommandInfo.swift

@@ -1,58 +0,0 @@
-//
-// CommandsInfo.swift
-// bitchat
-//
-// This is free and unencumbered software released into the public domain.
-// For more information, see <https://unlicense.org>
-//
-
-import Foundation
-
-// MARK: - CommandInfo Enum
-
-enum CommandInfo: String, Identifiable {
-    case block
-    case clear
-    case hug
-    case message = "dm"
-    case slap
-    case unblock
-    case who
-    case favorite
-    case unfavorite
-    
-    var id: String { rawValue }
-    
-    var alias: String { "/" + rawValue }
-    
-    var placeholder: String? {
-        switch self {
-        case .block, .hug, .message, .slap, .unblock, .favorite, .unfavorite:
-            return "<" + String(localized: "content.input.nickname_placeholder") + ">"
-        case .clear, .who:
-            return nil
-        }
-    }
-    
-    var description: String {
-        switch self {
-        case .block:        String(localized: "content.commands.block")
-        case .clear:        String(localized: "content.commands.clear")
-        case .hug:          String(localized: "content.commands.hug")
-        case .message:      String(localized: "content.commands.message")
-        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")
-        }
-    }
-    
-    static func all(isGeoPublic: Bool, isGeoDM: Bool) -> [CommandInfo] {
-        let baseCommands: [CommandInfo] = [.block, .unblock, .clear, .hug, .message, .slap, .who]
-        if isGeoPublic || isGeoDM {
-            return baseCommands + [.favorite, .unfavorite]
-        }
-        return baseCommands
-    }
-}

bitchat/Models/PeerID.swift

@@ -35,7 +35,7 @@ struct PeerID: Equatable, Hashable {
     // Private so the callers have to go through a convenience init
     private init(prefix: Prefix, bare: any StringProtocol) {
         self.prefix = prefix
-        self.bare = String(bare).lowercased()
+        self.bare = String(bare)
     }
 }
 
@@ -76,12 +76,6 @@ extension PeerID {
     init(hexData: Data) {
         self.init(str: hexData.hexEncodedString())
     }
-    
-    /// Convenience init to "hide" hex-encoding implementation detail
-    init?(hexData: Data?) {
-        guard let hexData else { return nil }
-        self.init(hexData: hexData)
-    }
 }
 
 // MARK: - Noise Public Key Helpers
@@ -136,20 +130,6 @@ extension PeerID {
     }
 }
 
-extension PeerID {
-    var routingData: Data? {
-        if let direct = Data(hexString: id), direct.count == 8 { return direct }
-        if let bareData = Data(hexString: bare), bareData.count == 8 { return bareData }
-        let short = toShort()
-        return Data(hexString: short.id)
-    }
-
-    init?(routingData: Data) {
-        guard routingData.count == 8 else { return nil }
-        self.init(hexData: routingData)
-    }
-}
-
 // MARK: - Validation
 
 extension PeerID {
@@ -211,7 +191,9 @@ extension PeerID: Comparable {
     }
 }
 
-// MARK: - CustomStringConvertible
+// MARK: - String Interop Helpers
+
+// MARK: CustomStringConvertible
 
 extension PeerID: CustomStringConvertible {
     /// So it returns the actual `id` like before even inside another String
@@ -219,3 +201,17 @@ extension PeerID: CustomStringConvertible {
         id
     }
 }
+
+// MARK: Custom Equatable w/ String & Optionality
+
+// PeerID <> String
+extension Optional where Wrapped == PeerID {
+    static func ==(lhs: Optional<Wrapped>, rhs: Optional<String>) -> Bool   { lhs?.id == rhs }
+    static func !=(lhs: Optional<Wrapped>, rhs: Optional<String>) -> Bool   { lhs?.id != rhs }
+}
+
+// String <> PeerID
+extension Optional where Wrapped == String {
+    static func ==(lhs: Optional<Wrapped>, rhs: Optional<PeerID>) -> Bool   { lhs == rhs?.id }
+    static func !=(lhs: Optional<Wrapped>, rhs: Optional<PeerID>) -> Bool   { lhs != rhs?.id }
+}

bitchat/Models/ReadReceipt.swift

@@ -11,11 +11,11 @@ import Foundation
 struct ReadReceipt: Codable {
     let originalMessageID: String
     let receiptID: String
-    var readerID: PeerID  // Who read it
+    var readerID: String  // Who read it
     let readerNickname: String
     let timestamp: Date
     
-    init(originalMessageID: String, readerID: PeerID, readerNickname: String) {
+    init(originalMessageID: String, readerID: String, readerNickname: String) {
         self.originalMessageID = originalMessageID
         self.receiptID = UUID().uuidString
         self.readerID = readerID
@@ -24,7 +24,7 @@ struct ReadReceipt: Codable {
     }
     
     // For binary decoding
-    private init(originalMessageID: String, receiptID: String, readerID: PeerID, readerNickname: String, timestamp: Date) {
+    private init(originalMessageID: String, receiptID: String, readerID: String, readerNickname: String, timestamp: Date) {
         self.originalMessageID = originalMessageID
         self.receiptID = receiptID
         self.readerID = readerID
@@ -48,7 +48,7 @@ struct ReadReceipt: Codable {
         data.appendUUID(receiptID)
         // ReaderID as 8-byte hex string
         var readerData = Data()
-        var tempID = readerID.id
+        var tempID = readerID
         while tempID.count >= 2 && readerData.count < 8 {
             let hexByte = String(tempID.prefix(2))
             if let byte = UInt8(hexByte, radix: 16) {
@@ -78,8 +78,8 @@ struct ReadReceipt: Codable {
               let receiptID = dataCopy.readUUID(at: &offset) else { return nil }
         
         guard let readerIDData = dataCopy.readFixedBytes(at: &offset, count: 8) else { return nil }
-        let readerID = PeerID(hexData: readerIDData)
-        guard readerID.isValid else { return nil }
+        let readerID = readerIDData.hexEncodedString()
+        guard PeerID(str: readerID).isValid else { return nil }
         
         guard let timestamp = dataCopy.readDate(at: &offset),
               InputValidator.validateTimestamp(timestamp),

bitchat/Models/RequestSyncPacket.swift

@@ -8,14 +8,6 @@ struct RequestSyncPacket {
     let p: Int
     let m: UInt32
     let data: Data
-    let types: SyncTypeFlags?
-
-    init(p: Int, m: UInt32, data: Data, types: SyncTypeFlags? = nil) {
-        self.p = p
-        self.m = m
-        self.data = data
-        self.types = types
-    }
 
     func encode() -> Data {
         var out = Data()
@@ -33,9 +25,6 @@ struct RequestSyncPacket {
         putTLV(0x02, withUnsafeBytes(of: &mBE) { Data($0) })
         // data
         putTLV(0x03, data)
-        if let typesData = types?.toData() {
-            putTLV(0x04, typesData)
-        }
         return out
     }
 
@@ -44,7 +33,6 @@ struct RequestSyncPacket {
         var p: Int? = nil
         var m: UInt32? = nil
         var payload: Data? = nil
-        var types: SyncTypeFlags? = nil
 
         while off + 3 <= data.count {
             let t = Int(data[off]); off += 1
@@ -64,16 +52,12 @@ struct RequestSyncPacket {
             case 0x03:
                 if v.count > maxAcceptBytes { return nil }
                 payload = v
-            case 0x04:
-                if let decoded = SyncTypeFlags.decode(v) {
-                    types = decoded
-                }
             default:
                 break // forward compatible; ignore unknown TLVs
             }
         }
 
         guard let pp = p, let mm = m, let dd = payload, pp >= 1, mm > 0 else { return nil }
-        return RequestSyncPacket(p: pp, m: mm, data: dd, types: types)
+        return RequestSyncPacket(p: pp, m: mm, data: dd)
     }
 }

bitchat/Noise/NoiseProtocol.swift

@@ -767,7 +767,7 @@ final class NoiseHandshakeState {
             let shared = try localStatic.sharedSecretFromKeyAgreement(with: remoteStatic)
             symmetricState.mixKey(shared.withUnsafeBytes { Data($0) })
             
-        case .e, .s:
+        default:
             break
         }
     }

bitchat/Noise/NoiseSessionManager.swift

@@ -60,23 +60,24 @@ final class NoiseSessionManager {
                 throw NoiseSessionError.alreadyEstablished
             }
             
-            // Remove any existing non-established session
-            if let existingSession = sessions[peerID], !existingSession.isEstablished() {
-                _ = sessions.removeValue(forKey: peerID)
+            let session: NoiseSession
+            
+            if let existingSession = sessions[peerID] {
+                session = existingSession
+                session.reset()
+            } else {
+                // Create new initiator session
+                session = SecureNoiseSession(
+                    peerID: peerID,
+                    role: .initiator,
+                    keychain: keychain,
+                    localStaticKey: localStaticKey
+                )
+                sessions[peerID] = session
             }
             
-            // Create new initiator session
-            let session = SecureNoiseSession(
-                peerID: peerID,
-                role: .initiator,
-                keychain: keychain,
-                localStaticKey: localStaticKey
-            )
-            sessions[peerID] = session
-            
             do {
-                let handshakeData = try session.startHandshake()
-                return handshakeData
+                return try session.startHandshake()
             } catch {
                 // Clean up failed session
                 _ = sessions.removeValue(forKey: peerID)

bitchat/Nostr/GeoRelayDirectory.swift

@@ -1,11 +1,6 @@
 import BitLogger
 import Foundation
 import Tor
-#if os(iOS)
-import UIKit
-#elseif os(macOS)
-import AppKit
-#endif
 
 /// Directory of online Nostr relays with approximate GPS locations, used for geohash routing.
 @MainActor
@@ -17,32 +12,19 @@ final class GeoRelayDirectory {
     }
 
     static let shared = GeoRelayDirectory()
-
     private(set) var entries: [Entry] = []
     private let cacheFileName = "georelays_cache.csv"
     private let lastFetchKey = "georelay.lastFetchAt"
     private let remoteURL = URL(string: "https://raw.githubusercontent.com/permissionlesstech/georelays/refs/heads/main/nostr_relays.csv")!
-    private let fetchInterval: TimeInterval = TransportConfig.geoRelayFetchIntervalSeconds
-
-    private var refreshTimer: Timer?
-    private var retryTask: Task<Void, Never>?
-    private var retryAttempt: Int = 0
-    private var isFetching: Bool = false
-    private var observers: [NSObjectProtocol] = []
+    private let fetchInterval: TimeInterval = TransportConfig.geoRelayFetchIntervalSeconds // 24h
 
     private init() {
-        entries = loadLocalEntries()
-        registerObservers()
-        startRefreshTimer()
+        // Load cached or bundled data synchronously
+        self.entries = self.loadLocalEntries()
+        // Fire-and-forget remote refresh if stale
         prefetchIfNeeded()
     }
 
-    deinit {
-        observers.forEach { NotificationCenter.default.removeObserver($0) }
-        refreshTimer?.invalidate()
-        retryTask?.cancel()
-    }
-
     /// Returns up to `count` relay URLs (wss://) closest to the geohash center.
     func closestRelays(toGeohash geohash: String, count: Int = 5) -> [String] {
         let center = Geohash.decodeCenter(geohash)
@@ -51,148 +33,52 @@ final class GeoRelayDirectory {
 
     /// Returns up to `count` relay URLs (wss://) closest to the given coordinate.
     func closestRelays(toLat lat: Double, lon: Double, count: Int = 5) -> [String] {
-        guard !entries.isEmpty, count > 0 else { return [] }
-
-        if entries.count <= count {
-            return entries
-                .sorted { a, b in
-                    haversineKm(lat, lon, a.lat, a.lon) < haversineKm(lat, lon, b.lat, b.lon)
-                }
-                .map { "wss://\($0.host)" }
-        }
-
-        var best: [(entry: Entry, distance: Double)] = []
-        best.reserveCapacity(count)
-
-        for entry in entries {
-            let distance = haversineKm(lat, lon, entry.lat, entry.lon)
-            if best.count < count {
-                let idx = best.firstIndex { $0.distance > distance } ?? best.count
-                best.insert((entry, distance), at: idx)
-            } else if let worstDistance = best.last?.distance, distance < worstDistance {
-                let idx = best.firstIndex { $0.distance > distance } ?? best.count
-                best.insert((entry, distance), at: idx)
-                best.removeLast()
+        guard !entries.isEmpty else { return [] }
+        let sorted = entries
+            .sorted { a, b in
+                haversineKm(lat, lon, a.lat, a.lon) < haversineKm(lat, lon, b.lat, b.lon)
             }
-        }
-
-        return best.map { "wss://\($0.entry.host)" }
+            .prefix(count)
+        return sorted.map { "wss://\($0.host)" }
     }
 
     // MARK: - Remote Fetch
-    func prefetchIfNeeded(force: Bool = false) {
-        guard !isFetching else { return }
-
+    func prefetchIfNeeded() {
         let now = Date()
         let last = UserDefaults.standard.object(forKey: lastFetchKey) as? Date ?? .distantPast
-
-        if !force {
-            guard now.timeIntervalSince(last) >= fetchInterval else { return }
-        } else if last != .distantPast,
-                  now.timeIntervalSince(last) < TransportConfig.geoRelayRetryInitialSeconds {
-            // Skip forced fetches if we just refreshed moments ago.
-            return
-        }
-
-        cancelRetry()
+        guard now.timeIntervalSince(last) >= fetchInterval else { return }
         fetchRemote()
     }
 
     private func fetchRemote() {
-        guard !isFetching else { return }
-        isFetching = true
-
-        let request = URLRequest(
-            url: remoteURL,
-            cachePolicy: .reloadIgnoringLocalCacheData,
-            timeoutInterval: 15
-        )
-
-        Task.detached { [weak self] in
-            guard let self else { return }
-
+        let req = URLRequest(url: remoteURL, cachePolicy: .reloadIgnoringLocalCacheData, timeoutInterval: 15)
+        // Ensure Tor readiness before fetching (fail-closed by default)
+        Task.detached {
             let ready = await TorManager.shared.awaitReady()
             if !ready {
-                await self.handleFetchFailure(.torNotReady)
+                SecureLogger.warning("GeoRelayDirectory: Tor not ready; skipping remote fetch (fail-closed)", category: .session)
                 return
             }
-
-            do {
-                let (data, _) = try await TorURLSession.shared.session.data(for: request)
-                guard let text = String(data: data, encoding: .utf8) else {
-                    await self.handleFetchFailure(.invalidData)
-                    return
+            let task = TorURLSession.shared.session.dataTask(with: req) { [weak self] data, _, error in
+                guard let self = self else { return }
+                if let data = data, error == nil, let text = String(data: data, encoding: .utf8) {
+                    let parsed = GeoRelayDirectory.parseCSV(text)
+                    if !parsed.isEmpty {
+                        Task { @MainActor in
+                            self.entries = parsed
+                            self.persistCache(text)
+                            UserDefaults.standard.set(Date(), forKey: self.lastFetchKey)
+                            SecureLogger.info("GeoRelayDirectory: refreshed \(parsed.count) relays from remote", category: .session)
+                        }
+                        return
+                    }
                 }
-
-                let parsed = GeoRelayDirectory.parseCSV(text)
-                guard !parsed.isEmpty else {
-                    await self.handleFetchFailure(.invalidData)
-                    return
-                }
-
-                await self.handleFetchSuccess(entries: parsed, csv: text)
-            } catch {
-                await self.handleFetchFailure(.network(error))
+                SecureLogger.warning("GeoRelayDirectory: remote fetch failed; keeping local entries", category: .session)
             }
+            task.resume()
         }
     }
 
-    private enum FetchFailure {
-        case torNotReady
-        case invalidData
-        case network(Error)
-    }
-
-    @MainActor
-    private func handleFetchSuccess(entries parsed: [Entry], csv: String) {
-        entries = parsed
-        persistCache(csv)
-        UserDefaults.standard.set(Date(), forKey: lastFetchKey)
-        SecureLogger.info("GeoRelayDirectory: refreshed \(parsed.count) relays from remote", category: .session)
-        isFetching = false
-        retryAttempt = 0
-        cancelRetry()
-    }
-
-    @MainActor
-    private func handleFetchFailure(_ reason: FetchFailure) {
-        switch reason {
-        case .torNotReady:
-            SecureLogger.warning("GeoRelayDirectory: Tor not ready; scheduling retry", category: .session)
-        case .invalidData:
-            SecureLogger.warning("GeoRelayDirectory: remote fetch returned invalid data; scheduling retry", category: .session)
-        case .network(let error):
-            SecureLogger.warning("GeoRelayDirectory: remote fetch failed with error: \(error.localizedDescription)", category: .session)
-        }
-        isFetching = false
-        scheduleRetry()
-    }
-
-    @MainActor
-    private func scheduleRetry() {
-        retryAttempt = min(retryAttempt + 1, 10)
-        let base = TransportConfig.geoRelayRetryInitialSeconds
-        let maxDelay = TransportConfig.geoRelayRetryMaxSeconds
-        let multiplier = pow(2.0, Double(max(retryAttempt - 1, 0)))
-        let calculated = base * multiplier
-        let delay = min(maxDelay, max(base, calculated))
-
-        cancelRetry()
-        retryTask = Task { [weak self] in
-            let nanoseconds = UInt64(delay * 1_000_000_000)
-            try? await Task.sleep(nanoseconds: nanoseconds)
-            await MainActor.run {
-                self?.prefetchIfNeeded(force: true)
-            }
-        }
-    }
-
-    @MainActor
-    private func cancelRetry() {
-        retryTask?.cancel()
-        retryTask = nil
-    }
-
     private func persistCache(_ text: String) {
         guard let url = cacheURL() else { return }
         do {
@@ -205,35 +91,30 @@ final class GeoRelayDirectory {
     // MARK: - Loading
     private func loadLocalEntries() -> [Entry] {
         // Prefer cached file if present
-        if let cache = cacheURL(),
+        if let cache = self.cacheURL(),
            let data = try? Data(contentsOf: cache),
            let text = String(data: data, encoding: .utf8) {
             let arr = Self.parseCSV(text)
             if !arr.isEmpty { return arr }
         }
-
         // Try bundled resource(s)
         let bundleCandidates = [
             Bundle.main.url(forResource: "nostr_relays", withExtension: "csv"),
             Bundle.main.url(forResource: "online_relays_gps", withExtension: "csv"),
             Bundle.main.url(forResource: "online_relays_gps", withExtension: "csv", subdirectory: "relays")
         ].compactMap { $0 }
-
         for url in bundleCandidates {
-            if let data = try? Data(contentsOf: url),
-               let text = String(data: data, encoding: .utf8) {
+            if let data = try? Data(contentsOf: url), let text = String(data: data, encoding: .utf8) {
                 let arr = Self.parseCSV(text)
                 if !arr.isEmpty { return arr }
             }
         }
-
         // Try filesystem path (development/test)
         if let cwd = FileManager.default.currentDirectoryPath as String?,
            let data = try? Data(contentsOf: URL(fileURLWithPath: cwd).appendingPathComponent("relays/online_relays_gps.csv")),
            let text = String(data: data, encoding: .utf8) {
             return Self.parseCSV(text)
         }
-
         SecureLogger.warning("GeoRelayDirectory: no local CSV found; entries empty", category: .session)
         return []
     }
@@ -241,6 +122,7 @@ final class GeoRelayDirectory {
     nonisolated static func parseCSV(_ text: String) -> [Entry] {
         var result: Set<Entry> = []
         let lines = text.split(whereSeparator: { $0.isNewline })
+        // Skip header if present
         for (idx, raw) in lines.enumerated() {
             let line = raw.trimmingCharacters(in: .whitespacesAndNewlines)
             if line.isEmpty { continue }
@@ -261,76 +143,11 @@ final class GeoRelayDirectory {
 
     private func cacheURL() -> URL? {
         do {
-            let base = try FileManager.default.url(
-                for: .applicationSupportDirectory,
-                in: .userDomainMask,
-                appropriateFor: nil,
-                create: true
-            )
+            let base = try FileManager.default.url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
             let dir = base.appendingPathComponent("bitchat", isDirectory: true)
             try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
             return dir.appendingPathComponent(cacheFileName)
-        } catch {
-            return nil
-        }
-    }
-
-    // MARK: - Observers & Timers
-    private func registerObservers() {
-        let center = NotificationCenter.default
-
-        let torReady = center.addObserver(
-            forName: .TorDidBecomeReady,
-            object: nil,
-            queue: .main
-        ) { [weak self] _ in
-            guard let self else { return }
-            Task { @MainActor in
-                self.prefetchIfNeeded(force: true)
-            }
-        }
-        observers.append(torReady)
-
-#if os(iOS)
-        let didBecomeActive = center.addObserver(
-            forName: UIApplication.didBecomeActiveNotification,
-            object: nil,
-            queue: .main
-        ) { [weak self] _ in
-            guard let self else { return }
-            Task { @MainActor in
-                self.prefetchIfNeeded()
-            }
-        }
-        observers.append(didBecomeActive)
-#elseif os(macOS)
-        let didBecomeActive = center.addObserver(
-            forName: NSApplication.didBecomeActiveNotification,
-            object: nil,
-            queue: .main
-        ) { [weak self] _ in
-            guard let self else { return }
-            Task { @MainActor in
-                self.prefetchIfNeeded()
-            }
-        }
-        observers.append(didBecomeActive)
-#endif
-    }
-
-    private func startRefreshTimer() {
-        refreshTimer?.invalidate()
-        let interval = TransportConfig.geoRelayRefreshCheckIntervalSeconds
-        guard interval > 0 else { return }
-
-        let timer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { [weak self] _ in
-            guard let self else { return }
-            Task { @MainActor in
-                self.prefetchIfNeeded()
-            }
-        }
-        refreshTimer = timer
-        RunLoop.main.add(timer, forMode: .common)
+        } catch { return nil }
     }
 }
 

bitchat/Nostr/NostrEmbeddedBitChat.swift

@@ -4,7 +4,7 @@ import Foundation
 
 struct NostrEmbeddedBitChat {
     /// Build a `bitchat1:` base64url-encoded BitChat packet carrying a private message for Nostr DMs.
-    static func encodePMForNostr(content: String, messageID: String, recipientPeerID: PeerID, senderPeerID: PeerID) -> String? {
+    static func encodePMForNostr(content: String, messageID: String, recipientPeerID: String, senderPeerID: String) -> String? {
         // TLV-encode the private message
         let pm = PrivateMessagePacket(messageID: messageID, content: content)
         guard let tlv = pm.encode() else { return nil }
@@ -14,12 +14,12 @@ struct NostrEmbeddedBitChat {
         payload.append(tlv)
 
         // Determine 8-byte recipient ID to embed
-        let recipientID = normalizeRecipientPeerID(recipientPeerID)
+        let recipientIDHex: String = normalizeRecipientPeerID(recipientPeerID)
 
         let packet = BitchatPacket(
             type: MessageType.noiseEncrypted.rawValue,
-            senderID: Data(hexString: senderPeerID.id) ?? Data(),
-            recipientID: Data(hexString: recipientID.id),
+            senderID: Data(hexString: senderPeerID) ?? Data(),
+            recipientID: Data(hexString: recipientIDHex),
             timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
             payload: payload,
             signature: nil,
@@ -31,18 +31,18 @@ struct NostrEmbeddedBitChat {
     }
 
     /// Build a `bitchat1:` base64url-encoded BitChat packet carrying a delivery/read ack for Nostr DMs.
-    static func encodeAckForNostr(type: NoisePayloadType, messageID: String, recipientPeerID: PeerID, senderPeerID: PeerID) -> String? {
+    static func encodeAckForNostr(type: NoisePayloadType, messageID: String, recipientPeerID: String, senderPeerID: String) -> String? {
         guard type == .delivered || type == .readReceipt else { return nil }
 
         var payload = Data([type.rawValue])
         payload.append(Data(messageID.utf8))
 
-        let recipientID = normalizeRecipientPeerID(recipientPeerID)
+        let recipientIDHex: String = normalizeRecipientPeerID(recipientPeerID)
 
         let packet = BitchatPacket(
             type: MessageType.noiseEncrypted.rawValue,
-            senderID: Data(hexString: senderPeerID.id) ?? Data(),
-            recipientID: Data(hexString: recipientID.id),
+            senderID: Data(hexString: senderPeerID) ?? Data(),
+            recipientID: Data(hexString: recipientIDHex),
             timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
             payload: payload,
             signature: nil,
@@ -54,7 +54,7 @@ struct NostrEmbeddedBitChat {
     }
 
     /// Build a `bitchat1:` ACK (delivered/read) without an embedded recipient peer ID (geohash DMs).
-    static func encodeAckForNostrNoRecipient(type: NoisePayloadType, messageID: String, senderPeerID: PeerID) -> String? {
+    static func encodeAckForNostrNoRecipient(type: NoisePayloadType, messageID: String, senderPeerID: String) -> String? {
         guard type == .delivered || type == .readReceipt else { return nil }
 
         var payload = Data([type.rawValue])
@@ -62,7 +62,7 @@ struct NostrEmbeddedBitChat {
 
         let packet = BitchatPacket(
             type: MessageType.noiseEncrypted.rawValue,
-            senderID: Data(hexString: senderPeerID.id) ?? Data(),
+            senderID: Data(hexString: senderPeerID) ?? Data(),
             recipientID: nil,
             timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
             payload: payload,
@@ -75,7 +75,7 @@ struct NostrEmbeddedBitChat {
     }
 
     /// Build a `bitchat1:` payload without an embedded recipient peer ID (used for geohash DMs).
-    static func encodePMForNostrNoRecipient(content: String, messageID: String, senderPeerID: PeerID) -> String? {
+    static func encodePMForNostrNoRecipient(content: String, messageID: String, senderPeerID: String) -> String? {
         let pm = PrivateMessagePacket(messageID: messageID, content: content)
         guard let tlv = pm.encode() else { return nil }
 
@@ -84,7 +84,7 @@ struct NostrEmbeddedBitChat {
 
         let packet = BitchatPacket(
             type: MessageType.noiseEncrypted.rawValue,
-            senderID: Data(hexString: senderPeerID.id) ?? Data(),
+            senderID: Data(hexString: senderPeerID) ?? Data(),
             recipientID: nil,
             timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
             payload: payload,
@@ -96,11 +96,11 @@ struct NostrEmbeddedBitChat {
         return "bitchat1:" + base64URLEncode(data)
     }
 
-    private static func normalizeRecipientPeerID(_ recipientPeerID: PeerID) -> PeerID {
-        if let maybeData = Data(hexString: recipientPeerID.id) {
+    private static func normalizeRecipientPeerID(_ recipientPeerID: String) -> String {
+        if let maybeData = Data(hexString: recipientPeerID) {
             if maybeData.count == 32 {
                 // Treat as Noise static public key; derive peerID from fingerprint
-                return PeerID(publicKey: maybeData)
+                return PeerID(publicKey: maybeData).id
             } else if maybeData.count == 8 {
                 // Already an 8-byte peer ID
                 return recipientPeerID

bitchat/Nostr/NostrIdentityBridge.swift

@@ -8,12 +8,9 @@ final class NostrIdentityBridge {
     private let deviceSeedKey = "nostr-device-seed"
     // In-memory cache to avoid transient keychain access issues
     private var deviceSeedCache: Data?
-    // Cache derived identities to avoid repeated crypto during view rendering
-    private var derivedIdentityCache: [String: NostrIdentity] = [:]
-    private let cacheLock = NSLock()
-
+    
     private let keychain: KeychainHelperProtocol
-
+    
     init(keychain: KeychainHelperProtocol = KeychainHelper()) {
         self.keychain = keychain
     }
@@ -109,14 +106,6 @@ final class NostrIdentityBridge {
     /// Uses HMAC-SHA256(deviceSeed, geohash) as private key material, with fallback rehashing
     /// if the candidate is not a valid secp256k1 private key.
     func deriveIdentity(forGeohash geohash: String) throws -> NostrIdentity {
-        // Check cache first to avoid repeated crypto + keychain I/O during view rendering
-        cacheLock.lock()
-        if let cached = derivedIdentityCache[geohash] {
-            cacheLock.unlock()
-            return cached
-        }
-        cacheLock.unlock()
-
         let seed = getOrCreateDeviceSeed()
         guard let msg = geohash.data(using: .utf8) else {
             throw NSError(domain: "NostrIdentity", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid geohash string"])
@@ -136,22 +125,11 @@ final class NostrIdentityBridge {
         for i in 0..<10 {
             let keyData = candidateKey(iteration: UInt32(i))
             if let identity = try? NostrIdentity(privateKeyData: keyData) {
-                // Cache the result
-                cacheLock.lock()
-                derivedIdentityCache[geohash] = identity
-                cacheLock.unlock()
                 return identity
             }
         }
         // As a final fallback, hash the seed+msg and try again
         let fallback = (seed + msg).sha256Hash()
-        let identity = try NostrIdentity(privateKeyData: fallback)
-
-        // Cache the result
-        cacheLock.lock()
-        derivedIdentityCache[geohash] = identity
-        cacheLock.unlock()
-
-        return identity
+        return try NostrIdentity(privateKeyData: fallback)
     }
 }

bitchat/Nostr/NostrRelayManager.swift

@@ -906,16 +906,6 @@ struct NostrFilter: Encodable {
         filter.limit = limit
         return filter
     }
-
-    // For location notes with neighbors: subscribe to multiple geohashes (center + neighbors)
-    static func geohashNotes(_ geohashes: [String], since: Date? = nil, limit: Int = 200) -> NostrFilter {
-        var filter = NostrFilter()
-        filter.kinds = [1]
-        filter.since = since?.timeIntervalSince1970.toInt()
-        filter.tagFilters = ["g": geohashes]
-        filter.limit = limit
-        return filter
-    }
 }
 
 // Dynamic coding key for tag filters

bitchat/Protocols/BinaryEncodingUtils.swift

@@ -6,7 +6,6 @@
 //
 
 import Foundation
-import CryptoKit
 
 // MARK: - Hex Encoding/Decoding
 
@@ -17,11 +16,6 @@ extension Data {
         }
         return self.map { String(format: "%02x", $0) }.joined()
     }
-
-    func sha256Hex() -> String {
-        let digest = SHA256.hash(data: self)
-        return digest.map { String(format: "%02x", $0) }.joined()
-    }
     
     init?(hexString: String) {
         let len = hexString.count / 2

bitchat/Protocols/BinaryProtocol.swift

@@ -22,11 +22,11 @@
 ///
 /// ## Wire Format
 /// ```
-/// Header (Fixed 14 bytes for v1, 16 bytes for v2):
-/// +--------+------+-----+-----------+-------+------------------+
-/// |Version | Type | TTL | Timestamp | Flags | PayloadLength    |
-/// |1 byte  |1 byte|1byte| 8 bytes   | 1 byte| 2 or 4 bytes     |
-/// +--------+------+-----+-----------+-------+------------------+
+/// Header (Fixed 13 bytes):
+/// +--------+------+-----+-----------+-------+----------------+
+/// |Version | Type | TTL | Timestamp | Flags | PayloadLength  |
+/// |1 byte  |1 byte|1byte| 8 bytes   | 1 byte| 2 bytes        |
+/// +--------+------+-----+-----------+-------+----------------+
 ///
 /// Variable sections:
 /// +----------+-------------+---------+------------+
@@ -52,7 +52,7 @@
 /// ## Flag Bits
 /// - Bit 0: Has recipient ID (directed message)
 /// - Bit 1: Has signature (authenticated message)
-/// - Bit 2: Is compressed (zlib compression applied)
+/// - Bit 2: Is compressed (LZ4 compression applied)
 /// - Bits 3-7: Reserved for future use
 ///
 /// ## Size Constraints
@@ -89,7 +89,6 @@
 ///
 
 import Foundation
-import BitLogger
 
 extension Data {
     func trimmingNullBytes() -> Data {
@@ -106,119 +105,83 @@ extension Data {
 /// their binary wire format representation.
 /// - Note: All multi-byte values use network byte order (big-endian)
 struct BinaryProtocol {
-    static let v1HeaderSize = 14
-    static let v2HeaderSize = 16
+    static let headerSize = 13
     static let senderIDSize = 8
     static let recipientIDSize = 8
     static let signatureSize = 64
-
-    // Field offsets within packet header
-    struct Offsets {
-        static let version = 0
-        static let type = 1
-        static let ttl = 2
-        static let timestamp = 3
-        static let flags = 11  // After version(1) + type(1) + ttl(1) + timestamp(8)
-    }
-
-    static func headerSize(for version: UInt8) -> Int? {
-        switch version {
-        case 1: return v1HeaderSize
-        case 2: return v2HeaderSize
-        default: return nil
-        }
-    }
-
-    private static func lengthFieldSize(for version: UInt8) -> Int {
-        return version == 2 ? 4 : 2
-    }
     
     struct Flags {
         static let hasRecipient: UInt8 = 0x01
         static let hasSignature: UInt8 = 0x02
         static let isCompressed: UInt8 = 0x04
-        static let hasRoute: UInt8 = 0x08
     }
     
     // Encode BitchatPacket to binary format
     static func encode(_ packet: BitchatPacket, padding: Bool = true) -> Data? {
-        let version = packet.version
-        guard version == 1 || version == 2 else { return nil }
-
-        // Try to compress payload when beneficial, keeping original size for later decoding
+        var data = Data()
+        
+        
+        // Try to compress payload if beneficial
         var payload = packet.payload
+        var originalPayloadSize: UInt16? = nil
         var isCompressed = false
-        var originalPayloadSize: Int?
+        
         if CompressionUtil.shouldCompress(payload) {
-            // Only compress when we can represent the original length in the outbound frame
-            let maxRepresentable = version == 2 ? Int(UInt32.max) : Int(UInt16.max)
-            if payload.count <= maxRepresentable,
-               let compressedPayload = CompressionUtil.compress(payload) {
-                originalPayloadSize = payload.count
+            if let compressedPayload = CompressionUtil.compress(payload) {
+                // Store original size for decompression (2 bytes after payload)
+                originalPayloadSize = UInt16(payload.count)
                 payload = compressedPayload
                 isCompressed = true
-            }
-        }
-
-        let lengthFieldBytes = lengthFieldSize(for: version)
-        let originalRoute = packet.route ?? []
-        if originalRoute.contains(where: { $0.isEmpty }) { return nil }
-        let sanitizedRoute: [Data] = originalRoute.map { hop in
-            if hop.count == senderIDSize { return hop }
-            if hop.count > senderIDSize { return Data(hop.prefix(senderIDSize)) }
-            var padded = hop
-            padded.append(Data(repeating: 0, count: senderIDSize - hop.count))
-            return padded
-        }
-        guard sanitizedRoute.count <= 255 else { return nil }
-
-        let hasRoute = !sanitizedRoute.isEmpty
-        let routeLength = hasRoute ? 1 + sanitizedRoute.count * senderIDSize : 0
-        let originalSizeFieldBytes = isCompressed ? lengthFieldBytes : 0
-        let payloadDataSize = routeLength + payload.count + originalSizeFieldBytes
-
-        if version == 1 && payloadDataSize > Int(UInt16.max) { return nil }
-        if version == 2 && payloadDataSize > Int(UInt32.max) { return nil }
-
-        guard let headerSize = headerSize(for: version) else { return nil }
-        let estimatedHeader = headerSize + senderIDSize + (packet.recipientID == nil ? 0 : recipientIDSize)
-        let estimatedPayload = payloadDataSize
-        let estimatedSignature = (packet.signature == nil ? 0 : signatureSize)
-        var data = Data()
-        data.reserveCapacity(estimatedHeader + estimatedPayload + estimatedSignature + 255)
-
-        data.append(version)
-        data.append(packet.type)
-        data.append(packet.ttl)
-
-        for shift in stride(from: 56, through: 0, by: -8) {
-            data.append(UInt8((packet.timestamp >> UInt64(shift)) & 0xFF))
-        }
-
-        var flags: UInt8 = 0
-        if packet.recipientID != nil { flags |= Flags.hasRecipient }
-        if packet.signature != nil { flags |= Flags.hasSignature }
-        if isCompressed { flags |= Flags.isCompressed }
-        if hasRoute { flags |= Flags.hasRoute }
-        data.append(flags)
-
-        if version == 2 {
-            let length = UInt32(payloadDataSize)
-            for shift in stride(from: 24, through: 0, by: -8) {
-                data.append(UInt8((length >> UInt32(shift)) & 0xFF))
+                
+            } else {
             }
         } else {
-            let length = UInt16(payloadDataSize)
-            data.append(UInt8((length >> 8) & 0xFF))
-            data.append(UInt8(length & 0xFF))
         }
-
+        
+        // Header
+        // Reserve capacity to reduce reallocations. Estimate base size conservatively.
+        // header(13) + sender(8) + opt recipient(8) + opt originalSize(2) + payload + opt signature(64) + up to 255 pad
+        let estimatedPayload = payload.count + (isCompressed ? 2 : 0)
+        let estimated = headerSize + senderIDSize + (packet.recipientID == nil ? 0 : recipientIDSize) + estimatedPayload + (packet.signature == nil ? 0 : signatureSize) + 255
+        data.reserveCapacity(estimated)
+        data.append(packet.version)
+        data.append(packet.type)
+        data.append(packet.ttl)
+        
+        // Timestamp (8 bytes, big-endian)
+        for i in (0..<8).reversed() {
+            data.append(UInt8((packet.timestamp >> (i * 8)) & 0xFF))
+        }
+        
+        // Flags
+        var flags: UInt8 = 0
+        if packet.recipientID != nil {
+            flags |= Flags.hasRecipient
+        }
+        if packet.signature != nil {
+            flags |= Flags.hasSignature
+        }
+        if isCompressed {
+            flags |= Flags.isCompressed
+        }
+        data.append(flags)
+        
+        // Payload length (2 bytes, big-endian) - includes original size if compressed
+        let payloadDataSize = payload.count + (isCompressed ? 2 : 0)
+        let payloadLength = UInt16(payloadDataSize)
+        
+        
+        data.append(UInt8((payloadLength >> 8) & 0xFF))
+        data.append(UInt8(payloadLength & 0xFF))
+        
+        // SenderID (exactly 8 bytes)
         let senderBytes = packet.senderID.prefix(senderIDSize)
         data.append(senderBytes)
         if senderBytes.count < senderIDSize {
             data.append(Data(repeating: 0, count: senderIDSize - senderBytes.count))
         }
-
+        
+        // RecipientID (if present)
         if let recipientID = packet.recipientID {
             let recipientBytes = recipientID.prefix(recipientIDSize)
             data.append(recipientBytes)
@@ -226,37 +189,30 @@ struct BinaryProtocol {
                 data.append(Data(repeating: 0, count: recipientIDSize - recipientBytes.count))
             }
         }
-
-        if hasRoute {
-            data.append(UInt8(sanitizedRoute.count))
-            for hop in sanitizedRoute {
-                data.append(hop)
-            }
-        }
-
+        
+        // Payload (with original size prepended if compressed)
         if isCompressed, let originalSize = originalPayloadSize {
-            if version == 2 {
-                let value = UInt32(originalSize)
-                for shift in stride(from: 24, through: 0, by: -8) {
-                    data.append(UInt8((value >> UInt32(shift)) & 0xFF))
-                }
-            } else {
-                let value = UInt16(originalSize)
-                data.append(UInt8((value >> 8) & 0xFF))
-                data.append(UInt8(value & 0xFF))
-            }
+            // Prepend original size (2 bytes, big-endian)
+            data.append(UInt8((originalSize >> 8) & 0xFF))
+            data.append(UInt8(originalSize & 0xFF))
         }
         data.append(payload)
-
+        
+        // Signature (if present)
         if let signature = packet.signature {
             data.append(signature.prefix(signatureSize))
         }
-
+        
+        
+        // Apply padding to standard block sizes for traffic analysis resistance
         if padding {
             let optimalSize = MessagePadding.optimalBlockSize(for: data.count)
-            return MessagePadding.pad(data, toSize: optimalSize)
+            let paddedData = MessagePadding.pad(data, toSize: optimalSize)
+            return paddedData
+        } else {
+            // Caller explicitly requested no padding (e.g., BLE write path)
+            return data
         }
-        return data
     }
     
     // Decode binary data to BitchatPacket
@@ -271,129 +227,87 @@ struct BinaryProtocol {
 
     // Core decoding implementation used by decode(_:) with and without padding removal
     private static func decodeCore(_ raw: Data) -> BitchatPacket? {
-        guard raw.count >= v1HeaderSize + senderIDSize else { return nil }
+        // Minimum size: header + senderID
+        guard raw.count >= headerSize + senderIDSize else { return nil }
 
         return raw.withUnsafeBytes { (buf: UnsafeRawBufferPointer) -> BitchatPacket? in
             guard let base = buf.baseAddress else { return nil }
             var offset = 0
             func require(_ n: Int) -> Bool { offset + n <= buf.count }
+            // Read single byte
             func read8() -> UInt8? {
                 guard require(1) else { return nil }
-                let value = base.advanced(by: offset).assumingMemoryBound(to: UInt8.self).pointee
+                let v = base.advanced(by: offset).assumingMemoryBound(to: UInt8.self).pointee
                 offset += 1
-                return value
+                return v
             }
+            // Read big-endian 16-bit
             func read16() -> UInt16? {
                 guard require(2) else { return nil }
-                let ptr = base.advanced(by: offset).assumingMemoryBound(to: UInt8.self)
-                let value = (UInt16(ptr[0]) << 8) | UInt16(ptr[1])
+                let p = base.advanced(by: offset).assumingMemoryBound(to: UInt8.self)
+                let v = (UInt16(p[0]) << 8) | UInt16(p[1])
                 offset += 2
-                return value
-            }
-            func read32() -> UInt32? {
-                guard require(4) else { return nil }
-                let ptr = base.advanced(by: offset).assumingMemoryBound(to: UInt8.self)
-                let value = (UInt32(ptr[0]) << 24) | (UInt32(ptr[1]) << 16) | (UInt32(ptr[2]) << 8) | UInt32(ptr[3])
-                offset += 4
-                return value
+                return v
             }
+            // Copy N bytes into Data
             func readData(_ n: Int) -> Data? {
                 guard require(n) else { return nil }
                 let ptr = base.advanced(by: offset)
-                let data = Data(bytes: ptr, count: n)
+                let d = Data(bytes: ptr, count: n)
                 offset += n
-                return data
+                return d
             }
 
-            guard let version = read8(), version == 1 || version == 2 else { return nil }
-            let lengthFieldBytes = lengthFieldSize(for: version)
-            guard let headerSize = headerSize(for: version) else { return nil }
-            let minimumRequired = headerSize + senderIDSize
-            guard raw.count >= minimumRequired else { return nil }
+            // Version
+            guard let version = read8(), version == 1 else { return nil }
+            guard let type = read8() else { return nil }
+            guard let ttl = read8() else { return nil }
 
-            guard let type = read8(), let ttl = read8() else { return nil }
-
-            var timestamp: UInt64 = 0
+            // Timestamp 8 bytes BE
+            guard require(8) else { return nil }
+            var ts: UInt64 = 0
             for _ in 0..<8 {
-                guard let byte = read8() else { return nil }
-                timestamp = (timestamp << 8) | UInt64(byte)
+                guard let b = read8() else { return nil }
+                ts = (ts << 8) | UInt64(b)
             }
 
+            // Flags
             guard let flags = read8() else { return nil }
             let hasRecipient = (flags & Flags.hasRecipient) != 0
             let hasSignature = (flags & Flags.hasSignature) != 0
             let isCompressed = (flags & Flags.isCompressed) != 0
 
-            let payloadLength: Int
-            if version == 2 {
-                guard let len = read32() else { return nil }
-                payloadLength = Int(len)
-            } else {
-                guard let len = read16() else { return nil }
-                payloadLength = Int(len)
-            }
-
-            guard payloadLength >= 0 else { return nil }
+            // Payload length
+            guard let payloadLen = read16(), payloadLen <= 65535 else { return nil }
 
+            // SenderID
             guard let senderID = readData(senderIDSize) else { return nil }
 
+            // Recipient
             var recipientID: Data? = nil
             if hasRecipient {
                 recipientID = readData(recipientIDSize)
                 if recipientID == nil { return nil }
             }
 
-            var route: [Data]? = nil
-            var remainingPayloadBytes = payloadLength
-
-            if (flags & Flags.hasRoute) != 0 {
-                guard remainingPayloadBytes >= 1, let routeCount = read8() else { return nil }
-                remainingPayloadBytes -= 1
-                if routeCount > 0 {
-                    var hops: [Data] = []
-                    for _ in 0..<Int(routeCount) {
-                        guard remainingPayloadBytes >= senderIDSize,
-                              let hop = readData(senderIDSize) else { return nil }
-                        remainingPayloadBytes -= senderIDSize
-                        hops.append(hop)
-                    }
-                    route = hops
-                }
-            }
-
+            // Payload
             let payload: Data
             if isCompressed {
-                guard remainingPayloadBytes >= lengthFieldBytes else { return nil }
-                let originalSize: Int
-                if version == 2 {
-                    guard let rawSize = read32() else { return nil }
-                    originalSize = Int(rawSize)
-                } else {
-                    guard let rawSize = read16() else { return nil }
-                    originalSize = Int(rawSize)
-                }
-                remainingPayloadBytes -= lengthFieldBytes
-                guard originalSize >= 0 && originalSize <= FileTransferLimits.maxFramedFileBytes else { return nil }
-                let compressedSize = remainingPayloadBytes
-                guard compressedSize > 0, let compressed = readData(compressedSize) else { return nil }
-                remainingPayloadBytes = 0
-
-                let compressionRatio = Double(originalSize) / Double(compressedSize)
-                guard compressionRatio <= 50_000.0 else {
-                    SecureLogger.warning("🚫 Suspicious compression ratio: \(String(format: "%.0f", compressionRatio)):1", category: .security)
-                    return nil
-                }
-
+                // Need original size (2 bytes)
+                guard let origSize16 = read16() else { return nil }
+                let originalSize = Int(origSize16)
+                guard originalSize >= 0 && originalSize <= 1_048_576 else { return nil }
+                let compSize = Int(payloadLen) - 2
+                guard compSize >= 0, let compressed = readData(compSize) else { return nil }
                 guard let decompressed = CompressionUtil.decompress(compressed, originalSize: originalSize),
                       decompressed.count == originalSize else { return nil }
                 payload = decompressed
             } else {
-                guard remainingPayloadBytes >= 0,
-                      let rawPayload = readData(remainingPayloadBytes) else { return nil }
-                remainingPayloadBytes = 0
-                payload = rawPayload
+                guard let p = readData(Int(payloadLen)) else { return nil }
+                payload = p
             }
 
+            // Signature
             var signature: Data? = nil
             if hasSignature {
                 signature = readData(signatureSize)
@@ -406,12 +320,10 @@ struct BinaryProtocol {
                 type: type,
                 senderID: senderID,
                 recipientID: recipientID,
-                timestamp: timestamp,
+                timestamp: ts,
                 payload: payload,
                 signature: signature,
-                ttl: ttl,
-                version: version,
-                route: route
+                ttl: ttl
             )
         }
     }

bitchat/Protocols/BitchatFilePacket.swift

@@ -1,155 +0,0 @@
-//
-// BitchatFilePacket.swift
-// bitchat
-//
-// This is free and unencumbered software released into the public domain.
-// For more information, see <https://unlicense.org>
-//
-
-import Foundation
-import BitLogger
-
-/// TLV payload for Bluetooth mesh file transfers (voice notes, images, generic files).
-/// Mirrors the Android client specification to ensure cross-platform interoperability.
-struct BitchatFilePacket {
-    var fileName: String?
-    var fileSize: UInt64?
-    var mimeType: String?
-    var content: Data
-
-    /// Canonical TLV tags defined by the Android implementation.
-    private enum TLVType: UInt8 {
-        case fileName = 0x01
-        case fileSize = 0x02
-        case mimeType = 0x03
-        case content = 0x04
-    }
-
-    /// Encodes the packet using v2 canonical TLVs (4-byte FILE_SIZE, 4-byte CONTENT length).
-    /// Returns `nil` when fields exceed protocol limits (e.g., content > UInt32.max).
-    func encode() -> Data? {
-        let resolvedSize = fileSize ?? UInt64(content.count)
-        guard resolvedSize <= UInt64(UInt32.max) else { return nil }
-        guard resolvedSize <= UInt64(FileTransferLimits.maxPayloadBytes) else { return nil }
-        guard content.count <= Int(UInt32.max) else { return nil }
-        guard FileTransferLimits.isValidPayload(content.count) else { return nil }
-
-        func appendBE<T: FixedWidthInteger>(_ value: T, into data: inout Data) {
-            var big = value.bigEndian
-            withUnsafeBytes(of: &big) { data.append(contentsOf: $0) }
-        }
-
-        var encoded = Data()
-
-        if let name = fileName, let nameData = name.data(using: .utf8), nameData.count <= Int(UInt16.max) {
-            encoded.append(TLVType.fileName.rawValue)
-            appendBE(UInt16(nameData.count), into: &encoded)
-            encoded.append(nameData)
-        }
-
-        encoded.append(TLVType.fileSize.rawValue)
-        appendBE(UInt16(4), into: &encoded)
-        appendBE(UInt32(resolvedSize), into: &encoded)
-
-        if let mime = mimeType, let mimeData = mime.data(using: .utf8), mimeData.count <= Int(UInt16.max) {
-            encoded.append(TLVType.mimeType.rawValue)
-            appendBE(UInt16(mimeData.count), into: &encoded)
-            encoded.append(mimeData)
-        }
-
-        encoded.append(TLVType.content.rawValue)
-        appendBE(UInt32(content.count), into: &encoded)
-        encoded.append(content)
-
-        return encoded
-    }
-
-    /// Decodes TLV payloads, tolerating legacy encodings (FILE_SIZE len=8, CONTENT len=2) when possible.
-    static func decode(_ data: Data) -> BitchatFilePacket? {
-        var cursor = data.startIndex
-        let end = data.endIndex
-
-        var fileName: String?
-        var fileSize: UInt64?
-        var mimeType: String?
-        var content = Data()
-
-        while cursor < end {
-            let typeRaw = data[cursor]
-            cursor = data.index(after: cursor)
-
-            guard cursor <= end else { return nil }
-            let tlvType = TLVType(rawValue: typeRaw)
-
-            func readBigEndianLength(bytes: Int) -> Int? {
-                guard data.distance(from: cursor, to: end) >= bytes else { return nil }
-                // Use UInt64 to prevent integer overflow during shift operations
-                var result: UInt64 = 0
-                for _ in 0..<bytes {
-                    result = (result << 8) | UInt64(data[cursor])
-                    cursor = data.index(after: cursor)
-                }
-                // Safely convert to Int with overflow check
-                guard result <= Int.max else { return nil }
-                return Int(result)
-            }
-
-            let length: Int?
-            if tlvType == .content {
-                let snapshot = cursor
-                let canonical = readBigEndianLength(bytes: 4)
-                if let canonical = canonical,
-                   canonical <= data.distance(from: cursor, to: end) {
-                    length = canonical
-                } else {
-                    cursor = snapshot
-                    length = readBigEndianLength(bytes: 2)
-                }
-            } else {
-                length = readBigEndianLength(bytes: 2)
-            }
-
-            guard let tlvLength = length, tlvLength >= 0 else { return nil }
-            guard data.distance(from: cursor, to: end) >= tlvLength else { return nil }
-
-            let valueStart = cursor
-            cursor = data.index(cursor, offsetBy: tlvLength)
-            let value = data[valueStart..<cursor]
-
-            switch tlvType {
-            case .fileName:
-                fileName = String(data: Data(value), encoding: .utf8)
-            case .fileSize:
-                if tlvLength == 4 || tlvLength == 8 {
-                    var size: UInt64 = 0
-                    for byte in value {
-                        size = (size << 8) | UInt64(byte)
-                    }
-                    if size > UInt64(FileTransferLimits.maxPayloadBytes) {
-                        return nil
-                    }
-                    fileSize = size
-                }
-            case .mimeType:
-                mimeType = String(data: Data(value), encoding: .utf8)
-            case .content:
-                let proposedSize = content.count + value.count
-                if proposedSize > FileTransferLimits.maxPayloadBytes {
-                    return nil
-                }
-                content.append(contentsOf: value)
-            case nil:
-                continue
-            }
-        }
-
-        guard !content.isEmpty else { return nil }
-        guard FileTransferLimits.isValidPayload(content.count) else { return nil }
-        return BitchatFilePacket(
-            fileName: fileName,
-            fileSize: fileSize ?? UInt64(content.count),
-            mimeType: mimeType,
-            content: content
-        )
-    }
-}

bitchat/Protocols/BitchatProtocol.swift

@@ -79,7 +79,6 @@ enum MessageType: UInt8 {
     
     // Fragmentation (simplified)
     case fragment = 0x20        // Single fragment type for large messages
-    case fileTransfer = 0x22    // Binary file/audio/image payloads
     
     var description: String {
         switch self {
@@ -90,7 +89,6 @@ enum MessageType: UInt8 {
         case .noiseHandshake: return "noiseHandshake"
         case .noiseEncrypted: return "noiseEncrypted"
         case .fragment: return "fragment"
-        case .fileTransfer: return "fileTransfer"
         }
     }
 }
@@ -178,7 +176,7 @@ protocol BitchatDelegate: AnyObject {
 
     // Bluetooth state updates for user notifications
     func didUpdateBluetoothState(_ state: CBManagerState)
-    func didReceivePublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date, messageID: String?)
+    func didReceivePublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date)
 }
 
 // Provide default implementation to make it effectively optional
@@ -195,7 +193,7 @@ extension BitchatDelegate {
         // Default empty implementation
     }
 
-    func didReceivePublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date, messageID: String?) {
+    func didReceivePublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date) {
         // Default empty implementation
     }
 }

bitchat/Protocols/Geohash.swift

@@ -119,57 +119,4 @@ enum Geohash {
         }
         return (latInterval.0, latInterval.1, lonInterval.0, lonInterval.1)
     }
-
-    /// Returns all 8 neighboring geohash cells at the same precision.
-    /// - Parameter geohash: Base32 geohash string.
-    /// - Returns: Array of 8 neighboring geohashes (N, NE, E, SE, S, SW, W, NW order).
-    static func neighbors(of geohash: String) -> [String] {
-        guard !geohash.isEmpty else { return [] }
-
-        let precision = geohash.count
-        let bounds = decodeBounds(geohash)
-        let center = decodeCenter(geohash)
-
-        // Calculate cell dimensions
-        let latHeight = bounds.latMax - bounds.latMin
-        let lonWidth = bounds.lonMax - bounds.lonMin
-
-        // Helper to wrap longitude around ±180
-        func wrapLongitude(_ lon: Double) -> Double {
-            var wrapped = lon
-            while wrapped > 180.0 { wrapped -= 360.0 }
-            while wrapped < -180.0 { wrapped += 360.0 }
-            return wrapped
-        }
-
-        // Helper to clamp latitude to ±90
-        func clampLatitude(_ lat: Double) -> Double {
-            return max(-90.0, min(90.0, lat))
-        }
-
-        // Calculate 8 neighbor centers
-        let neighbors: [(lat: Double, lon: Double)] = [
-            (center.lat + latHeight, center.lon),                    // N
-            (center.lat + latHeight, center.lon + lonWidth),         // NE
-            (center.lat, center.lon + lonWidth),                     // E
-            (center.lat - latHeight, center.lon + lonWidth),         // SE
-            (center.lat - latHeight, center.lon),                    // S
-            (center.lat - latHeight, center.lon - lonWidth),         // SW
-            (center.lat, center.lon - lonWidth),                     // W
-            (center.lat + latHeight, center.lon - lonWidth)          // NW
-        ]
-
-        // Encode each neighbor, handling boundary conditions
-        return neighbors.compactMap { neighbor in
-            let lat = clampLatitude(neighbor.lat)
-            let lon = wrapLongitude(neighbor.lon)
-
-            // Skip if we've crossed a pole (latitude clamped to boundary)
-            if (neighbor.lat > 90.0 || neighbor.lat < -90.0) {
-                return nil
-            }
-
-            return encode(latitude: lat, longitude: lon, precision: precision)
-        }
-    }
 }

bitchat/Protocols/LocationChannel.swift

@@ -116,18 +116,4 @@ enum ChannelID: Equatable, Codable {
         case .location(let ch): return ch.geohash
         }
     }
-    
-    var isMesh: Bool {
-        switch self {
-        case .mesh:     true
-        case .location: false
-        }
-    }
-    
-    var isLocation: Bool {
-        switch self {
-        case .mesh:     false
-        case .location: true
-        }
-    }
 }

bitchat/Protocols/Packets.swift

@@ -6,13 +6,11 @@ struct AnnouncementPacket {
     let nickname: String
     let noisePublicKey: Data            // Noise static public key (Curve25519.KeyAgreement)
     let signingPublicKey: Data          // Ed25519 public key for signing
-    let directNeighbors: [Data]?        // 8-byte peer IDs
 
     private enum TLVType: UInt8 {
         case nickname = 0x01
         case noisePublicKey = 0x02
         case signingPublicKey = 0x03
-        case directNeighbors = 0x04
     }
 
     func encode() -> Data? {
@@ -37,16 +35,6 @@ struct AnnouncementPacket {
         data.append(TLVType.signingPublicKey.rawValue)
         data.append(UInt8(signingPublicKey.count))
         data.append(signingPublicKey)
-        
-        // TLV for direct neighbors (optional)
-        if let neighbors = directNeighbors, !neighbors.isEmpty {
-            let neighborsData = neighbors.prefix(10).reduce(Data()) { $0 + $1 }
-            if !neighborsData.isEmpty && neighborsData.count % 8 == 0 {
-                data.append(TLVType.directNeighbors.rawValue)
-                data.append(UInt8(neighborsData.count))
-                data.append(neighborsData)
-            }
-        }
 
         return data
     }
@@ -56,7 +44,6 @@ struct AnnouncementPacket {
         var nickname: String?
         var noisePublicKey: Data?
         var signingPublicKey: Data?
-        var directNeighbors: [Data]?
 
         while offset + 2 <= data.count {
             let typeRaw = data[offset]
@@ -76,17 +63,6 @@ struct AnnouncementPacket {
                     noisePublicKey = Data(value)
                 case .signingPublicKey:
                     signingPublicKey = Data(value)
-                case .directNeighbors:
-                    if length > 0 && length % 8 == 0 {
-                        var neighbors = [Data]()
-                        let count = length / 8
-                        for i in 0..<count {
-                            let start = value.startIndex + i * 8
-                            let end = start + 8
-                            neighbors.append(Data(value[start..<end]))
-                        }
-                        directNeighbors = neighbors
-                    }
                 }
             } else {
                 // Unknown TLV; skip (tolerant decoder for forward compatibility)
@@ -98,8 +74,7 @@ struct AnnouncementPacket {
         return AnnouncementPacket(
             nickname: nickname,
             noisePublicKey: noisePublicKey,
-            signingPublicKey: signingPublicKey,
-            directNeighbors: directNeighbors
+            signingPublicKey: signingPublicKey
         )
     }
 }

bitchat/Services/BLE/MimeType.swift

@@ -1,195 +0,0 @@
-//
-// MimeType.swift
-// bitchat
-//
-// This is free and unencumbered software released into the public domain.
-// For more information, see <https://unlicense.org>
-//
-
-import UniformTypeIdentifiers
-
-// MARK: - Extensions for missing UTTypes
-
-extension UTType {
-    static let webP = UTType(importedAs: "image/webp")
-    static let aac  = UTType(importedAs: "audio/aac")
-    static let m4a  = UTType(importedAs: "audio/m4a")
-    static let ogg  = UTType(importedAs: "audio/ogg")
-}
-
-// MARK: - MimeType Enum
-
-enum MimeType: CaseIterable, Hashable {
-    case jpeg
-    case jpg
-    case png
-    case gif
-    case webp
-    case mp4Audio
-    case m4a
-    case aac
-    case mpeg
-    case mp3
-    case wav
-    case xWav
-    case ogg
-    case pdf
-    case octetStream
-
-    var utType: UTType {
-        switch self {
-        case .jpeg, .jpg:   .jpeg
-        case .png:          .png
-        case .gif:          .gif
-        case .webp:         .webP
-        case .aac:          .aac
-        case .m4a:          .m4a
-        case .mp4Audio:     .mpeg4Audio
-        case .mp3, .mpeg:   .mp3
-        case .wav, .xWav:   .wav
-        case .ogg:          .ogg
-        case .pdf:          .pdf
-        case .octetStream:  .data
-        }
-    }
-    
-    var category: Category {
-        switch self {
-        case .jpeg, .jpg, .png, .gif, .webp:
-            return .image
-        case .aac, .m4a, .mp4Audio, .mpeg, .mp3, .wav, .xWav, .ogg:
-            return .audio
-        case .pdf, .octetStream:
-            return .file
-        }
-    }
-
-
-    var mimeString: String {
-        switch self {
-        case .jpeg, .jpg:   "image/jpeg"
-        case .png:          "image/png"
-        case .gif:          "image/gif"
-        case .webp:         "image/webp"
-        case .mp4Audio:     "audio/mp4"
-        case .m4a:          "audio/m4a"
-        case .aac:          "audio/aac"
-        case .mpeg:         "audio/mpeg"
-        case .mp3:          "audio/mp3"
-        case .wav:          "audio/wav"
-        case .xWav:         "audio/x-wav"
-        case .ogg:          "audio/ogg"
-        case .pdf:          "application/pdf"
-        case .octetStream:  "application/octet-stream"
-        }
-    }
-    
-    var defaultExtension: String {
-        switch self {
-        case .jpeg, .jpg:           "jpg"
-        case .png:                  "png"
-        case .webp:                 "webp"
-        case .gif:                  "gif"
-        case .mp4Audio, .m4a, .aac: "m4a"
-        case .mpeg, .mp3:           "mp3"
-        case .wav, .xWav:           "wav"
-        case .ogg:                  "ogg"
-        case .pdf:                  "pdf"
-        case .octetStream:          "bin"
-        }
-    }
-
-    static var allowed: Set<MimeType> = [
-        .jpeg, .jpg, .png, .gif, .webp,
-        .mp4Audio, .m4a, .aac, .mpeg, .mp3,
-        .wav, .xWav, .ogg,
-        .pdf, .octetStream
-    ]
-
-    var isAllowed: Bool {
-        Self.allowed.contains(self)
-    }
-
-    // MARK: - Byte signature validation
-    func matches(data: Data) -> Bool {
-        guard !data.isEmpty else { return false }
-
-        // Generic type → skip validation
-        if self == .octetStream { return true }
-
-        switch self {
-        case .jpeg, .jpg:
-            return data.count >= 3 && data[0] == 0xFF && data[1] == 0xD8 && data[2] == 0xFF
-
-        case .png:
-            return data.count >= 8 &&
-                   data[0] == 0x89 && data[1] == 0x50 && data[2] == 0x4E && data[3] == 0x47 &&
-                   data[4] == 0x0D && data[5] == 0x0A && data[6] == 0x1A && data[7] == 0x0A
-
-        case .gif:
-            return data.count >= 6 && data[0] == 0x47 && data[1] == 0x49 && data[2] == 0x46 &&
-                   data[3] == 0x38 && (data[4] == 0x37 || data[4] == 0x39) && data[5] == 0x61
-
-        case .webp:
-            return data.count >= 12 &&
-                   data[0] == 0x52 && data[1] == 0x49 && data[2] == 0x46 && data[3] == 0x46 &&
-                   data[8] == 0x57 && data[9] == 0x45 && data[10] == 0x42 && data[11] == 0x50
-
-        case .m4a, .mp4Audio, .aac:
-            // AVAudioRecorder output varies by platform - be lenient
-            // Security: size already capped + sandboxed execution
-            return data.count > 100
-
-        case .mpeg, .mp3:
-            if data.count >= 3 && data[0] == 0x49 && data[1] == 0x44 && data[2] == 0x33 {
-                return true // ID3 header
-            }
-            return data.count >= 2 && data[0] == 0xFF && (data[1] & 0xE0) == 0xE0
-
-        case .wav, .xWav:
-            return data.count >= 12 &&
-                   data[0] == 0x52 && data[1] == 0x49 && data[2] == 0x46 && data[3] == 0x46 &&
-                   data[8] == 0x57 && data[9] == 0x41 && data[10] == 0x56 && data[11] == 0x45
-
-        case .ogg:
-            return data.count >= 4 &&
-                   data[0] == 0x4F && data[1] == 0x67 && data[2] == 0x67 && data[3] == 0x53
-
-        case .pdf:
-            return data.count >= 4 &&
-                   data[0] == 0x25 && data[1] == 0x50 && data[2] == 0x44 && data[3] == 0x46
-
-        default:
-            return false
-        }
-    }
-
-    // MARK: - Convenience Initializers
-
-    init?(_ mimeString: String?) {
-        guard let mimeString else { return nil }
-        
-        let normalized = mimeString.lowercased()
-
-        // Direct match with our canonical list
-        if let match = MimeType.allCases.first(where: { $0.mimeString == normalized }) {
-            self = match
-            return
-        }
-
-        // Let UTType normalize aliases like "image/jpg", "audio/x-wav", etc.
-        if let type = UTType(mimeType: normalized),
-           let match = MimeType.allCases.first(where: { type.conforms(to: $0.utType) }) {
-            self = match
-            return
-        }
-
-        return nil
-    }
-}
-
-extension MimeType {
-    enum Category: String {
-        case audio, image, file
-    }
-}

bitchat/Services/CommandProcessor.swift

@@ -65,11 +65,14 @@ final class CommandProcessor {
         case "/unfav":
             if inGeoPublic || inGeoDM { return .error(message: "favorites are only for mesh peers in #mesh") }
             return handleFavorite(args, add: false)
+        //
+        case "/help", "/h":
+            return .error(message: "unknown command: \(cmd)")
         default:
             return .error(message: "unknown command: \(cmd)")
         }
     }
-
+    
     // MARK: - Command Handlers
     
     private func handleMessage(_ args: String) -> CommandResult {
@@ -308,4 +311,19 @@ final class CommandProcessor {
         }
     }
     
+    private func handleHelp() -> CommandResult {
+        let helpText = """
+        commands:
+        /msg @name - start private chat
+        /who - list who's online
+        /clear - clear messages
+        /hug @name - send a hug
+        /slap @name - slap with a trout
+        /fav @name - add to favorites
+        /unfav @name - remove from favorites
+        /block @name - block
+        /unblock @name - unblock
+        """
+        return .success(message: helpText)
+    }
 }

bitchat/Services/KeychainManager.swift

@@ -27,6 +27,34 @@ final class KeychainManager: KeychainManagerProtocol {
     private let service = BitchatApp.bundleID
     private let appGroup = "group.\(BitchatApp.bundleID)"
     
+    private func isSandboxed() -> Bool {
+        #if os(macOS)
+        // More robust sandbox detection using multiple methods
+        
+        // Method 1: Check environment variable (can be spoofed)
+        let environment = ProcessInfo.processInfo.environment
+        let hasEnvVar = environment["APP_SANDBOX_CONTAINER_ID"] != nil
+        
+        // Method 2: Check if we can access a path outside sandbox
+        let homeDir = FileManager.default.homeDirectoryForCurrentUser
+        let testPath = homeDir.appendingPathComponent("../../../tmp/bitchat_sandbox_test_\(UUID().uuidString)")
+        let canWriteOutsideSandbox = FileManager.default.createFile(atPath: testPath.path, contents: nil, attributes: nil)
+        if canWriteOutsideSandbox {
+            try? FileManager.default.removeItem(at: testPath)
+        }
+        
+        // Method 3: Check container path
+        let containerPath = FileManager.default.urls(for: .libraryDirectory, in: .userDomainMask).first?.path ?? ""
+        let hasContainerPath = containerPath.contains("/Containers/")
+        
+        // If any method indicates sandbox, we consider it sandboxed
+        return hasEnvVar || !canWriteOutsideSandbox || hasContainerPath
+        #else
+        // iOS is always sandboxed
+        return true
+        #endif
+    }
+    
     // MARK: - Identity Keys
     
     func saveIdentityKey(_ keyData: Data, forKey key: String) -> Bool {

bitchat/Services/LocationChannelManager.swift

@@ -64,9 +64,7 @@ final class LocationChannelManager: NSObject, CLLocationManagerDelegate, Observa
         switch status {
         case .authorizedAlways, .authorizedWhenInUse, .authorized:
             break // will compute from location
-        case .notDetermined, .restricted, .denied:
-            fallthrough
-        @unknown default:
+        default:
             if case .location(let ch) = selectedChannel {
                 teleported = teleportedSet.contains(ch.geohash)
             }

bitchat/Services/LocationNotesCounter.swift

@@ -0,0 +1,104 @@
+import BitLogger
+import Foundation
+
+struct LocationNotesCounterDependencies {
+    typealias RelayLookup = @MainActor (_ geohash: String, _ count: Int) -> [String]
+    typealias Subscribe = @MainActor (_ filter: NostrFilter, _ id: String, _ relays: [String], _ handler: @escaping (NostrEvent) -> Void, _ onEOSE: (() -> Void)?) -> Void
+    typealias Unsubscribe = @MainActor (_ id: String) -> Void
+
+    var relayLookup: RelayLookup
+    var subscribe: Subscribe
+    var unsubscribe: Unsubscribe
+
+    static let live = LocationNotesCounterDependencies(
+        relayLookup: { geohash, count in
+            GeoRelayDirectory.shared.closestRelays(toGeohash: geohash, count: count)
+        },
+        subscribe: { filter, id, relays, handler, onEOSE in
+            NostrRelayManager.shared.subscribe(
+                filter: filter,
+                id: id,
+                relayUrls: relays,
+                handler: handler,
+                onEOSE: onEOSE
+            )
+        },
+        unsubscribe: { id in
+            NostrRelayManager.shared.unsubscribe(id: id)
+        }
+    )
+}
+
+/// Lightweight background counter for location notes (kind 1) at building-level geohash (8 chars).
+@MainActor
+final class LocationNotesCounter: ObservableObject {
+    static let shared = LocationNotesCounter()
+
+    @Published private(set) var geohash: String? = nil
+    @Published private(set) var count: Int? = 0
+    @Published private(set) var initialLoadComplete: Bool = false
+    @Published private(set) var relayAvailable: Bool = true
+
+    private var subscriptionID: String? = nil
+    private var noteIDs = Set<String>()
+    private let dependencies: LocationNotesCounterDependencies
+
+    private init(dependencies: LocationNotesCounterDependencies = .live) {
+        self.dependencies = dependencies
+    }
+
+    init(testDependencies: LocationNotesCounterDependencies) {
+        self.dependencies = testDependencies
+    }
+
+    func subscribe(geohash gh: String) {
+        let norm = gh.lowercased()
+        if geohash == norm, subscriptionID != nil { return }
+        // Validate geohash (building-level precision: 8 chars)
+        guard Geohash.isValidBuildingGeohash(norm) else {
+            SecureLogger.warning("LocationNotesCounter: rejecting invalid geohash '\(norm)' (expected 8 valid base32 chars)", category: .session)
+            return
+        }
+        // Unsubscribe previous without clearing count to avoid flicker
+        if let sub = subscriptionID { dependencies.unsubscribe(sub) }
+        subscriptionID = nil
+        geohash = norm
+        noteIDs.removeAll()
+        initialLoadComplete = false
+        relayAvailable = true
+
+        // Subscribe only to the building geohash (precision 8)
+        let subID = "locnotes-count-\(norm)-\(UUID().uuidString.prefix(6))"
+        let relays = dependencies.relayLookup(norm, TransportConfig.nostrGeoRelayCount)
+        guard !relays.isEmpty else {
+            relayAvailable = false
+            initialLoadComplete = true
+            count = 0
+            SecureLogger.warning("LocationNotesCounter: no geo relays for geohash=\(norm)", category: .session)
+            return
+        }
+
+        subscriptionID = subID
+        let filter = NostrFilter.geohashNotes(norm, since: nil, limit: 200)
+        dependencies.subscribe(filter, subID, relays, { [weak self] event in
+            guard let self = self else { return }
+            guard event.kind == NostrProtocol.EventKind.textNote.rawValue else { return }
+            guard event.tags.contains(where: { $0.count >= 2 && $0[0].lowercased() == "g" && $0[1].lowercased() == norm }) else { return }
+            if !self.noteIDs.contains(event.id) {
+                self.noteIDs.insert(event.id)
+                self.count = self.noteIDs.count
+            }
+        }, { [weak self] in
+            self?.initialLoadComplete = true
+        })
+    }
+
+    func cancel() {
+        if let sub = subscriptionID { dependencies.unsubscribe(sub) }
+        subscriptionID = nil
+        geohash = nil
+        count = 0
+        noteIDs.removeAll()
+        relayAvailable = true
+    }
+}

bitchat/Services/LocationNotesManager.swift

@@ -163,22 +163,14 @@ final class LocationNotesManager: ObservableObject {
 
         subscriptionID = subID
         initialLoadComplete = false
-
-        // Subscribe to center + 8 neighbors (± 1 grid)
-        let neighbors = Geohash.neighbors(of: geohash)
-        let allGeohashes = [geohash] + neighbors
-        let filter = NostrFilter.geohashNotes(allGeohashes, since: nil, limit: 200)
-
-        // Build a set of valid geohashes for tag matching (includes all 9 cells)
-        let validGeohashes = Set(allGeohashes.map { $0.lowercased() })
+        // For persistent notes, allow relays to return recent history without an aggressive time cutoff
+        let filter = NostrFilter.geohashNotes(geohash, since: nil, limit: 200)
 
         dependencies.subscribe(filter, subID, relays, { [weak self] event in
             guard let self = self else { return }
             guard event.kind == NostrProtocol.EventKind.textNote.rawValue else { return }
-            // Ensure matching tag - accept any of our 9 geohashes
-            guard event.tags.contains(where: { tag in
-                tag.count >= 2 && tag[0].lowercased() == "g" && validGeohashes.contains(tag[1].lowercased())
-            }) else { return }
+            // Ensure matching tag
+            guard event.tags.contains(where: { $0.count >= 2 && $0[0].lowercased() == "g" && $0[1].lowercased() == self.geohash }) else { return }
             guard !self.noteIDs.contains(event.id) else { return }
             self.noteIDs.insert(event.id)
             let nick = event.tags.first(where: { $0.first?.lowercased() == "n" && $0.count >= 2 })?.dropFirst().first

bitchat/Services/MeshTopologyTracker.swift

@@ -1,120 +0,0 @@
-import Foundation
-
-/// Tracks observed mesh topology and computes hop-by-hop routes.
-final class MeshTopologyTracker {
-    private typealias RoutingID = Data
-
-    private let queue = DispatchQueue(label: "mesh.topology", attributes: .concurrent)
-    private let hopSize = 8
-    private var adjacency: [RoutingID: Set<RoutingID>] = [:]
-
-    func reset() {
-        queue.sync(flags: .barrier) {
-            self.adjacency.removeAll()
-        }
-    }
-
-    func recordDirectLink(between a: Data?, and b: Data?) {
-        guard let left = sanitize(a), let right = sanitize(b), left != right else { return }
-        queue.sync(flags: .barrier) {
-            var setA = self.adjacency[left] ?? []
-            setA.insert(right)
-            self.adjacency[left] = setA
-
-            var setB = self.adjacency[right] ?? []
-            setB.insert(left)
-            self.adjacency[right] = setB
-        }
-    }
-
-    func removeDirectLink(between a: Data?, and b: Data?) {
-        guard let left = sanitize(a), let right = sanitize(b), left != right else { return }
-        queue.sync(flags: .barrier) {
-            if var setA = self.adjacency[left] {
-                setA.remove(right)
-                self.adjacency[left] = setA.isEmpty ? nil : setA
-            }
-            if var setB = self.adjacency[right] {
-                setB.remove(left)
-                self.adjacency[right] = setB.isEmpty ? nil : setB
-            }
-        }
-    }
-
-    func removePeer(_ data: Data?) {
-        guard let peer = sanitize(data) else { return }
-        queue.sync(flags: .barrier) {
-            guard let neighbors = self.adjacency.removeValue(forKey: peer) else { return }
-            for neighbor in neighbors {
-                if var set = self.adjacency[neighbor] {
-                    set.remove(peer)
-                    self.adjacency[neighbor] = set.isEmpty ? nil : set
-                }
-            }
-        }
-    }
-
-    func recordRoute(_ hops: [Data]) {
-        let sanitized = hops.compactMap { sanitize($0) }
-        guard sanitized.count >= 2 else { return }
-        queue.sync(flags: .barrier) {
-            for idx in 0..<(sanitized.count - 1) {
-                let left = sanitized[idx]
-                let right = sanitized[idx + 1]
-                guard left != right else { continue }
-
-                var setA = self.adjacency[left] ?? []
-                setA.insert(right)
-                self.adjacency[left] = setA
-
-                var setB = self.adjacency[right] ?? []
-                setB.insert(left)
-                self.adjacency[right] = setB
-            }
-        }
-    }
-
-    func computeRoute(from start: Data?, to goal: Data?, maxHops: Int = 255) -> [Data]? {
-        guard let source = sanitize(start), let target = sanitize(goal) else { return nil }
-        if source == target { return [source] }
-
-        let graph = queue.sync { adjacency }
-        guard graph[source] != nil, graph[target] != nil else { return nil }
-
-        var visited: Set<RoutingID> = [source]
-        var queuePaths: [[RoutingID]] = [[source]]
-        var index = 0
-
-        while index < queuePaths.count {
-            let path = queuePaths[index]
-            index += 1
-            guard path.count <= maxHops else { continue }
-            guard let last = path.last, let neighbors = graph[last] else { continue }
-
-            for neighbor in neighbors {
-                if visited.contains(neighbor) { continue }
-                var nextPath = path
-                nextPath.append(neighbor)
-                if neighbor == target { return nextPath }
-                if nextPath.count <= maxHops {
-                    queuePaths.append(nextPath)
-                }
-                visited.insert(neighbor)
-            }
-        }
-
-        return nil
-    }
-
-    // MARK: - Helpers
-
-    private func sanitize(_ data: Data?) -> Data? {
-        guard var value = data, !value.isEmpty else { return nil }
-        if value.count > hopSize {
-            value = Data(value.prefix(hopSize))
-        } else if value.count < hopSize {
-            value.append(Data(repeating: 0, count: hopSize - value.count))
-        }
-        return value
-    }
-}

bitchat/Services/NoiseEncryptionService.swift

@@ -177,18 +177,18 @@ final class NoiseEncryptionService {
     private let rekeyCheckInterval: TimeInterval = 60.0 // Check every minute
     
     // Callbacks
-    private var onPeerAuthenticatedHandlers: [((PeerID, String) -> Void)] = [] // Array of handlers for peer authentication
+    private var onPeerAuthenticatedHandlers: [((String, String) -> Void)] = [] // Array of handlers for peer authentication
     var onHandshakeRequired: ((PeerID) -> Void)? // peerID needs handshake
     
     // Add a handler for peer authentication
-    func addOnPeerAuthenticatedHandler(_ handler: @escaping (PeerID, String) -> Void) {
+    func addOnPeerAuthenticatedHandler(_ handler: @escaping (String, String) -> Void) {
         serviceQueue.async(flags: .barrier) { [weak self] in
             self?.onPeerAuthenticatedHandlers.append(handler)
         }
     }
     
     // Legacy support - setting this will add to the handlers array
-    var onPeerAuthenticated: ((PeerID, String) -> Void)? {
+    var onPeerAuthenticated: ((String, String) -> Void)? {
         get { nil } // Always return nil for backward compatibility
         set {
             if let handler = newValue {
@@ -546,7 +546,7 @@ final class NoiseEncryptionService {
         // Notify all handlers about authentication
         serviceQueue.async { [weak self] in
             self?.onPeerAuthenticatedHandlers.forEach { handler in
-                handler(peerID, fingerprint)
+                handler(peerID.id, fingerprint)
             }
         }
     }

bitchat/Services/NostrTransport.swift

@@ -82,7 +82,7 @@ final class NostrTransport: Transport {
                 SecureLogger.error("NostrTransport: failed to decode npub -> hex: \(error)", category: .session)
                 return
             }
-            guard let embedded = NostrEmbeddedBitChat.encodePMForNostr(content: content, messageID: messageID, recipientPeerID: peerID, senderPeerID: senderPeerID) else {
+            guard let embedded = NostrEmbeddedBitChat.encodePMForNostr(content: content, messageID: messageID, recipientPeerID: peerID.id, senderPeerID: senderPeerID.id) else {
                 SecureLogger.error("NostrTransport: failed to embed PM packet", category: .session)
                 return
             }
@@ -114,7 +114,7 @@ final class NostrTransport: Transport {
                 guard hrp == "npub" else { return }
                 recipientHex = data.hexEncodedString()
             } catch { return }
-            guard let embedded = NostrEmbeddedBitChat.encodePMForNostr(content: content, messageID: UUID().uuidString, recipientPeerID: peerID, senderPeerID: senderPeerID) else {
+            guard let embedded = NostrEmbeddedBitChat.encodePMForNostr(content: content, messageID: UUID().uuidString, recipientPeerID: peerID.id, senderPeerID: senderPeerID.id) else {
                 SecureLogger.error("NostrTransport: failed to embed favorite notification", category: .session)
                 return
             }
@@ -139,7 +139,7 @@ final class NostrTransport: Transport {
                 guard hrp == "npub" else { return }
                 recipientHex = data.hexEncodedString()
             } catch { return }
-            guard let ack = NostrEmbeddedBitChat.encodeAckForNostr(type: .delivered, messageID: messageID, recipientPeerID: peerID, senderPeerID: senderPeerID) else {
+            guard let ack = NostrEmbeddedBitChat.encodeAckForNostr(type: .delivered, messageID: messageID, recipientPeerID: peerID.id, senderPeerID: senderPeerID.id) else {
                 SecureLogger.error("NostrTransport: failed to embed DELIVERED ack", category: .session)
                 return
             }
@@ -161,7 +161,7 @@ extension NostrTransport {
     func sendDeliveryAckGeohash(for messageID: String, toRecipientHex recipientHex: String, from identity: NostrIdentity) {
         Task { @MainActor in
             SecureLogger.debug("GeoDM: send DELIVERED -> recip=\(recipientHex.prefix(8))… mid=\(messageID.prefix(8))… from=\(identity.publicKeyHex.prefix(8))…", category: .session)
-            guard let embedded = NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(type: .delivered, messageID: messageID, senderPeerID: senderPeerID) else { return }
+            guard let embedded = NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(type: .delivered, messageID: messageID, senderPeerID: senderPeerID.id) else { return }
             guard let event = try? NostrProtocol.createPrivateMessage(content: embedded, recipientPubkey: recipientHex, senderIdentity: identity) else { return }
             NostrRelayManager.registerPendingGiftWrap(id: event.id)
             NostrRelayManager.shared.sendEvent(event)
@@ -171,7 +171,7 @@ extension NostrTransport {
     func sendReadReceiptGeohash(_ messageID: String, toRecipientHex recipientHex: String, from identity: NostrIdentity) {
         Task { @MainActor in
             SecureLogger.debug("GeoDM: send READ -> recip=\(recipientHex.prefix(8))… mid=\(messageID.prefix(8))… from=\(identity.publicKeyHex.prefix(8))…", category: .session)
-            guard let embedded = NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(type: .readReceipt, messageID: messageID, senderPeerID: senderPeerID) else { return }
+            guard let embedded = NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(type: .readReceipt, messageID: messageID, senderPeerID: senderPeerID.id) else { return }
             guard let event = try? NostrProtocol.createPrivateMessage(content: embedded, recipientPubkey: recipientHex, senderIdentity: identity) else { return }
             NostrRelayManager.registerPendingGiftWrap(id: event.id)
             NostrRelayManager.shared.sendEvent(event)
@@ -184,7 +184,7 @@ extension NostrTransport {
             guard !recipientHex.isEmpty else { return }
             SecureLogger.debug("GeoDM: send PM -> recip=\(recipientHex.prefix(8))… mid=\(messageID.prefix(8))… from=\(identity.publicKeyHex.prefix(8))…", category: .session)
             // Build embedded BitChat packet without recipient peer ID
-            guard let embedded = NostrEmbeddedBitChat.encodePMForNostrNoRecipient(content: content, messageID: messageID, senderPeerID: senderPeerID) else {
+            guard let embedded = NostrEmbeddedBitChat.encodePMForNostrNoRecipient(content: content, messageID: messageID, senderPeerID: senderPeerID.id) else {
                 SecureLogger.error("NostrTransport: failed to embed geohash PM packet", category: .session)
                 return
             }
@@ -223,7 +223,7 @@ extension NostrTransport {
                 guard hrp == "npub" else { scheduleNextReadAck(); return }
                 recipientHex = data.hexEncodedString()
             } catch { scheduleNextReadAck(); return }
-            guard let ack = NostrEmbeddedBitChat.encodeAckForNostr(type: .readReceipt, messageID: item.receipt.originalMessageID, recipientPeerID: item.peerID, senderPeerID: senderPeerID) else {
+            guard let ack = NostrEmbeddedBitChat.encodeAckForNostr(type: .readReceipt, messageID: item.receipt.originalMessageID, recipientPeerID: item.peerID.id, senderPeerID: senderPeerID.id) else {
                 SecureLogger.error("NostrTransport: failed to embed READ ack", category: .session)
                 scheduleNextReadAck(); return
             }

bitchat/Services/NotificationService.swift

@@ -29,30 +29,28 @@ final class NotificationService {
         }
     }
     
-    func sendLocalNotification(
-        title: String,
-        body: String,
-        identifier: String,
-        userInfo: [String: Any]? = nil,
-        interruptionLevel: UNNotificationInterruptionLevel = .active
-    ) {
-        let content = UNMutableNotificationContent()
-        content.title = title
-        content.body = body
-        content.sound = .default
-        content.interruptionLevel = interruptionLevel
-
-        if let userInfo = userInfo {
-            content.userInfo = userInfo
+    func sendLocalNotification(title: String, body: String, identifier: String, userInfo: [String: Any]? = nil) {
+        // For now, skip app state check entirely to avoid thread issues
+        // The NotificationDelegate will handle foreground presentation
+        DispatchQueue.main.async {
+            let content = UNMutableNotificationContent()
+            content.title = title
+            content.body = body
+            content.sound = .default
+            if let userInfo = userInfo {
+                content.userInfo = userInfo
+            }
+            
+            let request = UNNotificationRequest(
+                identifier: identifier,
+                content: content,
+                trigger: nil // Deliver immediately
+            )
+            
+            UNUserNotificationCenter.current().add(request) { _ in
+                // Notification added
+            }
         }
-
-        let request = UNNotificationRequest(
-            identifier: identifier,
-            content: content,
-            trigger: nil // Deliver immediately
-        )
-
-        UNUserNotificationCenter.current().add(request)
     }
     
     func sendMentionNotification(from sender: String, message: String) {
@@ -63,11 +61,11 @@ final class NotificationService {
         sendLocalNotification(title: title, body: body, identifier: identifier)
     }
     
-    func sendPrivateMessageNotification(from sender: String, message: String, peerID: PeerID) {
+    func sendPrivateMessageNotification(from sender: String, message: String, peerID: String) {
         let title = "🔒 DM from \(sender)"
         let body = message
         let identifier = "private-\(UUID().uuidString)"
-        let userInfo = ["peerID": peerID.id, "senderName": sender]
+        let userInfo = ["peerID": peerID, "senderName": sender]
         
         sendLocalNotification(title: title, body: body, identifier: identifier, userInfo: userInfo)
     }
@@ -85,12 +83,25 @@ final class NotificationService {
         let title = "👥 bitchatters nearby!"
         let body = peerCount == 1 ? "1 person around" : "\(peerCount) people around"
         let identifier = "network-available-\(Date().timeIntervalSince1970)"
-
-        sendLocalNotification(
-            title: title,
-            body: body,
-            identifier: identifier,
-            interruptionLevel: .timeSensitive
-        )
+        
+        // For network notifications, we want to show them even in foreground
+        // No app state check - let the notification delegate handle presentation
+        DispatchQueue.main.async {
+            let content = UNMutableNotificationContent()
+            content.title = title
+            content.body = body
+            content.sound = .default
+            content.interruptionLevel = .timeSensitive  // Make it more prominent
+            
+            let request = UNNotificationRequest(
+                identifier: identifier,
+                content: content,
+                trigger: nil // Deliver immediately
+            )
+            
+            UNUserNotificationCenter.current().add(request) { _ in
+                // Notification added
+            }
+        }
     }
 }

bitchat/Services/NotificationStreamAssembler.swift

@@ -6,19 +6,10 @@
 // For more information, see <https://unlicense.org>
 //
 
-import BitLogger
 import Foundation
 
 struct NotificationStreamAssembler {
     private var buffer = Data()
-    private var pendingFrameStartedAt: DispatchTime?
-    private var pendingFrameExpectedLength: Int = 0
-
-    private mutating func resetState() {
-        buffer.removeAll(keepingCapacity: false)
-        pendingFrameStartedAt = nil
-        pendingFrameExpectedLength = 0
-    }
 
     mutating func append(_ chunk: Data) -> (frames: [Data], droppedPrefixes: [UInt8], reset: Bool) {
         guard !chunk.isEmpty else { return ([], [], false) }
@@ -27,107 +18,64 @@ struct NotificationStreamAssembler {
 
         var frames: [Data] = []
         var dropped: [UInt8] = []
-        var didReset = false
-        let now = DispatchTime.now()
-        let maxFrameLength = TransportConfig.bleNotificationAssemblerHardCapBytes
-        let minimumFramePrefix = BinaryProtocol.v1HeaderSize + BinaryProtocol.senderIDSize
+        var reset = false
+        let maxFrameLength = TransportConfig.blePendingWriteBufferCapBytes
 
-        if buffer.count > TransportConfig.bleNotificationAssemblerHardCapBytes {
-            SecureLogger.error("❌ Notification assembler overflow (\(buffer.count) bytes); dropping partial frame", category: .session)
-            resetState()
-            return ([], [], true)
-        }
+        let minHeaderBytes = 14 // version + type + ttl + timestamp(8) + flags + length(2)
+        let minFramePrefix = minHeaderBytes + BinaryProtocol.senderIDSize
 
-        while buffer.count >= minimumFramePrefix {
-            guard let version = buffer.first else { break }
-            guard version == 1 || version == 2 else {
+        while buffer.count >= minFramePrefix {
+            guard let first = buffer.first else { break }
+            if first != 1 {
                 dropped.append(buffer.removeFirst())
-                pendingFrameStartedAt = nil
-                pendingFrameExpectedLength = 0
                 continue
             }
 
-            guard let headerSize = BinaryProtocol.headerSize(for: version) else {
-                dropped.append(buffer.removeFirst())
-                pendingFrameStartedAt = nil
-                pendingFrameExpectedLength = 0
-                continue
-            }
-            let framePrefix = headerSize + BinaryProtocol.senderIDSize
-            guard buffer.count >= framePrefix else { break }
+            guard buffer.count >= minHeaderBytes else { break }
 
-            let flagsIndex = buffer.startIndex + BinaryProtocol.Offsets.flags
-            guard flagsIndex < buffer.endIndex else { break }
-            let flags = buffer[flagsIndex]
+            let headerBytes = Array(buffer.prefix(minFramePrefix))
+            guard headerBytes.count == minFramePrefix else { break }
+
+            let flags = headerBytes[11]
             let hasRecipient = (flags & BinaryProtocol.Flags.hasRecipient) != 0
             let hasSignature = (flags & BinaryProtocol.Flags.hasSignature) != 0
-            let isCompressed = (flags & BinaryProtocol.Flags.isCompressed) != 0
+            let payloadLen = (Int(headerBytes[12]) << 8) | Int(headerBytes[13])
 
-            let lengthOffset = 12
-            let payloadLength: Int
-            if version == 2 {
-                let lengthIndex = buffer.startIndex + lengthOffset
-                payloadLength =
-                    (Int(buffer[lengthIndex]) << 24) |
-                    (Int(buffer[lengthIndex + 1]) << 16) |
-                    (Int(buffer[lengthIndex + 2]) << 8) |
-                    Int(buffer[lengthIndex + 3])
-            } else {
-                let lengthIndex = buffer.startIndex + lengthOffset
-                payloadLength = (Int(buffer[lengthIndex]) << 8) | Int(buffer[lengthIndex + 1])
-            }
-
-            var frameLength = framePrefix + payloadLength
+            var frameLength = minFramePrefix + payloadLen
             if hasRecipient { frameLength += BinaryProtocol.recipientIDSize }
             if hasSignature { frameLength += BinaryProtocol.signatureSize }
-            if isCompressed {
-                let rawLengthFieldBytes = (version == 2) ? 4 : 2
-                if payloadLength < rawLengthFieldBytes {
-                    SecureLogger.error("❌ Invalid compressed payload length (\(payloadLength))", category: .session)
-                    resetState()
-                    didReset = true
-                    break
-                }
-            }
 
             guard frameLength > 0, frameLength <= maxFrameLength else {
-                SecureLogger.error("❌ Notification frame length \(frameLength) invalid (cap=\(maxFrameLength)); resetting stream", category: .session)
-                resetState()
-                didReset = true
+                buffer.removeAll()
+                reset = true
                 break
             }
 
             if buffer.count < frameLength {
-                let remaining = frameLength - buffer.count
-                if pendingFrameStartedAt == nil || frameLength != pendingFrameExpectedLength {
-                    pendingFrameStartedAt = now
-                    pendingFrameExpectedLength = frameLength
-                } else if let started = pendingFrameStartedAt {
-                    let elapsed = now.uptimeNanoseconds - started.uptimeNanoseconds
-                    let threshold = UInt64(TransportConfig.bleAssemblerStallResetMs) * 1_000_000
-                    if elapsed >= threshold {
-                        SecureLogger.debug("📉 Resetting notification assembler after waiting \(remaining)B for \(TransportConfig.bleAssemblerStallResetMs)ms", category: .session)
-                        resetState()
-                        didReset = true
-                    } else {
-                        SecureLogger.debug("⌛ Waiting for remaining \(remaining)B to complete BLE frame", category: .session)
+                // Check if a new frame start exists within the incomplete buffer; if so, drop leading partial bytes.
+                if let nextStart = buffer.dropFirst().firstIndex(of: 1) {
+                    let dropCount = buffer.distance(from: buffer.startIndex, to: nextStart)
+                    if dropCount > 0 {
+                        buffer.removeFirst(dropCount)
+                        dropped.append(1) // treat as dropped partial start
                     }
                 }
                 break
             }
 
-            pendingFrameStartedAt = nil
-            pendingFrameExpectedLength = 0
-
             let frame = Data(buffer.prefix(frameLength))
             frames.append(frame)
             buffer.removeFirst(frameLength)
         }
 
         if !buffer.isEmpty, buffer.allSatisfy({ $0 == 0 }) {
-            resetState()
+            buffer.removeAll(keepingCapacity: false)
         }
 
-        return (frames, dropped, didReset)
+        return (frames, dropped, reset)
+    }
+
+    mutating func reset() {
+        buffer.removeAll(keepingCapacity: false)
     }
 }

bitchat/Services/PrivateChatManager.swift

@@ -105,7 +105,7 @@ final class PrivateChatManager: ObservableObject {
         // Create read receipt using the simplified method
         let receipt = ReadReceipt(
             originalMessageID: message.id,
-            readerID: meshService?.myPeerID ?? PeerID(str: ""),
+            readerID: meshService?.myPeerID.id ?? "",
             readerNickname: meshService?.myNickname ?? ""
         )
         

bitchat/Services/RelayController.swift

@@ -13,7 +13,6 @@ struct RelayController {
                        senderIsSelf: Bool,
                        isEncrypted: Bool,
                        isDirectedEncrypted: Bool,
-                       isFragment: Bool,
                        isDirectedFragment: Bool,
                        isHandshake: Bool,
                        isAnnounce: Bool,
@@ -37,16 +36,6 @@ struct RelayController {
             return RelayDecision(shouldRelay: true, newTTL: newTTL, delayMs: delayMs)
         }
 
-        if isFragment {
-            let ttlLimit = min(ttlCap, TransportConfig.bleFragmentRelayTtlCap)
-            guard ttlLimit > 1 else {
-                return RelayDecision(shouldRelay: false, newTTL: ttlLimit, delayMs: 0)
-            }
-            let newTTL = ttlLimit &- 1
-            let delayMs = Int.random(in: TransportConfig.bleFragmentRelayMinDelayMs...TransportConfig.bleFragmentRelayMaxDelayMs)
-            return RelayDecision(shouldRelay: true, newTTL: newTTL, delayMs: delayMs)
-        }
-
         // TTL clamping for broadcast
         // - Dense graphs: keep lower but still allow multi-hop bridging
         // - Announces get a bit more headroom

bitchat/Services/TransferProgressManager.swift

@@ -1,65 +0,0 @@
-import Foundation
-import Combine
-
-/// Centralized progress bus for Bluetooth file transfers.
-/// Emits Combine events consumed by ChatViewModel to update UI progress indicators.
-final class TransferProgressManager {
-    static let shared = TransferProgressManager()
-
-    enum Event {
-        case started(id: String, totalFragments: Int)
-        case updated(id: String, sentFragments: Int, totalFragments: Int)
-        case completed(id: String, totalFragments: Int)
-        case cancelled(id: String, sentFragments: Int, totalFragments: Int)
-    }
-
-    private let subject = PassthroughSubject<Event, Never>()
-    private let queue = DispatchQueue(label: "com.bitchat.transfer-progress", attributes: .concurrent)
-    private var states: [String: (sent: Int, total: Int)] = [:]
-
-    var publisher: AnyPublisher<Event, Never> {
-        subject.eraseToAnyPublisher()
-    }
-
-    func start(id: String, totalFragments: Int) {
-        queue.async(flags: .barrier) { [weak self] in
-            guard let self = self else { return }
-            self.states[id] = (sent: 0, total: totalFragments)
-            self.subject.send(.started(id: id, totalFragments: totalFragments))
-        }
-    }
-
-    func recordFragmentSent(id: String) {
-        queue.async(flags: .barrier) { [weak self] in
-            guard let self = self, var state = self.states[id] else { return }
-            state.sent = min(state.sent + 1, state.total)
-            self.states[id] = state
-            self.subject.send(.updated(id: id, sentFragments: state.sent, totalFragments: state.total))
-            if state.sent >= state.total {
-                self.states.removeValue(forKey: id)
-                self.subject.send(.completed(id: id, totalFragments: state.total))
-            }
-        }
-    }
-
-    func cancel(id: String) {
-        queue.async(flags: .barrier) { [weak self] in
-            guard let self = self, let state = self.states.removeValue(forKey: id) else { return }
-            self.subject.send(.cancelled(id: id, sentFragments: state.sent, totalFragments: state.total))
-        }
-    }
-
-    func reset(id: String) {
-        queue.async(flags: .barrier) { [weak self] in
-            self?.states.removeValue(forKey: id)
-        }
-    }
-
-    func snapshot(id: String) -> (sent: Int, total: Int)? {
-        var result: (sent: Int, total: Int)?
-        queue.sync {
-            result = states[id]
-        }
-        return result
-    }
-}

bitchat/Services/Transport.swift

@@ -45,15 +45,11 @@ protocol Transport: AnyObject {
 
     // Messaging
     func sendMessage(_ content: String, mentions: [String])
-    func sendMessage(_ content: String, mentions: [String], messageID: String, timestamp: Date)
     func sendPrivateMessage(_ content: String, to peerID: PeerID, recipientNickname: String, messageID: String)
     func sendReadReceipt(_ receipt: ReadReceipt, to peerID: PeerID)
     func sendFavoriteNotification(to peerID: PeerID, isFavorite: Bool)
     func sendBroadcastAnnounce()
     func sendDeliveryAck(for messageID: String, to peerID: PeerID)
-    func sendFileBroadcast(_ packet: BitchatFilePacket, transferId: String)
-    func sendFilePrivate(_ packet: BitchatFilePacket, to peerID: PeerID, transferId: String)
-    func cancelTransfer(_ transferId: String)
 
     // QR verification (optional for transports)
     func sendVerifyChallenge(to peerID: PeerID, noiseKeyHex: String, nonceA: Data)
@@ -63,13 +59,6 @@ protocol Transport: AnyObject {
 extension Transport {
     func sendVerifyChallenge(to peerID: PeerID, noiseKeyHex: String, nonceA: Data) {}
     func sendVerifyResponse(to peerID: PeerID, noiseKeyHex: String, nonceA: Data) {}
-    func sendFileBroadcast(_ packet: BitchatFilePacket, transferId: String) {}
-    func sendFilePrivate(_ packet: BitchatFilePacket, to peerID: PeerID, transferId: String) {}
-    func cancelTransfer(_ transferId: String) {}
-
-    func sendMessage(_ content: String, mentions: [String], messageID: String, timestamp: Date) {
-        sendMessage(content, mentions: mentions)
-    }
 }
 
 protocol TransportPeerEventsDelegate: AnyObject {

bitchat/Services/TransportConfig.swift

@@ -8,10 +8,6 @@ enum TransportConfig {
     static let messageTTLDefault: UInt8 = 7                 // Default TTL for mesh flooding
     static let bleMaxInFlightAssemblies: Int = 128          // Cap concurrent fragment assemblies
     static let bleHighDegreeThreshold: Int = 6              // For adaptive TTL/probabilistic relays
-    static let bleMaxConcurrentTransfers: Int = 2           // Limit simultaneous large media sends
-    static let bleFragmentRelayMinDelayMs: Int = 8          // Faster forwarding for media fragments
-    static let bleFragmentRelayMaxDelayMs: Int = 25         // Upper jitter bound for fragment relays
-    static let bleFragmentRelayTtlCap: UInt8 = 5            // Clamp fragment TTL to contain floods
 
     // UI / Storage Caps
     static let privateChatCap: Int = 1337
@@ -34,11 +30,7 @@ enum TransportConfig {
     static let bleDynamicRSSIThresholdDefault: Int = -90
     static let bleConnectionCandidatesMax: Int = 100
     static let blePendingWriteBufferCapBytes: Int = 1_000_000
-    static let bleNotificationAssemblerHardCapBytes: Int = 8 * 1024 * 1024
-    static let bleAssemblerStallResetMs: Int = 250
-    static let blePendingNotificationsCapCount: Int = 128
-    static let bleNotificationRetryDelayMs: Int = 25
-    static let bleNotificationRetryMaxAttempts: Int = 80
+    static let blePendingNotificationsCapCount: Int = 20
 
     // Nostr
     static let nostrReadAckInterval: TimeInterval = 0.35 // ~3 per second
@@ -70,7 +62,6 @@ enum TransportConfig {
     static let uiAnimationMediumSeconds: TimeInterval = 0.2
     static let uiAnimationSidebarSeconds: TimeInterval = 0.25
     static let uiRecentCutoffFiveMinutesSeconds: TimeInterval = 5 * 60
-    static let uiMeshEmptyConfirmationSeconds: TimeInterval = 30.0
 
     // BLE maintenance & thresholds
     static let bleMaintenanceInterval: TimeInterval = 5.0
@@ -150,9 +141,6 @@ enum TransportConfig {
 
     // Geo relay directory
     static let geoRelayFetchIntervalSeconds: TimeInterval = 60 * 60 * 24
-    static let geoRelayRefreshCheckIntervalSeconds: TimeInterval = 60 * 60
-    static let geoRelayRetryInitialSeconds: TimeInterval = 60
-    static let geoRelayRetryMaxSeconds: TimeInterval = 60 * 60
 
     // BLE operational delays
     static let bleInitialAnnounceDelaySeconds: TimeInterval = 0.6

bitchat/Sync/GossipSyncManager.swift

@@ -8,55 +8,6 @@ final class GossipSyncManager {
         func signPacketForBroadcast(_ packet: BitchatPacket) -> BitchatPacket
     }
 
-    private struct PacketStore {
-        private(set) var packets: [String: BitchatPacket] = [:]
-        private(set) var order: [String] = []
-
-        mutating func insert(idHex: String, packet: BitchatPacket, capacity: Int) {
-            guard capacity > 0 else { return }
-            if packets[idHex] != nil {
-                packets[idHex] = packet
-                return
-            }
-            packets[idHex] = packet
-            order.append(idHex)
-            while order.count > capacity {
-                let victim = order.removeFirst()
-                packets.removeValue(forKey: victim)
-            }
-        }
-
-        func allPackets(isFresh: (BitchatPacket) -> Bool) -> [BitchatPacket] {
-            order.compactMap { key in
-                guard let packet = packets[key], isFresh(packet) else { return nil }
-                return packet
-            }
-        }
-
-        mutating func remove(where shouldRemove: (BitchatPacket) -> Bool) {
-            var nextOrder: [String] = []
-            for key in order {
-                guard let packet = packets[key] else { continue }
-                if shouldRemove(packet) {
-                    packets.removeValue(forKey: key)
-                } else {
-                    nextOrder.append(key)
-                }
-            }
-            order = nextOrder
-        }
-
-        mutating func removeExpired(isFresh: (BitchatPacket) -> Bool) {
-            remove { !isFresh($0) }
-        }
-    }
-
-    private struct SyncSchedule {
-        let types: SyncTypeFlags
-        let interval: TimeInterval
-        var lastSent: Date
-    }
-
     struct Config {
         var seenCapacity: Int = 1000          // max packets per sync (cap across types)
         var gcsMaxBytes: Int = 400           // filter size budget (128..1024)
@@ -65,43 +16,25 @@ final class GossipSyncManager {
         var maintenanceIntervalSeconds: TimeInterval = 30.0
         var stalePeerCleanupIntervalSeconds: TimeInterval = 60.0
         var stalePeerTimeoutSeconds: TimeInterval = 60.0
-        var fragmentCapacity: Int = 600
-        var fileTransferCapacity: Int = 200
-        var fragmentSyncIntervalSeconds: TimeInterval = 30.0
-        var fileTransferSyncIntervalSeconds: TimeInterval = 60.0
-        var messageSyncIntervalSeconds: TimeInterval = 15.0
     }
 
     private let myPeerID: PeerID
     private let config: Config
     weak var delegate: Delegate?
 
-    // Storage: broadcast packets by type, and latest announce per sender
-    private var messages = PacketStore()
-    private var fragments = PacketStore()
-    private var fileTransfers = PacketStore()
-    private var latestAnnouncementByPeer: [PeerID: (id: String, packet: BitchatPacket)] = [:]
+    // Storage: broadcast messages (ordered by insert), and latest announce per sender
+    private var messages: [String: BitchatPacket] = [:] // idHex -> packet
+    private var messageOrder: [String] = []
+    private var latestAnnouncementByPeer: [String: (id: String, packet: BitchatPacket)] = [:]
 
     // Timer
     private var periodicTimer: DispatchSourceTimer?
     private let queue = DispatchQueue(label: "mesh.sync", qos: .utility)
     private var lastStalePeerCleanup: Date = .distantPast
-    private var syncSchedules: [SyncSchedule] = []
 
     init(myPeerID: PeerID, config: Config = Config()) {
         self.myPeerID = myPeerID
         self.config = config
-        var schedules: [SyncSchedule] = []
-        if config.seenCapacity > 0 && config.messageSyncIntervalSeconds > 0 {
-            schedules.append(SyncSchedule(types: .publicMessages, interval: config.messageSyncIntervalSeconds, lastSent: .distantPast))
-        }
-        if config.fragmentCapacity > 0 && config.fragmentSyncIntervalSeconds > 0 {
-            schedules.append(SyncSchedule(types: .fragment, interval: config.fragmentSyncIntervalSeconds, lastSent: .distantPast))
-        }
-        if config.fileTransferCapacity > 0 && config.fileTransferSyncIntervalSeconds > 0 {
-            schedules.append(SyncSchedule(types: .fileTransfer, interval: config.fileTransferSyncIntervalSeconds, lastSent: .distantPast))
-        }
-        syncSchedules = schedules
     }
 
     func start() {
@@ -122,18 +55,7 @@ final class GossipSyncManager {
 
     func scheduleInitialSyncToPeer(_ peerID: PeerID, delaySeconds: TimeInterval = 5.0) {
         queue.asyncAfter(deadline: .now() + delaySeconds) { [weak self] in
-            guard let self = self else { return }
-            self.sendRequestSync(to: peerID, types: .publicMessages)
-            if self.config.fragmentCapacity > 0 && self.config.fragmentSyncIntervalSeconds > 0 {
-                self.queue.asyncAfter(deadline: .now() + 0.5) { [weak self] in
-                    self?.sendRequestSync(to: peerID, types: .fragment)
-                }
-            }
-            if self.config.fileTransferCapacity > 0 && self.config.fileTransferSyncIntervalSeconds > 0 {
-                self.queue.asyncAfter(deadline: .now() + 1.0) { [weak self] in
-                    self?.sendRequestSync(to: peerID, types: .fileTransfer)
-                }
-            }
+            self?.sendRequestSync(to: peerID)
         }
     }
 
@@ -165,45 +87,47 @@ final class GossipSyncManager {
     }
 
     private func _onPublicPacketSeen(_ packet: BitchatPacket) {
-        guard let messageType = MessageType(rawValue: packet.type) else { return }
+        let mt = MessageType(rawValue: packet.type)
         let isBroadcastRecipient: Bool = {
             guard let r = packet.recipientID else { return true }
             return r.count == 8 && r.allSatisfy { $0 == 0xFF }
         }()
+        let isBroadcastMessage = (mt == .message && isBroadcastRecipient)
+        let isAnnounce = (mt == .announce)
+        guard isBroadcastMessage || isAnnounce else { return }
 
-        switch messageType {
-        case .announce:
-            guard isPacketFresh(packet) else { return }
+        // Reject expired packets to prevent ghost peers and old messages
+        guard isPacketFresh(packet) else { return }
+
+        if isAnnounce {
             guard isAnnouncementFresh(packet) else {
-                let sender = PeerID(hexData: packet.senderID)
-                removeState(for: sender)
+                let sender = packet.senderID.hexEncodedString().lowercased()
+                removeState(forNormalizedPeerID: sender)
                 return
             }
-            let idHex = PacketIdUtil.computeId(packet).hexEncodedString()
-            let sender = PeerID(hexData: packet.senderID)
+        }
+
+        let idHex = PacketIdUtil.computeId(packet).hexEncodedString()
+
+        if isBroadcastMessage {
+            if messages[idHex] == nil {
+                messages[idHex] = packet
+                messageOrder.append(idHex)
+                // Enforce capacity
+                let cap = max(1, config.seenCapacity)
+                while messageOrder.count > cap {
+                    let victim = messageOrder.removeFirst()
+                    messages.removeValue(forKey: victim)
+                }
+            }
+        } else if isAnnounce {
+            let sender = packet.senderID.hexEncodedString().lowercased()
             latestAnnouncementByPeer[sender] = (id: idHex, packet: packet)
-        case .message:
-            guard isBroadcastRecipient else { return }
-            guard isPacketFresh(packet) else { return }
-            let idHex = PacketIdUtil.computeId(packet).hexEncodedString()
-            messages.insert(idHex: idHex, packet: packet, capacity: max(1, config.seenCapacity))
-        case .fragment:
-            guard isBroadcastRecipient else { return }
-            guard isPacketFresh(packet) else { return }
-            let idHex = PacketIdUtil.computeId(packet).hexEncodedString()
-            fragments.insert(idHex: idHex, packet: packet, capacity: max(1, config.fragmentCapacity))
-        case .fileTransfer:
-            guard isBroadcastRecipient else { return }
-            guard isPacketFresh(packet) else { return }
-            let idHex = PacketIdUtil.computeId(packet).hexEncodedString()
-            fileTransfers.insert(idHex: idHex, packet: packet, capacity: max(1, config.fileTransferCapacity))
-        default:
-            break
         }
     }
 
-    private func sendRequestSync(for types: SyncTypeFlags) {
-        let payload = buildGcsPayload(for: types)
+    private func sendRequestSync() {
+        let payload = buildGcsPayload()
         let pkt = BitchatPacket(
             type: MessageType.requestSync.rawValue,
             senderID: Data(hexString: myPeerID.id) ?? Data(),
@@ -217,8 +141,8 @@ final class GossipSyncManager {
         delegate?.sendPacket(signed)
     }
 
-    private func sendRequestSync(to peerID: PeerID, types: SyncTypeFlags) {
-        let payload = buildGcsPayload(for: types)
+    private func sendRequestSync(to peerID: PeerID) {
+        let payload = buildGcsPayload()
         var recipient = Data()
         var temp = peerID.id
         while temp.count >= 2 && recipient.count < 8 {
@@ -246,7 +170,6 @@ final class GossipSyncManager {
     }
 
     private func _handleRequestSync(from peerID: PeerID, request: RequestSyncPacket) {
-        let requestedTypes = (request.types ?? .publicMessages)
         // Decode GCS into sorted set and prepare membership checker
         let sorted = GCSFilter.decodeToSortedSet(p: request.p, m: request.m, data: request.data)
         func mightContain(_ id: Data) -> Bool {
@@ -254,100 +177,60 @@ final class GossipSyncManager {
             return GCSFilter.contains(sortedValues: sorted, candidate: bucket)
         }
 
-        if requestedTypes.contains(.announce) {
-            for (_, pair) in latestAnnouncementByPeer {
-                let (idHex, pkt) = pair
-                guard isPacketFresh(pkt) else { continue }
-                let idBytes = Data(hexString: idHex) ?? Data()
-                if !mightContain(idBytes) {
-                    var toSend = pkt
-                    toSend.ttl = 0
-                    delegate?.sendPacket(to: peerID, packet: toSend)
-                }
+        // 1) Announcements: send latest per peer if requester lacks them (and not expired)
+        for (_, pair) in latestAnnouncementByPeer {
+            let (idHex, pkt) = pair
+            guard isPacketFresh(pkt) else { continue }
+            let idBytes = Data(hexString: idHex) ?? Data()
+            if !mightContain(idBytes) {
+                var toSend = pkt
+                toSend.ttl = 0
+                delegate?.sendPacket(to: peerID, packet: toSend)
             }
         }
 
-        if requestedTypes.contains(.message) {
-            let toSendMsgs = messages.allPackets(isFresh: isPacketFresh)
-            for pkt in toSendMsgs {
-                let idBytes = PacketIdUtil.computeId(pkt)
-                if !mightContain(idBytes) {
-                    var toSend = pkt
-                    toSend.ttl = 0
-                    delegate?.sendPacket(to: peerID, packet: toSend)
-                }
-            }
-        }
-
-        if requestedTypes.contains(.fragment) {
-            let frags = fragments.allPackets(isFresh: isPacketFresh)
-            for pkt in frags {
-                let idBytes = PacketIdUtil.computeId(pkt)
-                if !mightContain(idBytes) {
-                    var toSend = pkt
-                    toSend.ttl = 0
-                    delegate?.sendPacket(to: peerID, packet: toSend)
-                }
-            }
-        }
-
-        if requestedTypes.contains(.fileTransfer) {
-            let files = fileTransfers.allPackets(isFresh: isPacketFresh)
-            for pkt in files {
-                let idBytes = PacketIdUtil.computeId(pkt)
-                if !mightContain(idBytes) {
-                    var toSend = pkt
-                    toSend.ttl = 0
-                    delegate?.sendPacket(to: peerID, packet: toSend)
-                }
+        // 2) Broadcast messages: send all missing (and not expired)
+        let toSendMsgs = messageOrder.compactMap { messages[$0] }
+        for pkt in toSendMsgs {
+            guard isPacketFresh(pkt) else { continue }
+            let idBytes = PacketIdUtil.computeId(pkt)
+            if !mightContain(idBytes) {
+                var toSend = pkt
+                toSend.ttl = 0
+                delegate?.sendPacket(to: peerID, packet: toSend)
             }
         }
     }
 
     // Build REQUEST_SYNC payload using current candidates and GCS params
-    private func buildGcsPayload(for types: SyncTypeFlags) -> Data {
+    private func buildGcsPayload() -> Data {
+        // Collect candidates: latest announce per peer + broadcast messages (only fresh)
         var candidates: [BitchatPacket] = []
-        if types.contains(.announce) {
-            for (_, pair) in latestAnnouncementByPeer where isPacketFresh(pair.packet) {
+        candidates.reserveCapacity(latestAnnouncementByPeer.count + messageOrder.count)
+        for (_, pair) in latestAnnouncementByPeer {
+            if isPacketFresh(pair.packet) {
                 candidates.append(pair.packet)
             }
         }
-        if types.contains(.message) {
-            candidates.append(contentsOf: messages.allPackets(isFresh: isPacketFresh))
+        for id in messageOrder {
+            if let p = messages[id], isPacketFresh(p) {
+                candidates.append(p)
+            }
         }
-        if types.contains(.fragment) {
-            candidates.append(contentsOf: fragments.allPackets(isFresh: isPacketFresh))
-        }
-        if types.contains(.fileTransfer) {
-            candidates.append(contentsOf: fileTransfers.allPackets(isFresh: isPacketFresh))
-        }
-        if candidates.isEmpty {
-            let p = GCSFilter.deriveP(targetFpr: config.gcsTargetFpr)
-            let req = RequestSyncPacket(p: p, m: 1, data: Data(), types: types)
-            return req.encode()
-        }
-
         // Sort by timestamp desc
         candidates.sort { $0.timestamp > $1.timestamp }
 
         let p = GCSFilter.deriveP(targetFpr: config.gcsTargetFpr)
         let nMax = GCSFilter.estimateMaxElements(sizeBytes: config.gcsMaxBytes, p: p)
-        let cap: Int
-        if types == .fragment {
-            cap = max(1, config.fragmentCapacity)
-        } else if types == .fileTransfer {
-            cap = max(1, config.fileTransferCapacity)
-        } else {
-            cap = max(1, config.seenCapacity)
-        }
+        let cap = max(1, config.seenCapacity)
         let takeN = min(candidates.count, min(nMax, cap))
         if takeN <= 0 {
-            let req = RequestSyncPacket(p: p, m: 1, data: Data(), types: types)
+            let req = RequestSyncPacket(p: p, m: 1, data: Data())
             return req.encode()
         }
         let ids: [Data] = candidates.prefix(takeN).map { PacketIdUtil.computeId($0) }
         let params = GCSFilter.buildFilter(ids: ids, maxBytes: config.gcsMaxBytes, targetFpr: config.gcsTargetFpr)
-        let req = RequestSyncPacket(p: params.p, m: params.m, data: params.data, types: types)
+        let req = RequestSyncPacket(p: params.p, m: params.m, data: params.data)
         return req.encode()
     }
 
@@ -358,21 +241,20 @@ final class GossipSyncManager {
             isPacketFresh(pair.packet)
         }
 
-        messages.removeExpired(isFresh: isPacketFresh)
-        fragments.removeExpired(isFresh: isPacketFresh)
-        fileTransfers.removeExpired(isFresh: isPacketFresh)
+        // Remove expired messages
+        let expiredMessageIds = messages.compactMap { id, pkt in
+            isPacketFresh(pkt) ? nil : id
+        }
+        for id in expiredMessageIds {
+            messages.removeValue(forKey: id)
+            messageOrder.removeAll { $0 == id }
+        }
     }
 
     private func performPeriodicMaintenance(now: Date = Date()) {
         cleanupExpiredMessages()
         cleanupStaleAnnouncementsIfNeeded(now: now)
-        for index in syncSchedules.indices {
-            guard syncSchedules[index].interval > 0 else { continue }
-            if syncSchedules[index].lastSent == .distantPast || now.timeIntervalSince(syncSchedules[index].lastSent) >= syncSchedules[index].interval {
-                syncSchedules[index].lastSent = now
-                sendRequestSync(for: syncSchedules[index].types)
-            }
-        }
+        sendRequestSync()
     }
 
     private func cleanupStaleAnnouncementsIfNeeded(now: Date) {
@@ -388,27 +270,40 @@ final class GossipSyncManager {
         let nowMs = UInt64(now.timeIntervalSince1970 * 1000)
         guard nowMs >= timeoutMs else { return }
         let cutoff = nowMs - timeoutMs
-        let stalePeerIDs = latestAnnouncementByPeer.compactMap { peerID, pair in
-            pair.packet.timestamp < cutoff ? peerID : nil
+        let stalePeerIDs = latestAnnouncementByPeer.compactMap { (peerHex, pair) -> String? in
+            pair.packet.timestamp < cutoff ? peerHex.lowercased() : nil
         }
         guard !stalePeerIDs.isEmpty else { return }
         for peerKey in stalePeerIDs {
-            removeState(for: peerKey)
+            removeState(forNormalizedPeerID: peerKey)
         }
     }
 
     // Explicit removal hook for LEAVE/stale peer
     func removeAnnouncementForPeer(_ peerID: PeerID) {
         queue.async { [weak self] in
-            self?.removeState(for: peerID)
+            self?._removeAnnouncementForPeer(peerID)
         }
     }
 
-    private func removeState(for peerID: PeerID) {
-        _ = latestAnnouncementByPeer.removeValue(forKey: peerID)
-        messages.remove { PeerID(hexData: $0.senderID) == peerID }
-        fragments.remove { PeerID(hexData: $0.senderID) == peerID }
-        fileTransfers.remove { PeerID(hexData: $0.senderID) == peerID }
+    private func _removeAnnouncementForPeer(_ peerID: PeerID) {
+        let normalizedPeerID = peerID.id.lowercased()
+        removeState(forNormalizedPeerID: normalizedPeerID)
+    }
+
+    private func removeState(forNormalizedPeerID normalizedPeerID: String) {
+        _ = latestAnnouncementByPeer.removeValue(forKey: normalizedPeerID)
+        // Remove messages from this peer
+        // Collect IDs to remove first to avoid concurrent modification
+        let messageIdsToRemove = messages.compactMap { (id, message) -> String? in
+            message.senderID.hexEncodedString().lowercased() == normalizedPeerID ? id : nil
+        }
+        
+        // Remove messages and update messageOrder
+        for id in messageIdsToRemove {
+            messages.removeValue(forKey: id)
+            messageOrder.removeAll { $0 == id }
+        }
     }
 }
 
@@ -422,13 +317,13 @@ extension GossipSyncManager {
 
     func _hasAnnouncement(for peerID: PeerID) -> Bool {
         queue.sync {
-            latestAnnouncementByPeer[peerID] != nil
+            latestAnnouncementByPeer[peerID.id.lowercased()] != nil
         }
     }
 
     func _messageCount(for peerID: PeerID) -> Int {
         queue.sync {
-            messages.allPackets { _ in true }.filter { PeerID(hexData: $0.senderID) == peerID }.count
+            messages.values.filter { $0.senderID.hexEncodedString().lowercased() == peerID.id.lowercased() }.count
         }
     }
 }

bitchat/Sync/SyncTypeFlags.swift

@@ -1,104 +0,0 @@
-import Foundation
-
-/// Bitfield describing which message types are covered by a REQUEST_SYNC round.
-/// Matches the Android mapping (bit index -> message type).
-struct SyncTypeFlags: OptionSet {
-    let rawValue: UInt64
-
-    init(rawValue: UInt64) {
-        self.rawValue = rawValue & 0x00FF_FFFF_FFFF_FFFF // Trim to max 8 bytes
-    }
-
-    private static func bitIndex(for type: MessageType) -> Int? {
-        switch type {
-        case .announce: return 0
-        case .message: return 1
-        case .leave: return 2
-        case .noiseHandshake: return 3
-        case .noiseEncrypted: return 4
-        case .fragment: return 5
-        case .requestSync: return 6
-        case .fileTransfer: return 7
-        }
-    }
-
-    private static func type(forBit index: Int) -> MessageType? {
-        switch index {
-        case 0: return .announce
-        case 1: return .message
-        case 2: return .leave
-        case 3: return .noiseHandshake
-        case 4: return .noiseEncrypted
-        case 5: return .fragment
-        case 6: return .requestSync
-        case 7: return .fileTransfer
-        default:
-            return nil
-        }
-    }
-
-    static let announce = SyncTypeFlags(messageTypes: [.announce])
-    static let message = SyncTypeFlags(messageTypes: [.message])
-    static let fragment = SyncTypeFlags(messageTypes: [.fragment])
-    static let fileTransfer = SyncTypeFlags(messageTypes: [.fileTransfer])
-
-    static let publicMessages = SyncTypeFlags(messageTypes: [.announce, .message])
-
-    init(messageTypes: [MessageType]) {
-        var raw: UInt64 = 0
-        for type in messageTypes {
-            guard let bit = SyncTypeFlags.bitIndex(for: type) else { continue }
-            raw |= (1 << UInt64(bit))
-        }
-        self.init(rawValue: raw)
-    }
-
-    func contains(_ type: MessageType) -> Bool {
-        guard let bit = SyncTypeFlags.bitIndex(for: type) else { return false }
-        return contains(SyncTypeFlags(rawValue: 1 << UInt64(bit)))
-    }
-
-    func union(_ other: SyncTypeFlags) -> SyncTypeFlags {
-        SyncTypeFlags(rawValue: rawValue | other.rawValue)
-    }
-
-    func intersection(_ other: SyncTypeFlags) -> SyncTypeFlags {
-        SyncTypeFlags(rawValue: rawValue & other.rawValue)
-    }
-
-    func toMessageTypes() -> [MessageType] {
-        guard rawValue != 0 else { return [] }
-        var types: [MessageType] = []
-        for bit in 0..<64 {
-            guard (rawValue & (1 << UInt64(bit))) != 0 else { continue }
-            if let type = SyncTypeFlags.type(forBit: bit) {
-                types.append(type)
-            }
-        }
-        return types
-    }
-
-    func toData() -> Data? {
-        guard rawValue != 0 else { return nil }
-        var value = rawValue
-        var bytes: [UInt8] = []
-        while value > 0 && bytes.count < 8 {
-            bytes.append(UInt8(value & 0xFF))
-            value >>= 8
-        }
-        while let last = bytes.last, last == 0 {
-            bytes.removeLast()
-        }
-        guard !bytes.isEmpty, bytes.count <= 8 else { return nil }
-        return Data(bytes)
-    }
-
-    static func decode(_ data: Data) -> SyncTypeFlags? {
-        guard (1...8).contains(data.count) else { return nil }
-        var raw: UInt64 = 0
-        for (index, byte) in data.enumerated() {
-            raw |= UInt64(byte) << UInt64(index * 8)
-        }
-        return SyncTypeFlags(rawValue: raw)
-    }
-}

bitchat/Utils/CompressionUtil.swift

@@ -61,13 +61,15 @@ struct CompressionUtil {
         // 1. Data is too small
         // 2. Data appears to be already compressed (high entropy)
         guard data.count >= compressionThreshold else { return false }
-
-        // Quick uniqueness check — a high diversity of bytes usually means the
-        // payload is already compressed. We only need to know how many unique
-        // values exist rather than keeping full frequency counts.
-        let uniqueByteCount = Set(data).count
-        let sampleSize = min(data.count, 256)
-        let uniqueByteRatio = Double(uniqueByteCount) / Double(sampleSize)
+        
+        // Simple entropy check - count unique bytes
+        var byteFrequency = [UInt8: Int]()
+        for byte in data {
+            byteFrequency[byte, default: 0] += 1
+        }
+        
+        // If we have very high byte diversity, data is likely already compressed
+        let uniqueByteRatio = Double(byteFrequency.count) / Double(min(data.count, 256))
         return uniqueByteRatio < 0.9 // Compress if less than 90% unique bytes
     }
 }

bitchat/Utils/FileTransferLimits.swift

@@ -1,25 +0,0 @@
-import Foundation
-
-/// Centralized thresholds for Bluetooth file transfers to keep payload sizes sane on constrained radios.
-enum FileTransferLimits {
-    /// Absolute ceiling enforced for any file payload (voice, image, other).
-    static let maxPayloadBytes: Int = 1 * 1024 * 1024 // 1 MiB
-    /// Voice notes stay small for low-latency relays.
-    static let maxVoiceNoteBytes: Int = 512 * 1024 // 512 KiB
-    /// Compressed images after downscaling should comfortably fit under this budget.
-    static let maxImageBytes: Int = 512 * 1024 // 512 KiB
-    /// Worst-case size once TLV metadata and binary packet framing are included for the largest payloads.
-    static let maxFramedFileBytes: Int = {
-        let maxMetadataBytes = Int(UInt16.max) * 2 // fileName + mimeType TLVs
-        let tlvEnvelopeOverhead = 18 + maxMetadataBytes // TLV tags + lengths + metadata bytes
-        let binaryEnvelopeOverhead = BinaryProtocol.v2HeaderSize
-            + BinaryProtocol.senderIDSize
-            + BinaryProtocol.recipientIDSize
-            + BinaryProtocol.signatureSize
-        return maxPayloadBytes + tlvEnvelopeOverhead + binaryEnvelopeOverhead
-    }()
-
-    static func isValidPayload(_ size: Int) -> Bool {
-        size <= maxPayloadBytes
-    }
-}

bitchat/Utils/InputValidator.swift

@@ -1,5 +1,4 @@
 import Foundation
-import BitLogger
 
 /// Comprehensive input validation for BitChat protocol
 /// Prevents injection attacks, buffer overflows, and malformed data
@@ -17,28 +16,29 @@ struct InputValidator {
     // MARK: - String Content Validation
     
     /// Validates and sanitizes user-provided strings used in UI
-    ///
-    /// Rejects strings containing control characters to prevent potential security issues
-    /// and UI rendering problems. This strict approach ensures data integrity at input time.
     static func validateUserString(_ string: String, maxLength: Int) -> String? {
+        // Check empty
+        guard !string.isEmpty else { return nil }
+
+        // Trim whitespace
         let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines)
         guard !trimmed.isEmpty else { return nil }
+
+        // Check length
         guard trimmed.count <= maxLength else { return nil }
 
-        // Reject control characters outright instead of rewriting the string.
-        // This prevents injection attacks and ensures consistent UI rendering.
+        // Remove control characters
         let controlChars = CharacterSet.controlCharacters
-        if !trimmed.unicodeScalars.allSatisfy({ !controlChars.contains($0) }) {
-            // Log rejection for monitoring, without exposing actual content for privacy
-            let controlCharCount = trimmed.unicodeScalars.filter { controlChars.contains($0) }.count
-            SecureLogger.debug(
-                "Input validation rejected string (length: \(trimmed.count), control chars: \(controlCharCount))",
-                category: .security
-            )
-            return nil
-        }
-
-        return trimmed
+        let cleaned = trimmed.components(separatedBy: controlChars).joined()
+        
+        // Ensure valid UTF-8 (should already be, but double-check)
+        guard cleaned.data(using: .utf8) != nil else { return nil }
+        
+        // Prevent zero-width characters and other invisible unicode
+        let invisibleChars = CharacterSet(charactersIn: "\u{200B}\u{200C}\u{200D}\u{FEFF}")
+        let visible = cleaned.components(separatedBy: invisibleChars).joined()
+        
+        return visible.isEmpty ? nil : visible
     }
     
     /// Validates nickname

bitchat/ViewModels/GeoChannelCoordinator.swift

@@ -1,118 +0,0 @@
-//
-// GeoChannelCoordinator.swift
-// bitchat
-//
-// Centralizes Combine wiring for location channel selection and sampling.
-//
-
-import Combine
-import Foundation
-import Tor
-
-@MainActor
-final class GeoChannelCoordinator {
-    private let locationManager: LocationChannelManager
-    private let bookmarksStore: GeohashBookmarksStore
-    private let torManager: TorManager
-
-    private let onChannelSwitch: (ChannelID) -> Void
-    private let beginSampling: ([String]) -> Void
-    private let endSampling: () -> Void
-
-    private var cancellables = Set<AnyCancellable>()
-    private var regionalGeohashes: [String] = []
-    private var bookmarkedGeohashes: [String] = []
-
-    init(
-        locationManager: LocationChannelManager? = nil,
-        bookmarksStore: GeohashBookmarksStore? = nil,
-        torManager: TorManager? = nil,
-        onChannelSwitch: @escaping (ChannelID) -> Void,
-        beginSampling: @escaping ([String]) -> Void,
-        endSampling: @escaping () -> Void
-    ) {
-        self.locationManager = locationManager ?? Self.defaultLocationManager()
-        self.bookmarksStore = bookmarksStore ?? GeohashBookmarksStore.shared
-        self.torManager = torManager ?? Self.defaultTorManager()
-        self.onChannelSwitch = onChannelSwitch
-        self.beginSampling = beginSampling
-        self.endSampling = endSampling
-
-        start()
-    }
-
-    func start() {
-        regionalGeohashes = locationManager.availableChannels.map { $0.geohash }
-        bookmarkedGeohashes = bookmarksStore.bookmarks
-
-        locationManager.$selectedChannel
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] channel in
-                guard let self else { return }
-                Task { @MainActor in
-                    self.onChannelSwitch(channel)
-                }
-            }
-            .store(in: &cancellables)
-
-        locationManager.$availableChannels
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] channels in
-                guard let self else { return }
-                self.regionalGeohashes = channels.map { $0.geohash }
-                self.updateSampling()
-            }
-            .store(in: &cancellables)
-
-        bookmarksStore.$bookmarks
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] bookmarks in
-                guard let self else { return }
-                self.bookmarkedGeohashes = bookmarks
-                self.updateSampling()
-            }
-            .store(in: &cancellables)
-
-        locationManager.$permissionState
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] state in
-                guard let self, state == .authorized else { return }
-                Task { @MainActor [weak self] in
-                    self?.locationManager.refreshChannels()
-                }
-            }
-            .store(in: &cancellables)
-
-        Task { @MainActor in
-            self.onChannelSwitch(self.locationManager.selectedChannel)
-        }
-        updateSampling()
-    }
-
-    private func updateSampling() {
-        let union = Array(Set(regionalGeohashes).union(bookmarkedGeohashes))
-        Task { @MainActor in
-            guard !union.isEmpty else {
-                endSampling()
-                return
-            }
-            if torManager.isForeground() {
-                beginSampling(union)
-            } else {
-                endSampling()
-            }
-        }
-    }
-
-    func refreshSampling() {
-        updateSampling()
-    }
-    private static func defaultLocationManager() -> LocationChannelManager {
-        LocationChannelManager.shared
-    }
-
-    @MainActor
-    private static func defaultTorManager() -> TorManager {
-        TorManager.shared
-    }
-}

bitchat/ViewModels/MessageRateLimiter.swift

@@ -1,77 +0,0 @@
-//
-// MessageRateLimiter.swift
-// bitchat
-//
-// Handles per-sender and per-content token buckets for public message intake.
-//
-
-import Foundation
-
-struct MessageRateLimiter {
-    private struct TokenBucket {
-        var capacity: Double
-        var tokens: Double
-        var refillPerSec: Double
-        var lastRefill: Date
-
-        mutating func allow(cost: Double = 1.0, now: Date = Date()) -> Bool {
-            let dt = now.timeIntervalSince(lastRefill)
-            if dt > 0 {
-                tokens = min(capacity, tokens + dt * refillPerSec)
-                lastRefill = now
-            }
-            if tokens >= cost {
-                tokens -= cost
-                return true
-            }
-            return false
-        }
-    }
-
-    private var senderBuckets: [String: TokenBucket] = [:]
-    private var contentBuckets: [String: TokenBucket] = [:]
-
-    private let senderCapacity: Double
-    private let senderRefill: Double
-    private let contentCapacity: Double
-    private let contentRefill: Double
-
-    init(
-        senderCapacity: Double,
-        senderRefillPerSec: Double,
-        contentCapacity: Double,
-        contentRefillPerSec: Double
-    ) {
-        self.senderCapacity = senderCapacity
-        self.senderRefill = senderRefillPerSec
-        self.contentCapacity = contentCapacity
-        self.contentRefill = contentRefillPerSec
-    }
-
-    mutating func allow(senderKey: String, contentKey: String, now: Date = Date()) -> Bool {
-        var senderBucket = senderBuckets[senderKey] ?? TokenBucket(
-            capacity: senderCapacity,
-            tokens: senderCapacity,
-            refillPerSec: senderRefill,
-            lastRefill: now
-        )
-        let senderAllowed = senderBucket.allow(now: now)
-        senderBuckets[senderKey] = senderBucket
-
-        var contentBucket = contentBuckets[contentKey] ?? TokenBucket(
-            capacity: contentCapacity,
-            tokens: contentCapacity,
-            refillPerSec: contentRefill,
-            lastRefill: now
-        )
-        let contentAllowed = contentBucket.allow(now: now)
-        contentBuckets[contentKey] = contentBucket
-
-        return senderAllowed && contentAllowed
-    }
-
-    mutating func reset() {
-        senderBuckets.removeAll()
-        contentBuckets.removeAll()
-    }
-}

bitchat/ViewModels/MinimalDistancePalette.swift

@@ -1,210 +0,0 @@
-//
-// MinimalDistancePalette.swift
-// bitchat
-//
-// Lightweight palette generator that keeps peer colors evenly spaced.
-//
-
-import Foundation
-import SwiftUI
-
-final class MinimalDistancePalette {
-    struct Config {
-        let slotCount: Int
-        let avoidCenterHue: Double
-        let avoidHueDelta: Double
-        let saturationLight: Double
-        let saturationDark: Double
-        let baseBrightnessLight: Double
-        let baseBrightnessDark: Double
-        let ringBrightnessDeltaLight: Double
-        let ringBrightnessDeltaDark: Double
-        let preferredBiasWeight: Double
-        let goldenStep: Int
-
-        init(
-            slotCount: Int,
-            avoidCenterHue: Double,
-            avoidHueDelta: Double,
-            saturationLight: Double,
-            saturationDark: Double,
-            baseBrightnessLight: Double,
-            baseBrightnessDark: Double,
-            ringBrightnessDeltaLight: Double,
-            ringBrightnessDeltaDark: Double,
-            preferredBiasWeight: Double = 0.05,
-            goldenStep: Int = 7
-        ) {
-            self.slotCount = slotCount
-            self.avoidCenterHue = avoidCenterHue
-            self.avoidHueDelta = avoidHueDelta
-            self.saturationLight = saturationLight
-            self.saturationDark = saturationDark
-            self.baseBrightnessLight = baseBrightnessLight
-            self.baseBrightnessDark = baseBrightnessDark
-            self.ringBrightnessDeltaLight = ringBrightnessDeltaLight
-            self.ringBrightnessDeltaDark = ringBrightnessDeltaDark
-            self.preferredBiasWeight = preferredBiasWeight
-            self.goldenStep = goldenStep
-        }
-    }
-
-    private struct Entry {
-        let slot: Int
-        let ring: Int
-        let hue: Double
-    }
-
-    private let config: Config
-    private var currentSeeds: [String: String] = [:]
-    private var entries: [String: Entry] = [:]
-    private var previousEntries: [String: Entry] = [:]
-
-    init(config: Config) {
-        self.config = config
-    }
-
-    @MainActor
-    func ensurePalette(for seeds: [String: String]) {
-        guard seeds != currentSeeds || entries.count != seeds.count else { return }
-        previousEntries = entries
-        currentSeeds = seeds
-        rebuildEntries()
-    }
-
-    @MainActor
-    func color(for identifier: String, isDark: Bool) -> Color? {
-        guard let entry = entries[identifier] else { return nil }
-        let saturation = isDark ? config.saturationDark : config.saturationLight
-        let baseBrightness = isDark ? config.baseBrightnessDark : config.baseBrightnessLight
-        let ringDelta = isDark ? config.ringBrightnessDeltaDark : config.ringBrightnessDeltaLight
-        let brightness = min(1.0, max(0.0, baseBrightness + ringDelta * Double(entry.ring)))
-        return Color(hue: entry.hue, saturation: saturation, brightness: brightness)
-    }
-
-    @MainActor
-    func reset() {
-        currentSeeds.removeAll()
-        entries.removeAll()
-        previousEntries.removeAll()
-    }
-
-    @MainActor
-    private func rebuildEntries() {
-        guard !currentSeeds.isEmpty else {
-            entries.removeAll()
-            return
-        }
-
-        let slotCount = max(8, config.slotCount)
-        var slots: [Double] = []
-        for idx in 0..<slotCount {
-            let hue = Double(idx) / Double(slotCount)
-            if abs(hue - config.avoidCenterHue) < config.avoidHueDelta {
-                continue
-            }
-            slots.append(hue)
-        }
-        if slots.isEmpty {
-            for idx in 0..<slotCount {
-                slots.append(Double(idx) / Double(slotCount))
-            }
-        }
-
-        func circularDistance(_ a: Double, _ b: Double) -> Double {
-            let diff = abs(a - b)
-            return diff > 0.5 ? 1.0 - diff : diff
-        }
-
-        let peerIDs = currentSeeds.keys.sorted()
-        let preferredIndex: [String: Int] = Dictionary(uniqueKeysWithValues: peerIDs.map { id in
-            let seed = currentSeeds[id] ?? id
-            let hash = seed.djb2()
-            let index = Int(hash % UInt64(slots.count))
-            return (id, index)
-        })
-
-        var mapping: [String: Entry] = [:]
-        var usedSlots = Set<Int>()
-        var usedHues: [Double] = []
-
-        let prior = entries.isEmpty ? previousEntries : entries
-        for (id, entry) in prior {
-            guard currentSeeds.keys.contains(id), entry.slot < slots.count else { continue }
-            let hue = slots[entry.slot]
-            mapping[id] = Entry(slot: entry.slot, ring: entry.ring, hue: hue)
-            usedSlots.insert(entry.slot)
-            usedHues.append(hue)
-        }
-
-        let unassigned = peerIDs.filter { mapping[$0] == nil }
-        for id in unassigned {
-            let preferred = preferredIndex[id] ?? 0
-            if !usedSlots.contains(preferred), preferred < slots.count {
-                let hue = slots[preferred]
-                mapping[id] = Entry(slot: preferred, ring: 0, hue: hue)
-                usedSlots.insert(preferred)
-                usedHues.append(hue)
-                continue
-            }
-
-            var bestSlot: Int?
-            var bestScore = -Double.infinity
-            for slot in 0..<slots.count where !usedSlots.contains(slot) {
-                let hue = slots[slot]
-                let minDistance = usedHues.isEmpty ? 1.0 : usedHues.map { circularDistance(hue, $0) }.min() ?? 1.0
-                let bias = 1.0 - (Double((abs(slot - (preferredIndex[id] ?? 0)) % slots.count)) / Double(slots.count))
-                let score = minDistance + config.preferredBiasWeight * bias
-                if score > bestScore {
-                    bestScore = score
-                    bestSlot = slot
-                }
-            }
-
-            if let slot = bestSlot {
-                let hue = slots[slot]
-                mapping[id] = Entry(slot: slot, ring: 0, hue: hue)
-                usedSlots.insert(slot)
-                usedHues.append(hue)
-            }
-        }
-
-        let remaining = peerIDs.filter { mapping[$0] == nil }
-        if !remaining.isEmpty {
-            for (index, id) in remaining.enumerated() {
-                let preferred = preferredIndex[id] ?? 0
-                let slot = (preferred + index * config.goldenStep) % slots.count
-                let hue = slots[slot]
-                mapping[id] = Entry(slot: slot, ring: 1, hue: hue)
-            }
-        }
-
-        entries = mapping
-    }
-}
-
-extension MinimalDistancePalette.Config {
-    static let mesh = MinimalDistancePalette.Config(
-        slotCount: TransportConfig.uiPeerPaletteSlots,
-        avoidCenterHue: 30.0 / 360.0,
-        avoidHueDelta: TransportConfig.uiColorHueAvoidanceDelta,
-        saturationLight: 0.70,
-        saturationDark: 0.80,
-        baseBrightnessLight: 0.45,
-        baseBrightnessDark: 0.75,
-        ringBrightnessDeltaLight: TransportConfig.uiPeerPaletteRingBrightnessDeltaLight,
-        ringBrightnessDeltaDark: TransportConfig.uiPeerPaletteRingBrightnessDeltaDark
-    )
-
-    static let nostr = MinimalDistancePalette.Config(
-        slotCount: TransportConfig.uiPeerPaletteSlots,
-        avoidCenterHue: 30.0 / 360.0,
-        avoidHueDelta: TransportConfig.uiColorHueAvoidanceDelta,
-        saturationLight: 0.70,
-        saturationDark: 0.80,
-        baseBrightnessLight: 0.45,
-        baseBrightnessDark: 0.75,
-        ringBrightnessDeltaLight: TransportConfig.uiPeerPaletteRingBrightnessDeltaLight,
-        ringBrightnessDeltaDark: TransportConfig.uiPeerPaletteRingBrightnessDeltaDark
-    )
-}

bitchat/ViewModels/PublicMessagePipeline.swift

@@ -1,190 +0,0 @@
-//
-// PublicMessagePipeline.swift
-// bitchat
-//
-// Handles batching and deduplication of public chat messages before surfacing them to the UI.
-//
-
-import Foundation
-
-@MainActor
-protocol PublicMessagePipelineDelegate: AnyObject {
-    func pipelineCurrentMessages(_ pipeline: PublicMessagePipeline) -> [BitchatMessage]
-    func pipeline(_ pipeline: PublicMessagePipeline, setMessages messages: [BitchatMessage])
-    func pipeline(_ pipeline: PublicMessagePipeline, normalizeContent content: String) -> String
-    func pipeline(_ pipeline: PublicMessagePipeline, contentTimestampForKey key: String) -> Date?
-    func pipeline(_ pipeline: PublicMessagePipeline, recordContentKey key: String, timestamp: Date)
-    func pipelineTrimMessages(_ pipeline: PublicMessagePipeline)
-    func pipelinePrewarmMessage(_ pipeline: PublicMessagePipeline, message: BitchatMessage)
-    func pipelineSetBatchingState(_ pipeline: PublicMessagePipeline, isBatching: Bool)
-}
-
-@MainActor
-final class PublicMessagePipeline {
-    weak var delegate: PublicMessagePipelineDelegate?
-
-    private var buffer: [BitchatMessage] = []
-    private var timer: Timer?
-    private let baseFlushInterval: TimeInterval
-    private var dynamicFlushInterval: TimeInterval
-    private var recentBatchSizes: [Int] = []
-    private let maxRecentBatchSamples: Int
-    private let dedupWindow: TimeInterval
-    private var activeChannel: ChannelID = .mesh
-
-    init(
-        baseFlushInterval: TimeInterval = TransportConfig.basePublicFlushInterval,
-        maxRecentBatchSamples: Int = 10,
-        dedupWindow: TimeInterval = 1.0
-    ) {
-        self.baseFlushInterval = baseFlushInterval
-        self.dynamicFlushInterval = baseFlushInterval
-        self.maxRecentBatchSamples = maxRecentBatchSamples
-        self.dedupWindow = dedupWindow
-    }
-
-    deinit {
-        timer?.invalidate()
-    }
-
-    func updateActiveChannel(_ channel: ChannelID) {
-        activeChannel = channel
-    }
-
-    func enqueue(_ message: BitchatMessage) {
-        buffer.append(message)
-        scheduleFlush()
-    }
-
-    func flushIfNeeded() {
-        flushBuffer()
-    }
-
-    func reset() {
-        timer?.invalidate()
-        timer = nil
-        buffer.removeAll(keepingCapacity: false)
-    }
-
-}
-
-private extension PublicMessagePipeline {
-    func scheduleFlush() {
-        guard timer == nil else { return }
-        timer = Timer.scheduledTimer(withTimeInterval: dynamicFlushInterval, repeats: false) { [weak self] _ in
-            guard let self else { return }
-            Task { @MainActor in
-                self.flushBuffer()
-            }
-        }
-    }
-
-    func flushBuffer() {
-        timer?.invalidate()
-        timer = nil
-        guard !buffer.isEmpty else { return }
-        guard let delegate = delegate else {
-            buffer.removeAll(keepingCapacity: false)
-            return
-        }
-
-        delegate.pipelineSetBatchingState(self, isBatching: true)
-
-        var existingIDs = Set(delegate.pipelineCurrentMessages(self).map { $0.id })
-        var pending: [(message: BitchatMessage, contentKey: String)] = []
-        var batchContentLatest: [String: Date] = [:]
-
-        for message in buffer {
-            if existingIDs.contains(message.id) { continue }
-            let contentKey = delegate.pipeline(self, normalizeContent: message.content)
-            if let ts = delegate.pipeline(self, contentTimestampForKey: contentKey),
-               abs(ts.timeIntervalSince(message.timestamp)) < dedupWindow {
-                continue
-            }
-            if let ts = batchContentLatest[contentKey],
-               abs(ts.timeIntervalSince(message.timestamp)) < dedupWindow {
-                continue
-            }
-            existingIDs.insert(message.id)
-            pending.append((message, contentKey))
-            batchContentLatest[contentKey] = message.timestamp
-        }
-
-        buffer.removeAll(keepingCapacity: true)
-        guard !pending.isEmpty else {
-            delegate.pipelineSetBatchingState(self, isBatching: false)
-            if !buffer.isEmpty { scheduleFlush() }
-            return
-        }
-
-        pending.sort { $0.message.timestamp < $1.message.timestamp }
-
-        var messages = delegate.pipelineCurrentMessages(self)
-        let threshold = lateInsertThreshold(for: activeChannel)
-        let lastTimestamp = messages.last?.timestamp ?? .distantPast
-
-        for item in pending {
-            let message = item.message
-            if threshold == 0 || message.timestamp < lastTimestamp.addingTimeInterval(-threshold) {
-                let index = insertionIndex(for: message.timestamp, in: messages)
-                if index >= messages.count {
-                    messages.append(message)
-                } else {
-                    messages.insert(message, at: index)
-                }
-            } else {
-                messages.append(message)
-            }
-            delegate.pipeline(self, recordContentKey: item.contentKey, timestamp: message.timestamp)
-        }
-
-        delegate.pipeline(self, setMessages: messages)
-        delegate.pipelineTrimMessages(self)
-
-        updateFlushInterval(withBatchSize: pending.count)
-
-        for item in pending {
-            delegate.pipelinePrewarmMessage(self, message: item.message)
-        }
-
-        delegate.pipelineSetBatchingState(self, isBatching: false)
-
-        if !buffer.isEmpty {
-            scheduleFlush()
-        }
-    }
-
-    func updateFlushInterval(withBatchSize size: Int) {
-        recentBatchSizes.append(size)
-        if recentBatchSizes.count > maxRecentBatchSamples {
-            recentBatchSizes.removeFirst(recentBatchSizes.count - maxRecentBatchSamples)
-        }
-        let avg = recentBatchSizes.isEmpty
-            ? 0.0
-            : Double(recentBatchSizes.reduce(0, +)) / Double(recentBatchSizes.count)
-        dynamicFlushInterval = avg > 100.0 ? 0.12 : baseFlushInterval
-    }
-
-    func lateInsertThreshold(for channel: ChannelID) -> TimeInterval {
-        switch channel {
-        case .mesh:
-            return TransportConfig.uiLateInsertThreshold
-        case .location:
-            return TransportConfig.uiLateInsertThresholdGeo
-        }
-    }
-
-    func insertionIndex(for timestamp: Date, in messages: [BitchatMessage]) -> Int {
-        var low = 0
-        var high = messages.count
-        while low < high {
-            let mid = (low + high) / 2
-            if messages[mid].timestamp < timestamp {
-                low = mid + 1
-            } else {
-                high = mid
-            }
-        }
-        return low
-    }
-}

bitchat/ViewModels/PublicTimelineStore.swift

@@ -1,124 +0,0 @@
-//
-// PublicTimelineStore.swift
-// bitchat
-//
-// Maintains mesh and geohash public timelines with simple caps and helpers.
-//
-
-import Foundation
-
-struct PublicTimelineStore {
-    private var meshTimeline: [BitchatMessage] = []
-    private var geohashTimelines: [String: [BitchatMessage]] = [:]
-    private var pendingGeohashSystemMessages: [String] = []
-
-    private let meshCap: Int
-    private let geohashCap: Int
-
-    init(meshCap: Int, geohashCap: Int) {
-        self.meshCap = meshCap
-        self.geohashCap = geohashCap
-    }
-
-    mutating func append(_ message: BitchatMessage, to channel: ChannelID) {
-        switch channel {
-        case .mesh:
-            guard !meshTimeline.contains(where: { $0.id == message.id }) else { return }
-            meshTimeline.append(message)
-            trimMeshTimelineIfNeeded()
-        case .location(let channel):
-            append(message, toGeohash: channel.geohash)
-        }
-    }
-
-    mutating func append(_ message: BitchatMessage, toGeohash geohash: String) {
-        var timeline = geohashTimelines[geohash] ?? []
-        guard !timeline.contains(where: { $0.id == message.id }) else { return }
-        timeline.append(message)
-        trimGeohashTimelineIfNeeded(&timeline)
-        geohashTimelines[geohash] = timeline
-    }
-
-    /// Append message if absent, returning true when stored.
-    mutating func appendIfAbsent(_ message: BitchatMessage, toGeohash geohash: String) -> Bool {
-        var timeline = geohashTimelines[geohash] ?? []
-        guard !timeline.contains(where: { $0.id == message.id }) else { return false }
-        timeline.append(message)
-        trimGeohashTimelineIfNeeded(&timeline)
-        geohashTimelines[geohash] = timeline
-        return true
-    }
-
-    mutating func messages(for channel: ChannelID) -> [BitchatMessage] {
-        switch channel {
-        case .mesh:
-            return meshTimeline
-        case .location(let channel):
-            let cleaned = geohashTimelines[channel.geohash]?.cleanedAndDeduped() ?? []
-            geohashTimelines[channel.geohash] = cleaned
-            return cleaned
-        }
-    }
-
-    mutating func clear(channel: ChannelID) {
-        switch channel {
-        case .mesh:
-            meshTimeline.removeAll()
-        case .location(let channel):
-            geohashTimelines[channel.geohash] = []
-        }
-    }
-
-    @discardableResult
-    mutating func removeMessage(withID id: String) -> BitchatMessage? {
-        if let index = meshTimeline.firstIndex(where: { $0.id == id }) {
-            return meshTimeline.remove(at: index)
-        }
-
-        for key in Array(geohashTimelines.keys) {
-            var timeline = geohashTimelines[key] ?? []
-            if let index = timeline.firstIndex(where: { $0.id == id }) {
-                let removed = timeline.remove(at: index)
-                geohashTimelines[key] = timeline.isEmpty ? nil : timeline
-                return removed
-            }
-        }
-
-        return nil
-    }
-
-    mutating func removeMessages(in geohash: String, where predicate: (BitchatMessage) -> Bool) {
-        var timeline = geohashTimelines[geohash] ?? []
-        timeline.removeAll(where: predicate)
-        geohashTimelines[geohash] = timeline.isEmpty ? nil : timeline
-    }
-
-    mutating func mutateGeohash(_ geohash: String, _ transform: (inout [BitchatMessage]) -> Void) {
-        var timeline = geohashTimelines[geohash] ?? []
-        transform(&timeline)
-        geohashTimelines[geohash] = timeline.isEmpty ? nil : timeline
-    }
-
-    mutating func queueGeohashSystemMessage(_ content: String) {
-        pendingGeohashSystemMessages.append(content)
-    }
-
-    mutating func drainPendingGeohashSystemMessages() -> [String] {
-        defer { pendingGeohashSystemMessages.removeAll(keepingCapacity: false) }
-        return pendingGeohashSystemMessages
-    }
-
-    func geohashKeys() -> [String] {
-        Array(geohashTimelines.keys)
-    }
-
-    private mutating func trimMeshTimelineIfNeeded() {
-        guard meshTimeline.count > meshCap else { return }
-        meshTimeline = Array(meshTimeline.suffix(meshCap))
-    }
-
-    private func trimGeohashTimelineIfNeeded(_ timeline: inout [BitchatMessage]) {
-        guard timeline.count > geohashCap else { return }
-        timeline = Array(timeline.suffix(geohashCap))
-    }
-}

bitchat/Views/Components/CommandSuggestionsView.swift

@@ -1,90 +0,0 @@
-//
-//  CommandSuggestionsView.swift
-//  bitchat
-//
-//  Created by Islam on 29/10/2025.
-//
-
-import SwiftUI
-
-struct CommandSuggestionsView: View {
-    @EnvironmentObject private var viewModel: ChatViewModel
-    @ObservedObject private var locationManager = LocationChannelManager.shared
-    
-    @Binding var messageText: String
-    
-    let textColor: Color
-    let backgroundColor: Color
-    let secondaryTextColor: Color
-    
-    private var filteredCommands: [CommandInfo] {
-        guard messageText.hasPrefix("/") && !messageText.contains(" ") else { return [] }
-        let isGeoPublic = locationManager.selectedChannel.isLocation
-        let isGeoDM = viewModel.selectedPrivateChatPeer?.isGeoDM == true
-        return CommandInfo.all(isGeoPublic: isGeoPublic, isGeoDM: isGeoDM).filter { command in
-            command.alias.starts(with: messageText.lowercased())
-        }
-    }
-    
-    var body: some View {
-        VStack(alignment: .leading, spacing: 0) {
-            ForEach(filteredCommands) { command in
-                Button {
-                    messageText = command.alias + " "
-                } label: {
-                    buttonRow(for: command)
-                }
-                .buttonStyle(.plain)
-                .background(Color.gray.opacity(0.1))
-            }
-        }
-        .background(backgroundColor)
-        .overlay(
-            RoundedRectangle(cornerRadius: 4)
-                .stroke(secondaryTextColor.opacity(0.3), lineWidth: 1)
-        )
-    }
-    
-    private func buttonRow(for command: CommandInfo) -> some View {
-        HStack {
-            Text(command.alias)
-                .font(.bitchatSystem(size: 11, design: .monospaced))
-                .foregroundColor(textColor)
-                .fontWeight(.medium)
-            
-            if let placeholder = command.placeholder {
-                Text(placeholder)
-                    .font(.bitchatSystem(size: 10, design: .monospaced))
-                    .foregroundColor(secondaryTextColor.opacity(0.8))
-            }
-
-            Spacer()
-            
-            Text(command.description)
-                .font(.bitchatSystem(size: 10, design: .monospaced))
-                .foregroundColor(secondaryTextColor)
-        }
-        .padding(.horizontal, 12)
-        .padding(.vertical, 3)
-        .frame(maxWidth: .infinity, alignment: .leading)
-    }
-}
-
-@available(iOS 17, macOS 14, *)
-#Preview {
-    @Previewable @State var messageText: String = "/"
-    let keychain = KeychainManager()
-    let viewModel = ChatViewModel(
-        keychain: keychain,
-        idBridge: NostrIdentityBridge(),
-        identityManager: SecureIdentityStateManager(keychain)
-    )
-    
-    CommandSuggestionsView(
-        messageText: $messageText,
-        textColor: .green,
-        backgroundColor: .primary,
-        secondaryTextColor: .secondary
-    )
-    .environmentObject(viewModel)
-}

bitchat/Views/FingerprintView.swift

@@ -10,7 +10,7 @@ import SwiftUI
 
 struct FingerprintView: View {
     @ObservedObject var viewModel: ChatViewModel
-    let peerID: PeerID
+    let peerID: String
     @Environment(\.dismiss) var dismiss
     @Environment(\.colorScheme) var colorScheme
     
@@ -65,12 +65,15 @@ struct FingerprintView: View {
             
             VStack(alignment: .leading, spacing: 16) {
                 // Prefer short mesh ID for session/encryption status
-                let statusPeerID = viewModel.getShortIDForNoiseKey(peerID)
+                let statusPeerID: String = {
+                    if peerID.count == 64, let short = viewModel.getShortIDForNoiseKey(peerID) { return short.id }
+                    return peerID
+                }()
                 // Resolve a friendly name
                 let peerNickname: String = {
-                    if let p = viewModel.getPeer(byID: statusPeerID) { return p.displayName }
-                    if let name = viewModel.meshService.peerNickname(peerID: statusPeerID) { return name }
-                    if let data = peerID.noiseKey {
+                    if let p = viewModel.getPeer(byID: PeerID(str: statusPeerID)) { return p.displayName }
+                    if let name = viewModel.meshService.peerNickname(peerID: PeerID(str: statusPeerID)) { return name }
+                    if peerID.count == 64, let data = Data(hexString: peerID) {
                         if let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: data), !fav.peerNickname.isEmpty { return fav.peerNickname }
                         let fp = data.sha256Fingerprint()
                         if let social = viewModel.identityManager.getSocialIdentity(for: fp) {
@@ -81,7 +84,7 @@ struct FingerprintView: View {
                     return Strings.unknownPeer()
                 }()
                 // Accurate encryption state based on short ID session
-                let encryptionStatus = viewModel.getEncryptionStatus(for: statusPeerID)
+                let encryptionStatus = viewModel.getEncryptionStatus(for: PeerID(str: statusPeerID))
                 
                 HStack {
                     if let icon = encryptionStatus.icon {
@@ -112,7 +115,7 @@ struct FingerprintView: View {
                         .font(.bitchatSystem(size: 12, weight: .bold, design: .monospaced))
                         .foregroundColor(textColor.opacity(0.7))
                     
-                    if let fingerprint = viewModel.getFingerprint(for: statusPeerID) {
+                    if let fingerprint = viewModel.getFingerprint(for: PeerID(str: statusPeerID)) {
                         Text(formatFingerprint(fingerprint))
                             .font(.bitchatSystem(size: 14, design: .monospaced))
                             .foregroundColor(textColor)
@@ -173,6 +176,7 @@ struct FingerprintView: View {
                 // Verification status
                 if encryptionStatus == .noiseSecured || encryptionStatus == .noiseVerified {
                     let isVerified = encryptionStatus == .noiseVerified
+                    let peerID = PeerID(str: peerID)
                     
                     VStack(spacing: 12) {
                         Text(isVerified ? Strings.verifiedBadge : Strings.notVerifiedBadge)
@@ -236,6 +240,8 @@ struct FingerprintView: View {
         .padding()
         .frame(maxWidth: .infinity, maxHeight: .infinity)
         .background(backgroundColor)
+        .presentationDetents([.large])
+        .presentationDragIndicator(.visible)
     }
     
     private func formatFingerprint(_ fingerprint: String) -> String {

bitchat/Views/LocationChannelsSheet.swift

@@ -125,6 +125,9 @@ struct LocationChannelsSheet: View {
             .navigationTitle("")
             #endif
         }
+        #if os(iOS)
+        .presentationDetents([.large])
+        #endif
         #if os(macOS)
         .frame(minWidth: 420, minHeight: 520)
         #endif
@@ -596,7 +599,7 @@ extension LocationChannelsSheet {
         switch level {
         case .region:
             return ""
-        case .building, .block, .neighborhood, .city, .province:
+        default:
             return "~"
         }
     }

bitchat/Views/LocationNotesView.swift

@@ -78,6 +78,9 @@ struct LocationNotesView: View {
             .navigationTitle("")
             #endif
         }
+       #if os(iOS)
+        .presentationDetents([.large])
+        #endif
         .background(backgroundColor)
         .onDisappear { manager.cancel() }
         .onChange(of: geohash) { newValue in
@@ -138,7 +141,7 @@ struct LocationNotesView: View {
         String(
             format: String(localized: "location_notes.header", comment: "Header displaying the geohash and localized note count"),
             locale: .current,
-            "\(geohash) ± 1", count
+            geohash, count
         )
     }
 

bitchat/Views/Media/BlockRevealImageView.swift

@@ -1,191 +0,0 @@
-import SwiftUI
-
-#if os(iOS)
-import UIKit
-private typealias PlatformImage = UIImage
-#else
-import AppKit
-private typealias PlatformImage = NSImage
-#endif
-
-struct BlockRevealImageView: View {
-    private let url: URL
-    private let revealProgress: Double?
-    private let isSending: Bool
-    private let onCancel: (() -> Void)?
-    private let initiallyBlurred: Bool
-    private let onOpen: (() -> Void)?
-    private let onDelete: (() -> Void)?
-
-    @State private var platformImage: PlatformImage?
-    @State private var aspectRatio: CGFloat = 1
-    @State private var isBlurred: Bool = false
-
-    init(
-        url: URL,
-        revealProgress: Double?,
-        isSending: Bool,
-        onCancel: (() -> Void)?,
-        initiallyBlurred: Bool = false,
-        onOpen: (() -> Void)? = nil,
-        onDelete: (() -> Void)? = nil
-    ) {
-        self.url = url
-        self.revealProgress = revealProgress
-        self.isSending = isSending
-        self.onCancel = onCancel
-        self.initiallyBlurred = initiallyBlurred
-        self.onOpen = onOpen
-        self.onDelete = onDelete
-    }
-
-    private var fraction: Double {
-        guard let revealProgress = revealProgress else { return 1 }
-        return max(0, min(1, revealProgress))
-    }
-
-    var body: some View {
-        ZStack(alignment: .topTrailing) {
-            if let image = platformImage {
-                Image(platformImage: image)
-                    .resizable()
-                    .aspectRatio(aspectRatio, contentMode: .fit)
-                    .clipShape(RoundedRectangle(cornerRadius: 16, style: .continuous))
-                    .overlay(
-                        RoundedRectangle(cornerRadius: 16, style: .continuous)
-                            .stroke(Color.gray.opacity(0.2), lineWidth: 1)
-                    )
-                    .mask(
-                        BlockRevealMask(
-                            fraction: fraction,
-                            columns: 24,
-                            rows: 16
-                        )
-                        .animation(.easeOut(duration: 0.2), value: fraction)
-                    )
-                    .blur(radius: isBlurred ? 20 : 0)
-                    .overlay {
-                        if isBlurred {
-                            RoundedRectangle(cornerRadius: 16, style: .continuous)
-                                .fill(Color.black.opacity(0.35))
-                                .overlay(
-                                    Image(systemName: "eye.slash.fill")
-                                        .font(.bitchatSystem(size: 24, weight: .semibold))
-                                        .foregroundColor(.white.opacity(0.85))
-                                )
-                        }
-                    }
-            } else {
-                RoundedRectangle(cornerRadius: 16, style: .continuous)
-                    .fill(Color.gray.opacity(0.2))
-                    .frame(height: 200)
-                    .overlay(
-                        ProgressView()
-                            .progressViewStyle(.circular)
-                    )
-            }
-
-            if let onCancel = onCancel, isSending {
-                Button(action: onCancel) {
-                    Image(systemName: "xmark")
-                        .font(.bitchatSystem(size: 12, weight: .bold))
-                        .padding(8)
-                        .background(Circle().fill(Color.black.opacity(0.7)))
-                        .foregroundColor(.white)
-                        .padding(8)
-                }
-                .buttonStyle(.plain)
-            }
-        }
-        .onAppear {
-            isBlurred = initiallyBlurred
-            loadImage()
-        }
-        .onChange(of: url) { _ in
-            isBlurred = initiallyBlurred
-            loadImage()
-        }
-        .gesture(mainGesture)
-    }
-
-    private func loadImage() {
-        DispatchQueue.global(qos: .userInitiated).async {
-            #if os(iOS)
-            guard let image = UIImage(contentsOfFile: url.path) else { return }
-            #else
-            guard let image = NSImage(contentsOf: url) else { return }
-            #endif
-            let ratio = image.size.height > 0 ? image.size.width / image.size.height : 1
-            DispatchQueue.main.async {
-                self.platformImage = image
-                self.aspectRatio = ratio
-            }
-        }
-    }
-
-    private var mainGesture: some Gesture {
-        let doubleTap = TapGesture(count: 2).onEnded {
-            guard !isSending else { return }
-            onDelete?()
-        }
-        let singleTap = TapGesture().onEnded {
-            guard !isSending else { return }
-            if isBlurred {
-                withAnimation(.easeOut(duration: 0.2)) {
-                    isBlurred = false
-                }
-            } else {
-                onOpen?()
-            }
-        }
-        let swipe = DragGesture(minimumDistance: 20, coordinateSpace: .local).onEnded { value in
-            guard !isSending else { return }
-            let horizontal = value.translation.width
-            let vertical = value.translation.height
-            guard abs(horizontal) > abs(vertical), abs(horizontal) > 40 else { return }
-            if !isBlurred {
-                withAnimation(.easeInOut(duration: 0.2)) {
-                    isBlurred = true
-                }
-            }
-        }
-        return doubleTap.exclusively(before: singleTap).simultaneously(with: swipe)
-    }
-}
-
-private struct BlockRevealMask: Shape {
-    let fraction: Double
-    let columns: Int
-    let rows: Int
-
-    func path(in rect: CGRect) -> Path {
-        var path = Path()
-        guard fraction > 0, columns > 0, rows > 0 else { return path }
-        let totalBlocks = columns * rows
-        let revealCount = max(0, min(totalBlocks, Int(ceil(fraction * Double(totalBlocks)))))
-        guard revealCount > 0 else { return path }
-        let blockWidth = rect.width / CGFloat(columns)
-        let blockHeight = rect.height / CGFloat(rows)
-        var remaining = revealCount
-        for row in 0..<rows {
-            for column in 0..<columns {
-                if remaining <= 0 { return path }
-                let x = CGFloat(column) * blockWidth
-                let y = CGFloat(row) * blockHeight
-                path.addRect(CGRect(x: x, y: y, width: blockWidth, height: blockHeight))
-                remaining -= 1
-            }
-        }
-        return path
-    }
-}
-
-private extension Image {
-    init(platformImage: PlatformImage) {
-        #if os(iOS)
-        self.init(uiImage: platformImage)
-        #else
-        self.init(nsImage: platformImage)
-        #endif
-    }
-}

bitchat/Views/Media/VoiceNoteView.swift

@@ -1,123 +0,0 @@
-import SwiftUI
-import AVFoundation
-
-struct VoiceNoteView: View {
-    private let url: URL
-    private let isSending: Bool
-    private let sendProgress: Double?
-    private let onCancel: (() -> Void)?
-
-    @Environment(\.colorScheme) private var colorScheme
-    @StateObject private var playback: VoiceNotePlaybackController
-    @State private var waveform: [Float] = []
-
-    init(url: URL, isSending: Bool, sendProgress: Double?, onCancel: (() -> Void)?) {
-        self.url = url
-        self.isSending = isSending
-        self.sendProgress = sendProgress
-        self.onCancel = onCancel
-        _playback = StateObject(wrappedValue: VoiceNotePlaybackController(url: url))
-    }
-
-    private var samples: [Float] {
-        if waveform.isEmpty {
-            return Array(repeating: 0.25, count: 64)
-        }
-        return waveform
-    }
-
-    private var backgroundColor: Color {
-        colorScheme == .dark ? Color.black.opacity(0.6) : Color.white
-    }
-
-    private var borderColor: Color {
-        colorScheme == .dark ? Color.green.opacity(0.3) : Color.green.opacity(0.2)
-    }
-
-    private var durationText: String {
-        let duration = playback.duration
-        guard duration.isFinite, duration > 0 else { return "--:--" }
-        let minutes = Int(duration) / 60
-        let seconds = Int(duration) % 60
-        return String(format: "%02d:%02d", minutes, seconds)
-    }
-
-    private var currentText: String {
-        let current = playback.currentTime
-        guard current.isFinite, current > 0 else { return "00:00" }
-        let minutes = Int(current) / 60
-        let seconds = Int(current) % 60
-        return String(format: "%02d:%02d", minutes, seconds)
-    }
-
-    private var playbackLabel: String {
-        playback.isPlaying ? currentText + "/" + durationText : durationText
-    }
-
-    var body: some View {
-        HStack(spacing: 12) {
-            Button(action: playback.togglePlayback) {
-                Image(systemName: playback.isPlaying ? "pause.fill" : "play.fill")
-                    .foregroundColor(.white)
-                    .frame(width: 36, height: 36)
-                    .background(Circle().fill(Color.green))
-            }
-            .buttonStyle(.plain)
-
-            WaveformView(
-                samples: samples,
-                playbackProgress: playback.progress,
-                sendProgress: sendProgress,
-                onSeek: { fraction in
-                    playback.seek(to: fraction)
-                },
-                isInteractive: playback.isPlaying
-            )
-
-            Text(playbackLabel)
-                .font(.bitchatSystem(size: 13, design: .monospaced))
-                .foregroundColor(Color.secondary)
-
-            if let onCancel = onCancel, isSending {
-                Button(action: onCancel) {
-                    Image(systemName: "xmark")
-                        .font(.bitchatSystem(size: 12, weight: .bold))
-                        .frame(width: 28, height: 28)
-                        .background(Circle().fill(Color.red.opacity(0.9)))
-                        .foregroundColor(.white)
-                }
-                .buttonStyle(.plain)
-            }
-        }
-        .padding(12)
-        .background(
-            RoundedRectangle(cornerRadius: 14)
-                .fill(backgroundColor)
-                .shadow(color: Color.black.opacity(colorScheme == .dark ? 0.3 : 0.1), radius: 6, x: 0, y: 2)
-        )
-        .overlay(
-            RoundedRectangle(cornerRadius: 14)
-                .stroke(borderColor, lineWidth: 1)
-        )
-        .task {
-            // Defer loading to let UI settle after view appears
-            try? await Task.sleep(nanoseconds: 100_000_000) // 0.1s
-            playback.loadDuration()
-            await withCheckedContinuation { continuation in
-                WaveformCache.shared.waveform(for: url, completion: { bins in
-                    waveform = bins
-                    continuation.resume()
-                })
-            }
-        }
-        .onChange(of: url) { newValue in
-            WaveformCache.shared.waveform(for: newValue, completion: { bins in
-                self.waveform = bins
-            })
-            playback.replaceURL(newValue)
-        }
-        .onDisappear {
-            playback.stop()
-        }
-    }
-}

bitchat/Views/Media/WaveformView.swift

@@ -1,67 +0,0 @@
-import SwiftUI
-
-struct WaveformView: View {
-    let samples: [Float]
-    let playbackProgress: Double
-    let sendProgress: Double?
-    let onSeek: ((Double) -> Void)?
-    let isInteractive: Bool
-
-    private var clampedPlayback: Double {
-        max(0, min(1, playbackProgress))
-    }
-
-    private var clampedSend: Double? {
-        guard let sendProgress = sendProgress else { return nil }
-        return max(0, min(1, sendProgress))
-    }
-
-    var body: some View {
-        GeometryReader { geometry in
-            ZStack {
-                Canvas { context, size in
-                    guard !samples.isEmpty else { return }
-                    let width = max(size.width, 1)
-                    let height = max(size.height, 1)
-                    let barWidth = max(width / CGFloat(samples.count), 1)
-                    for (index, sample) in samples.enumerated() {
-                        let normalized = max(0, min(sample, 1))
-                        let barHeight = CGFloat(normalized) * height
-                        let originX = CGFloat(index) * barWidth
-                        let rect = CGRect(
-                            x: originX,
-                            y: (height - barHeight) / 2,
-                            width: max(barWidth * 0.7, 1),
-                            height: barHeight
-                        )
-                        let binPosition = Double(index) / Double(samples.count)
-                        let color: Color
-                        if binPosition <= clampedPlayback {
-                            color = Color.green
-                        } else if let send = clampedSend, binPosition <= send {
-                            color = Color.blue
-                        } else {
-                            color = Color.gray.opacity(0.35)
-                        }
-                        context.fill(Path(rect), with: .color(color))
-                    }
-                }
-                .frame(width: geometry.size.width, height: geometry.size.height)
-
-                if isInteractive, let onSeek = onSeek {
-                    Color.clear
-                        .contentShape(Rectangle())
-                        .gesture(
-                            DragGesture(minimumDistance: 0)
-                                .onEnded { value in
-                                    guard geometry.size.width > 0 else { return }
-                                    let fraction = max(0, min(1, value.location.x / geometry.size.width))
-                                    onSeek(fraction)
-                                }
-                        )
-                }
-            }
-        }
-        .frame(height: 48)
-    }
-}

bitchat/Views/MeshPeerList.swift

@@ -4,9 +4,9 @@ struct MeshPeerList: View {
     @ObservedObject var viewModel: ChatViewModel
     let textColor: Color
     let secondaryTextColor: Color
-    let onTapPeer: (PeerID) -> Void
-    let onToggleFavorite: (PeerID) -> Void
-    let onShowFingerprint: (PeerID) -> Void
+    let onTapPeer: (String) -> Void
+    let onToggleFavorite: (String) -> Void
+    let onShowFingerprint: (String) -> Void
     @Environment(\.colorScheme) var colorScheme
 
     @State private var orderedIDs: [String] = []
@@ -130,7 +130,7 @@ struct MeshPeerList: View {
                         }
 
                         if !isMe {
-                            Button(action: { onToggleFavorite(peer.peerID) }) {
+                            Button(action: { onToggleFavorite(peer.peerID.id) }) {
                                 Image(systemName: (peer.favoriteStatus?.isFavorite ?? false) ? "star.fill" : "star")
                                     .font(.bitchatSystem(size: 12))
                                     .foregroundColor((peer.favoriteStatus?.isFavorite ?? false) ? .yellow : secondaryTextColor)
@@ -142,8 +142,8 @@ struct MeshPeerList: View {
                     .padding(.vertical, 4)
                     .padding(.top, idx == 0 ? 10 : 0)
                     .contentShape(Rectangle())
-                    .onTapGesture { if !isMe { onTapPeer(peer.peerID) } }
-                    .onTapGesture(count: 2) { if !isMe { onShowFingerprint(peer.peerID) } }
+                    .onTapGesture { if !isMe { onTapPeer(peer.peerID.id) } }
+                    .onTapGesture(count: 2) { if !isMe { onShowFingerprint(peer.peerID.id) } }
                 }
             }
             // Seed and update order outside result builder

bitchat/Views/VerificationViews.swift

@@ -388,6 +388,10 @@ struct VerificationSheetView: View {
             .padding(.vertical, 14)
         }
         .background(backgroundColor)
+        #if os(iOS)
+        .presentationDetents([.large])
+        .presentationDragIndicator(.visible)
+        #endif
         .onDisappear { showingScanner = false }
     }
 }

bitchat/bitchat-macOS.entitlements

@@ -10,19 +10,11 @@
 	</array>
 	<key>com.apple.security.device.bluetooth</key>
 	<true/>
-	<key>com.apple.security.device.microphone</key>
-	<true/>
 	<key>com.apple.security.personal-information.location</key>
 	<true/>
 	<key>com.apple.security.network.client</key>
 	<true/>
 	<key>com.apple.security.network.server</key>
 	<true/>
-	<key>com.apple.security.files.user-selected.read-only</key>
-	<true/>
-	<key>com.apple.security.files.user-selected.read-write</key>
-	<true/>
-	<key>com.apple.security.assets.pictures.read-only</key>
-	<true/>
 </dict>
 </plist>

bitchatTests/BLEServiceTests.swift

@@ -298,5 +298,5 @@ private final class MockBitchatDelegate: BitchatDelegate {
     func didUpdateMessageDeliveryStatus(_ messageID: String, status: DeliveryStatus) {}
     func didReceiveNoisePayload(from peerID: PeerID, type: NoisePayloadType, payload: Data, timestamp: Date) {}
     func didUpdateBluetoothState(_ state: CBManagerState) {}
-    func didReceivePublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date, messageID: String?) {}
+    func didReceivePublicMessage(from peerID: String, nickname: String, content: String, timestamp: Date) {}
 }

bitchatTests/EndToEnd/PrivateChatE2ETests.swift

@@ -186,11 +186,11 @@ struct PrivateChatE2ETests {
             // Bob relays private messages for Charlie
             bob.packetDeliveryHandler = { packet in
                 if let recipientID = packet.recipientID,
-                   PeerID(data: recipientID) == charlie.peerID {
+                   String(data: recipientID, encoding: .utf8) == charlie.peerID {
                     // Relay to Charlie
                     var relayPacket = packet
                     relayPacket.ttl = packet.ttl - 1
-                    charlie.simulateIncomingPacket(relayPacket)
+                    self.charlie.simulateIncomingPacket(relayPacket)
                 }
             }
             

bitchatTests/EndToEnd/PublicChatE2ETests.swift

@@ -388,7 +388,7 @@ struct PublicChatE2ETests {
 
             if let message = BitchatMessage(packet.payload) {
                 // Don't relay own messages
-                guard message.senderPeerID != node.peerID else { return }
+                guard message.senderPeerID?.id != node.peerID else { return }
                 
                 // Create relay message
                 let relayMessage = BitchatMessage(

bitchatTests/Fragmentation/FragmentationTests.swift

@@ -92,62 +92,6 @@ struct FragmentationTests {
         #expect(capture.publicMessages.count == 1)
         #expect(capture.publicMessages.first?.content.count == 2048)
     }
-
-    @Test("Max-sized file transfer survives reassembly")
-    func maxSizedFileTransferSurvivesReassembly() async throws {
-        let ble = BLEService(
-            keychain: mockKeychain,
-            idBridge: idBridge,
-            identityManager: mockIdentityManager
-        )
-        let capture = CaptureDelegate()
-        ble.delegate = capture
-
-        let remoteID = PeerID(str: "CAFEBABECAFEBABE")
-        let fileContent = Data(repeating: 0x42, count: FileTransferLimits.maxPayloadBytes)
-        let filePacket = BitchatFilePacket(
-            fileName: "limit.bin",
-            fileSize: UInt64(fileContent.count),
-            mimeType: "application/octet-stream",
-            content: fileContent
-        )
-        let encoded = try #require(filePacket.encode(), "File packet encoding failed")
-
-        let packet = BitchatPacket(
-            type: MessageType.fileTransfer.rawValue,
-            senderID: Data(hexString: remoteID.id) ?? Data(),
-            recipientID: nil,
-            timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
-            payload: encoded,
-            signature: nil,
-            ttl: 7,
-            version: 2
-        )
-
-        let fragments = fragmentPacket(packet, fragmentSize: 4096, pad: false)
-        #expect(!fragments.isEmpty)
-
-        for (i, fragment) in fragments.enumerated() {
-            let delay = 5 * Double(i) * 0.001
-            Task {
-                try await sleep(delay)
-                ble._test_handlePacket(fragment, fromPeerID: remoteID)
-            }
-        }
-
-        try await sleep(1.0)
-
-        let message = try #require(capture.receivedMessages.first, "Expected file transfer message")
-        #expect(message.content.hasPrefix("[file]"))
-
-        if let fileName = message.content.split(separator: " ").last {
-            let base = try FileManager.default.url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
-            let filesRoot = base.appendingPathComponent("files", isDirectory: true)
-            let incoming = filesRoot.appendingPathComponent("files/incoming", isDirectory: true)
-            let url = incoming.appendingPathComponent(String(fileName))
-            try? FileManager.default.removeItem(at: url)
-        }
-    }
     
     @Test("Invalid fragment header is ignored")
     func invalidFragmentHeaderIsIgnored() async throws {
@@ -198,10 +142,7 @@ struct FragmentationTests {
 extension FragmentationTests {
     private final class CaptureDelegate: BitchatDelegate {
         var publicMessages: [(peerID: PeerID, nickname: String, content: String)] = []
-        var receivedMessages: [BitchatMessage] = []
-        func didReceiveMessage(_ message: BitchatMessage) {
-            receivedMessages.append(message)
-        }
+        func didReceiveMessage(_ message: BitchatMessage) {}
         func didConnectToPeer(_ peerID: PeerID) {}
         func didDisconnectFromPeer(_ peerID: PeerID) {}
         func didUpdatePeerList(_ peers: [PeerID]) {}
@@ -209,7 +150,7 @@ extension FragmentationTests {
         func didUpdateMessageDeliveryStatus(_ messageID: String, status: DeliveryStatus) {}
         func didReceiveNoisePayload(from peerID: PeerID, type: NoisePayloadType, payload: Data, timestamp: Date) {}
         func didUpdateBluetoothState(_ state: CBManagerState) {}
-        func didReceivePublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date, messageID: String?) {
+        func didReceivePublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date) {
             publicMessages.append((peerID, nickname, content))
         }
         func didReceiveRegionalPublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date) {}
@@ -232,8 +173,8 @@ extension FragmentationTests {
     }
 
     // Helper: fragment a packet using the same header format BLEService expects
-    private func fragmentPacket(_ packet: BitchatPacket, fragmentSize: Int, fragmentID: Data? = nil, pad: Bool = true) -> [BitchatPacket] {
-        guard let fullData = packet.toBinaryData(padding: pad) else { return [] }
+    private func fragmentPacket(_ packet: BitchatPacket, fragmentSize: Int, fragmentID: Data? = nil) -> [BitchatPacket] {
+        let fullData = packet.toBinaryData() ?? Data()
         let fid = fragmentID ?? Data((0..<8).map { _ in UInt8.random(in: 0...255) })
         let chunks: [Data] = stride(from: 0, to: fullData.count, by: fragmentSize).map { off in
             Data(fullData[off..<min(off + fragmentSize, fullData.count)])

bitchatTests/GossipSyncManagerTests.swift

@@ -125,138 +125,16 @@ struct GossipSyncManagerTests {
         #expect(manager._hasAnnouncement(for: PeerID(str: peerHex)) == false)
         #expect(manager._messageCount(for: PeerID(str: peerHex)) == 0)
     }
-
-    @Test func maintenanceEmitsTypedSyncRequests() throws {
-        var config = GossipSyncManager.Config()
-        config.seenCapacity = 10
-        config.fragmentCapacity = 5
-        config.fileTransferCapacity = 4
-        config.messageSyncIntervalSeconds = 1
-        config.fragmentSyncIntervalSeconds = 1
-        config.fileTransferSyncIntervalSeconds = 1
-        config.maintenanceIntervalSeconds = 0
-
-        let manager = GossipSyncManager(myPeerID: myPeerID, config: config)
-        let delegate = RecordingDelegate()
-        manager.delegate = delegate
-
-        let sender = try #require(Data(hexString: "1122334455667788"))
-        let now = UInt64(Date().timeIntervalSince1970 * 1000)
-
-        let announcePacket = BitchatPacket(
-            type: MessageType.announce.rawValue,
-            senderID: sender,
-            recipientID: nil,
-            timestamp: now,
-            payload: Data(),
-            signature: nil,
-            ttl: 1
-        )
-        let messagePacket = BitchatPacket(
-            type: MessageType.message.rawValue,
-            senderID: sender,
-            recipientID: nil,
-            timestamp: now,
-            payload: Data([0x01]),
-            signature: nil,
-            ttl: 1
-        )
-        let fragmentPacket = BitchatPacket(
-            type: MessageType.fragment.rawValue,
-            senderID: sender,
-            recipientID: nil,
-            timestamp: now,
-            payload: Data([0xAA]),
-            signature: nil,
-            ttl: 1
-        )
-        let filePacket = BitchatPacket(
-            type: MessageType.fileTransfer.rawValue,
-            senderID: sender,
-            recipientID: nil,
-            timestamp: now,
-            payload: Data([0xBB]),
-            signature: nil,
-            ttl: 1,
-            version: 2
-        )
-
-        manager.onPublicPacketSeen(announcePacket)
-        manager.onPublicPacketSeen(messagePacket)
-        manager.onPublicPacketSeen(fragmentPacket)
-        manager.onPublicPacketSeen(filePacket)
-
-        manager._performMaintenanceSynchronously(now: Date())
-
-        let sentPackets = delegate.packets
-        #expect(sentPackets.count == 3)
-        let decoded = sentPackets.compactMap { RequestSyncPacket.decode(from: $0.payload) }
-        #expect(decoded.count == 3)
-        #expect(decoded[0].types == .publicMessages)
-        #expect(decoded[1].types == .fragment)
-        #expect(decoded[2].types == .fileTransfer)
-    }
-
-    @Test func handleRequestSyncHonorsTypeFilter() async throws {
-        var config = GossipSyncManager.Config()
-        config.seenCapacity = 5
-        config.fragmentCapacity = 5
-        config.fileTransferCapacity = 0
-        config.messageSyncIntervalSeconds = 0
-        config.fragmentSyncIntervalSeconds = 0
-        config.fileTransferSyncIntervalSeconds = 0
-
-        let manager = GossipSyncManager(myPeerID: myPeerID, config: config)
-        let delegate = RecordingDelegate()
-        manager.delegate = delegate
-
-        let sender = try #require(Data(hexString: "aabbccddeeff0011"))
-        let now = UInt64(Date().timeIntervalSince1970 * 1000)
-
-        let messagePacket = BitchatPacket(
-            type: MessageType.message.rawValue,
-            senderID: sender,
-            recipientID: nil,
-            timestamp: now,
-            payload: Data([0x10]),
-            signature: nil,
-            ttl: 1
-        )
-
-        let fragmentPacket = BitchatPacket(
-            type: MessageType.fragment.rawValue,
-            senderID: sender,
-            recipientID: nil,
-            timestamp: now,
-            payload: Data([0x20]),
-            signature: nil,
-            ttl: 1
-        )
-
-        manager.onPublicPacketSeen(messagePacket)
-        manager.onPublicPacketSeen(fragmentPacket)
-
-        let peer = PeerID(str: "FFFFFFFFFFFFFFFF")
-        let request = RequestSyncPacket(p: 4, m: 1, data: Data(), types: .fragment)
-        manager.handleRequestSync(from: peer, request: request)
-
-        try await sleep(0.01)
-        let sentPackets = delegate.packets
-        #expect(sentPackets.count == 1)
-        #expect(sentPackets[0].type == MessageType.fragment.rawValue)
-    }
 }
 
 private final class RecordingDelegate: GossipSyncManager.Delegate {
     var onSend: (() -> Void)?
     private(set) var lastPacket: BitchatPacket?
-    private(set) var packets: [BitchatPacket] = []
     private let lock = NSLock()
 
     func sendPacket(_ packet: BitchatPacket) {
         lock.lock()
         lastPacket = packet
-        packets.append(packet)
         lock.unlock()
         onSend?()
     }

bitchatTests/InputValidatorTests.swift

@@ -1,192 +0,0 @@
-//
-// InputValidatorTests.swift
-// bitchatTests
-//
-// This is free and unencumbered software released into the public domain.
-// For more information, see <https://unlicense.org>
-//
-
-import Testing
-import Foundation
-@testable import bitchat
-
-struct InputValidatorTests {
-
-    // MARK: - Basic Validation Tests
-
-    @Test func validStringPassesValidation() throws {
-        let result = InputValidator.validateUserString("Hello World", maxLength: 100)
-        #expect(result == "Hello World")
-    }
-
-    @Test func emptyStringReturnsNil() throws {
-        let result = InputValidator.validateUserString("", maxLength: 100)
-        #expect(result == nil)
-    }
-
-    @Test func whitespaceOnlyStringReturnsNil() throws {
-        let result = InputValidator.validateUserString("   \n\t  ", maxLength: 100)
-        #expect(result == nil)
-    }
-
-    @Test func stringExceedingMaxLengthReturnsNil() throws {
-        let longString = String(repeating: "a", count: 101)
-        let result = InputValidator.validateUserString(longString, maxLength: 100)
-        #expect(result == nil)
-    }
-
-    @Test func stringAtMaxLengthIsAccepted() throws {
-        let exactString = String(repeating: "a", count: 100)
-        let result = InputValidator.validateUserString(exactString, maxLength: 100)
-        #expect(result == exactString)
-    }
-
-    @Test func whitespaceIsTrimmed() throws {
-        let result = InputValidator.validateUserString("  Hello  ", maxLength: 100)
-        #expect(result == "Hello")
-    }
-
-    // MARK: - Control Character Tests
-
-    @Test func nullCharacterIsRejected() throws {
-        let stringWithNull = "Hello\u{0000}World"
-        let result = InputValidator.validateUserString(stringWithNull, maxLength: 100)
-        #expect(result == nil)
-    }
-
-    @Test func bellCharacterIsRejected() throws {
-        let stringWithBell = "Hello\u{0007}World"
-        let result = InputValidator.validateUserString(stringWithBell, maxLength: 100)
-        #expect(result == nil)
-    }
-
-    @Test func backspaceCharacterIsRejected() throws {
-        let stringWithBackspace = "Hello\u{0008}World"
-        let result = InputValidator.validateUserString(stringWithBackspace, maxLength: 100)
-        #expect(result == nil)
-    }
-
-    @Test func escapeCharacterIsRejected() throws {
-        let stringWithEscape = "Hello\u{001B}World"
-        let result = InputValidator.validateUserString(stringWithEscape, maxLength: 100)
-        #expect(result == nil)
-    }
-
-    @Test func deleteCharacterIsRejected() throws {
-        let stringWithDelete = "Hello\u{007F}World"
-        let result = InputValidator.validateUserString(stringWithDelete, maxLength: 100)
-        #expect(result == nil)
-    }
-
-    @Test func multipleControlCharactersAreRejected() throws {
-        let stringWithMultiple = "Hello\u{0000}\u{0007}\u{001B}World"
-        let result = InputValidator.validateUserString(stringWithMultiple, maxLength: 100)
-        #expect(result == nil)
-    }
-
-    // MARK: - Unicode and Special Character Tests
-
-    @Test func emojiIsAccepted() throws {
-        let result = InputValidator.validateUserString("Hello 👋 World", maxLength: 100)
-        #expect(result == "Hello 👋 World")
-    }
-
-    @Test func unicodeCharactersAreAccepted() throws {
-        let result = InputValidator.validateUserString("Hello 世界 مرحبا", maxLength: 100)
-        #expect(result == "Hello 世界 مرحبا")
-    }
-
-    @Test func specialCharactersAreAccepted() throws {
-        let result = InputValidator.validateUserString("Hello!@#$%^&*()_+-=[]{}|;':\",./<>?", maxLength: 100)
-        #expect(result == "Hello!@#$%^&*()_+-=[]{}|;':\",./<>?")
-    }
-
-    // MARK: - Nickname Validation Tests
-
-    @Test func validNicknameIsAccepted() throws {
-        let result = InputValidator.validateNickname("Alice")
-        #expect(result == "Alice")
-    }
-
-    @Test func nicknameWithEmojiIsAccepted() throws {
-        let result = InputValidator.validateNickname("Alice 🚀")
-        #expect(result == "Alice 🚀")
-    }
-
-    @Test func nicknameTooLongIsRejected() throws {
-        let longNickname = String(repeating: "a", count: 51)
-        let result = InputValidator.validateNickname(longNickname)
-        #expect(result == nil)
-    }
-
-    @Test func nicknameAtMaxLengthIsAccepted() throws {
-        let exactNickname = String(repeating: "a", count: 50)
-        let result = InputValidator.validateNickname(exactNickname)
-        #expect(result == exactNickname)
-    }
-
-    @Test func nicknameWithControlCharacterIsRejected() throws {
-        let result = InputValidator.validateNickname("Alice\u{0000}")
-        #expect(result == nil)
-    }
-
-    // MARK: - Timestamp Validation Tests
-
-    @Test func currentTimestampIsValid() throws {
-        let now = Date()
-        let result = InputValidator.validateTimestamp(now)
-        #expect(result == true)
-    }
-
-    @Test func timestampWithinOneHourIsValid() throws {
-        let thirtyMinutesAgo = Date().addingTimeInterval(-30 * 60)
-        let result = InputValidator.validateTimestamp(thirtyMinutesAgo)
-        #expect(result == true)
-    }
-
-    @Test func timestampTwoHoursAgoIsInvalid() throws {
-        let twoHoursAgo = Date().addingTimeInterval(-2 * 3600)
-        let result = InputValidator.validateTimestamp(twoHoursAgo)
-        #expect(result == false)
-    }
-
-    @Test func timestampTwoHoursInFutureIsInvalid() throws {
-        let twoHoursFromNow = Date().addingTimeInterval(2 * 3600)
-        let result = InputValidator.validateTimestamp(twoHoursFromNow)
-        #expect(result == false)
-    }
-
-    @Test func timestampAtOneHourBoundaryIsValid() throws {
-        // Just slightly within the one-hour window
-        let almostOneHourAgo = Date().addingTimeInterval(-3599)
-        let result = InputValidator.validateTimestamp(almostOneHourAgo)
-        #expect(result == true)
-    }
-
-    // MARK: - Edge Cases
-
-    @Test func singleCharacterStringIsAccepted() throws {
-        let result = InputValidator.validateUserString("a", maxLength: 100)
-        #expect(result == "a")
-    }
-
-    @Test func stringWithOnlyNewlinesIsRejected() throws {
-        let result = InputValidator.validateUserString("\n\n\n", maxLength: 100)
-        #expect(result == nil)
-    }
-
-    @Test func stringWithMixedWhitespaceIsTrimmed() throws {
-        let result = InputValidator.validateUserString(" \t\nHello\n\t ", maxLength: 100)
-        #expect(result == "Hello")
-    }
-
-    @Test func stringWithLeadingControlCharacterIsRejected() throws {
-        let result = InputValidator.validateUserString("\u{0000}Hello", maxLength: 100)
-        #expect(result == nil)
-    }
-
-    @Test func stringWithTrailingControlCharacterIsRejected() throws {
-        let result = InputValidator.validateUserString("Hello\u{0000}", maxLength: 100)
-        #expect(result == nil)
-    }
-}

bitchatTests/LocationNotesManagerTests.swift

@@ -91,3 +91,61 @@ struct LocationNotesManagerTests {
         case shouldNotDerive
     }
 }
+
+@MainActor
+struct LocationNotesCounterTests {
+    @Test func subscribeWithoutRelaysMarksUnavailable() {
+        var subscribeCalled = false
+        let deps = LocationNotesCounterDependencies(
+            relayLookup: { _, _ in [] },
+            subscribe: { _, _, _, _, _ in subscribeCalled = true },
+            unsubscribe: { _ in }
+        )
+
+        let counter = LocationNotesCounter(testDependencies: deps)
+        counter.subscribe(geohash: "u4pruydq")
+
+        #expect(!subscribeCalled)
+        #expect(!counter.relayAvailable)
+        #expect(counter.initialLoadComplete)
+        #expect(counter.count == 0)
+    }
+
+    @Test func subscribeCountsUniqueNotes() {
+        var storedHandler: ((NostrEvent) -> Void)?
+        var storedEOSE: (() -> Void)?
+        let deps = LocationNotesCounterDependencies(
+            relayLookup: { _, _ in ["wss://relay.geo"] },
+            subscribe: { filter, id, relays, handler, eose in
+                #expect(relays == ["wss://relay.geo"])
+                #expect(filter.kinds == [1])
+                #expect(!id.isEmpty)
+                storedHandler = handler
+                storedEOSE = eose
+            },
+            unsubscribe: { _ in }
+        )
+
+        let counter = LocationNotesCounter(testDependencies: deps)
+        counter.subscribe(geohash: "u4pruydq")
+
+        var first = NostrEvent(
+            pubkey: "pub",
+            createdAt: Date(),
+            kind: .textNote,
+            tags: [["g", "u4pruydq"]],
+            content: "a"
+        )
+        first.id = "eventA"
+        storedHandler?(first)
+
+        let duplicate = first
+        storedHandler?(duplicate)
+
+        storedEOSE?()
+
+        #expect(counter.relayAvailable)
+        #expect(counter.count == 1)
+        #expect(counter.initialLoadComplete)
+    }
+}

bitchatTests/MimeTypeTests.swift

@@ -1,90 +0,0 @@
-//
-// MimeTypeTests.swift
-// bitchatTests
-//
-// This is free and unencumbered software released into the public domain.
-// For more information, see <https://unlicense.org>
-//
-
-import Testing
-import Foundation
-@testable import bitchat
-
-// MARK: - MimeType Mapping and Signature Tests
-
-struct MimeTypeTests {
-
-    // MARK: MIME → Enum Parsing + Default Extension
-    @Test(arguments: [
-        ("image/jpeg", MimeType.jpeg, "jpg"),
-        ("image/jpg", MimeType.jpeg, "jpg"),
-        ("image/png", MimeType.png, "png"),
-        ("image/gif", MimeType.gif, "gif"),
-        ("image/webp", MimeType.webp, "webp"),
-        ("audio/mp4", MimeType.mp4Audio, "m4a"),
-        ("audio/m4a", MimeType.m4a, "m4a"),
-        ("audio/aac", MimeType.aac, "m4a"),
-        ("audio/mpeg", MimeType.mpeg, "mp3"),
-        ("audio/mp3", MimeType.mp3, "mp3"),
-        ("audio/wav", MimeType.wav, "wav"),
-        ("audio/x-wav", MimeType.xWav, "wav"),
-        ("audio/ogg", MimeType.ogg, "ogg"),
-        ("application/pdf", MimeType.pdf, "pdf"),
-        ("application/octet-stream", MimeType.octetStream, "bin")
-    ])
-    func mimeTypeParsingAndExtensions(
-        mimeString: String,
-        expectedType: MimeType,
-        expectedExt: String
-    ) throws {
-        guard let mime = MimeType(mimeString) else {
-            Issue.record("Failed to parse \(mimeString)")
-            return
-        }
-
-        #expect(mime == expectedType, "Expected \(expectedType) for \(mimeString)")
-        #expect(mime.mimeString == expectedType.mimeString)
-        #expect(mime.defaultExtension == expectedExt)
-        #expect(mime.isAllowed)
-    }
-
-    // MARK: - File Signature Validation
-    @Test(arguments: [
-        // === Image types ===
-        (MimeType.jpeg, [0xFF, 0xD8, 0xFF]),
-        (MimeType.png,  [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]),
-        (MimeType.gif,  [0x47, 0x49, 0x46, 0x38, 0x39, 0x61]), // "GIF89a"
-        (MimeType.webp, [0x52, 0x49, 0x46, 0x46, 0x00, 0x00, 0x00, 0x00,
-                         0x57, 0x45, 0x42, 0x50]),             // "RIFF....WEBP"
-
-        // === Audio types ===
-        (MimeType.mp3,  [0x49, 0x44, 0x33]),                   // "ID3"
-        (MimeType.wav,  [0x52, 0x49, 0x46, 0x46, 0x00, 0x00, 0x00, 0x00,
-                         0x57, 0x41, 0x56, 0x45]),             // "RIFF....WAVE"
-        (MimeType.ogg,  [0x4F, 0x67, 0x67, 0x53]),             // "OggS"
-
-        // === Application types ===
-        (MimeType.pdf,  [0x25, 0x50, 0x44, 0x46])              // "%PDF"
-    ])
-    func validSignatures(mime: MimeType, bytes: [UInt8]) throws {
-        let data = Data(bytes)
-        #expect(mime.matches(data: data),
-                "Expected \(mime.mimeString) to match its signature")
-    }
-
-    // MARK: - Negative Tests
-    @Test func invalidDataDoesNotMatch() throws {
-        let badData = Data(repeating: 0x00, count: 16)
-        for mime in MimeType.allCases where mime != .octetStream {
-            #expect(!mime.matches(data: badData),
-                    "Unexpectedly matched \(mime.mimeString) with zeroed data")
-        }
-    }
-
-    // MARK: - Octet-stream (generic binary)
-    @Test func octetStreamAlwaysMatches() throws {
-        let randomData = Data([0x00, 0x11, 0x22, 0x33])
-        #expect(MimeType.octetStream.matches(data: randomData),
-                "application/octet-stream should always be considered valid")
-    }
-}

bitchatTests/Mocks/MockBLEService.swift

@@ -153,15 +153,7 @@ final class MockBLEService: NSObject {
             }
         }
     }
-
-    func sendFileBroadcast(_ packet: BitchatFilePacket, transferId: String) {
-        // Tests currently ignore file transfer flows; keep stub for protocol conformance.
-    }
-
-    func sendFilePrivate(_ packet: BitchatFilePacket, to peerID: PeerID, transferId: String) {
-        // Tests currently ignore file transfer flows; keep stub for protocol conformance.
-    }
-
+    
     func sendPrivateMessage(_ content: String, to recipientPeerID: PeerID, recipientNickname: String, messageID: String) {
         let message = BitchatMessage(
             id: messageID,
@@ -203,7 +195,10 @@ final class MockBLEService: NSObject {
                let target = bus.service(for: recipientPeerID) {
                 target.simulateIncomingPacket(packet)
             } else {
-                // Not directly connected: deliver to neighbors for relay
+                // Not directly connected: deliver to neighbors for relay; also deliver directly if target is known
+                if let target = bus.service(for: recipientPeerID) {
+                    target.simulateIncomingPacket(packet)
+                }
                 for neighbor in neighbors() where neighbor.peerID != recipientPeerID {
                     neighbor.simulateIncomingPacket(packet)
                 }

bitchatTests/NostrProtocolTests.swift

@@ -126,7 +126,7 @@ struct NostrProtocolTests {
 
         // Build a DELIVERED ack embedded payload (geohash-style, no recipient peer ID)
         let messageID = "TEST-MSG-DELIVERED-1"
-        let senderPeerID = PeerID(str: "0123456789abcdef") // 8-byte hex peer ID
+        let senderPeerID = "0123456789abcdef" // 8-byte hex peer ID
 
         let embedded = try #require(
             NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(type: .delivered, messageID: messageID, senderPeerID: senderPeerID),
@@ -176,7 +176,7 @@ struct NostrProtocolTests {
         let recipient = try NostrIdentity.generate()
         
         let messageID = "TEST-MSG-READ-1"
-        let senderPeerID = PeerID(str: "fedcba9876543210") // 8-byte hex peer ID
+        let senderPeerID = "fedcba9876543210" // 8-byte hex peer ID
         let embedded = try #require(
             NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(type: .readReceipt, messageID: messageID, senderPeerID: senderPeerID),
             "Failed to embed read ack"

bitchatTests/NotificationStreamAssemblerTests.swift

@@ -95,57 +95,4 @@ struct NotificationStreamAssemblerTests {
         let decoded = try #require(BinaryProtocol.decode(result.frames[0]), "Failed to decode frame after drop")
         #expect(decoded.timestamp == packet.timestamp)
     }
-
-    func testAssemblesCompressedLargeFrame() throws {
-        var assembler = NotificationStreamAssembler()
-
-        // Keep the fixture below FileTransferLimits.maxPayloadBytes so encoding succeeds while still exercising compression.
-        let largeContent = Data(repeating: 0x41, count: 600_000)
-        let filePacket = BitchatFilePacket(
-            fileName: "large.bin",
-            fileSize: UInt64(largeContent.count),
-            mimeType: "application/octet-stream",
-            content: largeContent
-        )
-        let tlvPayload = try #require(filePacket.encode(), "Failed to encode file packet")
-
-        let senderID = Data(repeating: 0xAA, count: BinaryProtocol.senderIDSize)
-        let packet = BitchatPacket(
-            type: MessageType.fileTransfer.rawValue,
-            senderID: senderID,
-            recipientID: nil,
-            timestamp: 0x010203040506,
-            payload: tlvPayload,
-            signature: nil,
-            ttl: 3,
-            version: 2
-        )
-
-        let frame = try #require(packet.toBinaryData(padding: false), "Failed to encode packet frame")
-
-        #expect(BinaryProtocol.Offsets.flags < frame.count)
-        let flags = frame[frame.startIndex + BinaryProtocol.Offsets.flags]
-        #expect((flags & BinaryProtocol.Flags.isCompressed) != 0, "Frame should be compressed for large payloads")
-
-        let splitIndex = min(4096, frame.count / 2)
-        var result = assembler.append(frame.prefix(splitIndex))
-        #expect(result.frames.isEmpty)
-
-        result = assembler.append(frame.suffix(from: splitIndex))
-        #expect(result.frames.count == 1)
-        #expect(result.droppedPrefixes.isEmpty)
-        #expect(result.reset == false)
-
-        let assembled = try #require(result.frames.first, "Missing assembled frame")
-        #expect(assembled.count == frame.count)
-
-        let decodedPacket = try #require(BinaryProtocol.decode(assembled), "Failed to decode compressed frame")
-        #expect(decodedPacket.payload.count == tlvPayload.count)
-
-        let decodedFile = try #require(BitchatFilePacket.decode(decodedPacket.payload), "Failed to decode TLV payload")
-        #expect(decodedFile.fileName == filePacket.fileName)
-        #expect(decodedFile.mimeType == filePacket.mimeType)
-        #expect(decodedFile.content.count == largeContent.count)
-        #expect(decodedFile.content.prefix(32) == largeContent.prefix(32))
-    }
 }

bitchatTests/Protocol/BinaryProtocolTests.swift

@@ -54,86 +54,6 @@ struct BinaryProtocolTests {
         #expect(decodedPacket.signature != nil)
         #expect(decodedPacket.signature == TestConstants.testSignature)
     }
-
-    @Test func packetWithRouteRoundTrip() throws {
-        let route: [Data] = [
-            try #require(Data(hexString: "0102030405060708")),
-            try #require(Data(hexString: "1112131415161718")),
-            try #require(Data(hexString: "2122232425262728"))
-        ]
-
-        var packet = BitchatPacket(
-            type: 0x01,
-            senderID: route[0],
-            recipientID: route.last,
-            timestamp: 1_720_000_000_000,
-            payload: Data("route-test".utf8),
-            signature: nil,
-            ttl: 6
-        )
-        packet.route = route
-
-        let encoded = try #require(BinaryProtocol.encode(packet), "Failed to encode packet with route")
-        let flagsByte = encoded[BinaryProtocol.Offsets.flags]
-        #expect((flagsByte & BinaryProtocol.Flags.hasRoute) != 0)
-
-        let decoded = try #require(BinaryProtocol.decode(encoded), "Failed to decode packet with route")
-        let decodedRoute = try #require(decoded.route)
-        #expect(decodedRoute.count == route.count)
-        for (expected, actual) in zip(route, decodedRoute) {
-            #expect(actual == expected)
-        }
-    }
-
-    @Test func packetWithRoutePadsShortHop() throws {
-        let sender = try #require(Data(hexString: "0011223344556677"))
-        let destination = try #require(Data(hexString: "8899aabbccddeeff"))
-        let shortHop = Data([0xAA, 0xBB, 0xCC])
-
-        var packet = BitchatPacket(
-            type: 0x02,
-            senderID: sender,
-            recipientID: destination,
-            timestamp: 1_730_000_000_000,
-            payload: Data("pad-test".utf8),
-            signature: nil,
-            ttl: 5
-        )
-        packet.route = [shortHop, destination]
-
-        let encoded = try #require(BinaryProtocol.encode(packet), "Failed to encode packet with short hop route")
-        let decoded = try #require(BinaryProtocol.decode(encoded), "Failed to decode packet with short hop route")
-        let decodedRoute = try #require(decoded.route)
-        let firstHop = try #require(decodedRoute.first)
-        #expect(firstHop.count == BinaryProtocol.senderIDSize)
-        #expect(firstHop.prefix(shortHop.count) == shortHop)
-        let paddingBytes = firstHop.suffix(firstHop.count - shortHop.count)
-        #expect(paddingBytes.allSatisfy { $0 == 0 })
-    }
-
-    @Test func packetWithRouteAndCompressedPayload() throws {
-        let route: [Data] = [
-            try #require(Data(hexString: "0101010101010101")),
-            try #require(Data(hexString: "0202020202020202"))
-        ]
-        let repeatedString = String(repeating: "compress-me", count: 150)
-        var packet = BitchatPacket(
-            type: 0x03,
-            senderID: route[0],
-            recipientID: route.last,
-            timestamp: 1_740_000_000_000,
-            payload: Data(repeatedString.utf8),
-            signature: nil,
-            ttl: 7
-        )
-        packet.route = route
-
-        let encoded = try #require(BinaryProtocol.encode(packet), "Failed to encode packet with route and compression")
-        let decoded = try #require(BinaryProtocol.decode(encoded), "Failed to decode packet with route and compression")
-        #expect(decoded.payload == Data(repeatedString.utf8))
-        let decodedRoute = try #require(decoded.route)
-        #expect(decodedRoute == route)
-    }
     
     // MARK: - Compression Tests
     
@@ -148,9 +68,8 @@ struct BinaryProtocolTests {
         let encodedData = try #require(BinaryProtocol.encode(packet), "Failed to encode packet with large payload")
         
         // The encoded size should be smaller than uncompressed due to compression
-        let headerSize = try #require(BinaryProtocol.headerSize(for: packet.version), "Invalid packet version")
-        let uncompressedSize = headerSize + BinaryProtocol.senderIDSize + largePayload.count
-        #expect(encodedData.count < uncompressedSize, "Compressed packet should be smaller than uncompressed form")
+        let uncompressedSize = BinaryProtocol.headerSize + BinaryProtocol.senderIDSize + largePayload.count
+        #expect(encodedData.count < uncompressedSize)
         
         // Decode and verify
         let decodedPacket = try #require(BinaryProtocol.decode(encodedData), "Failed to decode compressed packet")

bitchatTests/Protocols/BitchatFilePacketTests.swift

@@ -1,47 +0,0 @@
-import XCTest
-@testable import bitchat
-
-final class BitchatFilePacketTests: XCTestCase {
-
-    func testRoundTripPreservesFields() throws {
-        let content = Data((0..<4096).map { UInt8($0 % 251) })
-        let packet = BitchatFilePacket(
-            fileName: "sample.jpg",
-            fileSize: UInt64(content.count),
-            mimeType: "image/jpeg",
-            content: content
-        )
-
-        guard let encoded = packet.encode() else {
-            return XCTFail("Failed to encode file packet")
-        }
-        guard let decoded = BitchatFilePacket.decode(encoded) else {
-            return XCTFail("Failed to decode file packet")
-        }
-
-        XCTAssertEqual(decoded.fileName, packet.fileName)
-        XCTAssertEqual(decoded.fileSize, packet.fileSize)
-        XCTAssertEqual(decoded.mimeType, packet.mimeType)
-        XCTAssertEqual(decoded.content, packet.content)
-    }
-
-    func testDecodeFallsBackToContentSizeWhenFileSizeMissing() throws {
-        let content = Data(repeating: 0x7F, count: 1024)
-        let packet = BitchatFilePacket(
-            fileName: nil,
-            fileSize: nil,
-            mimeType: nil,
-            content: content
-        )
-
-        guard let encoded = packet.encode() else {
-            return XCTFail("Failed to encode file packet")
-        }
-        guard let decoded = BitchatFilePacket.decode(encoded) else {
-            return XCTFail("Failed to decode file packet")
-        }
-
-        XCTAssertEqual(decoded.fileSize, UInt64(content.count))
-        XCTAssertEqual(decoded.content, content)
-    }
-}

bitchatTests/Services/MeshTopologyTrackerTests.swift

@@ -1,86 +0,0 @@
-//
-// MeshTopologyTrackerTests.swift
-// bitchatTests
-//
-// This is free and unencumbered software released into the public domain.
-// For more information, see <https://unlicense.org>
-//
-
-import Testing
-import Foundation
-@testable import bitchat
-
-struct MeshTopologyTrackerTests {
-    private func hex(_ value: String) throws -> Data {
-        try #require(Data(hexString: value))
-    }
-
-    @Test func directLinkProducesRoute() throws {
-        let tracker = MeshTopologyTracker()
-        let a = try hex("0102030405060708")
-        let b = try hex("1112131415161718")
-
-        tracker.recordDirectLink(between: a, and: b)
-        let route = try #require(tracker.computeRoute(from: a, to: b))
-        #expect(route == [a, b])
-    }
-
-    @Test func multiHopRouteComputation() throws {
-        let tracker = MeshTopologyTracker()
-        let a = try hex("0001020304050607")
-        let b = try hex("1011121314151617")
-        let c = try hex("2021222324252627")
-        let d = try hex("3031323334353637")
-
-        tracker.recordDirectLink(between: a, and: b)
-        tracker.recordDirectLink(between: b, and: c)
-        tracker.recordDirectLink(between: c, and: d)
-
-        let route = try #require(tracker.computeRoute(from: a, to: d))
-        #expect(route == [a, b, c, d])
-    }
-
-    @Test func recordRouteAddsEdges() throws {
-        let tracker = MeshTopologyTracker()
-        var a = Data([0xAA, 0xBB, 0xCC])
-        let b = try hex("4445464748494A4B")
-        let c = try hex("5455565758595A5B")
-
-        tracker.recordRoute([a, b, c])
-
-        a.append(Data(repeating: 0, count: BinaryProtocol.senderIDSize - a.count))
-        let route = try #require(tracker.computeRoute(from: a, to: c))
-        #expect(route.first == a)
-        #expect(route.last == c)
-    }
-
-    @Test func removingDirectLinkBreaksRoute() throws {
-        let tracker = MeshTopologyTracker()
-        let a = try hex("0101010101010101")
-        let b = try hex("0202020202020202")
-        let c = try hex("0303030303030303")
-
-        tracker.recordDirectLink(between: a, and: b)
-        tracker.recordDirectLink(between: b, and: c)
-        let initialRoute = try #require(tracker.computeRoute(from: a, to: c))
-        #expect(initialRoute == [a, b, c])
-
-        tracker.removeDirectLink(between: b, and: c)
-        #expect(tracker.computeRoute(from: a, to: c) == nil)
-    }
-
-    @Test func removingPeerClearsEdges() throws {
-        let tracker = MeshTopologyTracker()
-        let a = try hex("0F0E0D0C0B0A0908")
-        let b = try hex("0A0B0C0D0E0F0001")
-        let c = try hex("0011223344556677")
-
-        tracker.recordRoute([a, b, c])
-        let initialRoute = try #require(tracker.computeRoute(from: a, to: c))
-        #expect(initialRoute == [a, b, c])
-
-        tracker.removePeer(b)
-        #expect(tracker.computeRoute(from: a, to: c) == nil)
-    }
-
-}

bitchatTests/Utils/PeerIDTests.swift

@@ -217,27 +217,7 @@ struct PeerIDTests {
         let short = peerID.toShort()
         #expect(short == peerID)
     }
-
-    @Test func routingData_fromShortID() throws {
-        let peerID = PeerID(str: hex16)
-        let routing = try #require(peerID.routingData)
-        #expect(routing.count == 8)
-        #expect(routing == Data(hexString: hex16))
-    }
-
-    @Test func routingData_fromNoiseKey() throws {
-        let peerID = PeerID(str: hex64)
-        let routing = try #require(peerID.routingData)
-        let expectedShort = peerID.toShort()
-        #expect(routing == Data(hexString: expectedShort.id))
-    }
-
-    @Test func routingPeerRoundTrip() throws {
-        let raw = try #require(Data(hexString: hex16))
-        let peerID = try #require(PeerID(routingData: raw))
-        #expect(peerID.routingData == raw)
-    }
-
+    
     // MARK: - Codable
 
     @Test func codable_emptyPrefix() throws {
@@ -293,7 +273,7 @@ struct PeerIDTests {
     @Test func comparable_sorting_and_equality() {
         let p1 = PeerID(str: "aaa")
         let p2 = PeerID(str: "bbb")
-        let p3 = PeerID(str: "BBB")
+        let p3 = PeerID(str: "bbb")
         
         #expect(p1 < p2)
         #expect(p2 >= p1)
@@ -304,18 +284,44 @@ struct PeerIDTests {
     }
     
     @Test func equality() {
-        let peerID = PeerID(str: "aaa")
+        let string = "aaa"
+        let peerID = PeerID(str: string)
+        let badString = "bbb"
+        
+        // PeerID == String
+        #expect(peerID == string)
+        #expect(peerID == Optional(string))
+        #expect(Optional(peerID) == string)
+        #expect(Optional(peerID) == Optional(string))
+
+        // PeerID != String
+        #expect(peerID != badString)
+        #expect(peerID != Optional(badString))
+        #expect(Optional(peerID) != badString)
+        #expect(Optional(peerID) != Optional(badString))
+        
+        // String == PeerID
+        #expect(string == peerID)
+        #expect(Optional(string) == peerID)
+        #expect(string == Optional(peerID))
+        #expect(Optional(string) == Optional(peerID))
+
+        // String != PeerID
+        #expect(badString != peerID)
+        #expect(Optional(badString) != peerID)
+        #expect(badString != Optional(peerID))
+        #expect(Optional(badString) != Optional(peerID))
         
         // Regular PeerID <> PeerID
-        #expect(peerID == PeerID(str: "AAA"))
-        #expect(peerID == Optional(PeerID(str: "AAA")))
-        #expect(PeerID(str: "AAA") == peerID)
-        #expect(Optional(PeerID(str: "AAA")) == Optional(peerID))
+        #expect(peerID == PeerID(str: "aaa"))
+        #expect(peerID == Optional(PeerID(str: "aaa")))
+        #expect(PeerID(str: "aaa") == peerID)
+        #expect(Optional(PeerID(str: "aaa")) == Optional(peerID))
         
-        #expect(peerID != PeerID(str: "BBB"))
-        #expect(peerID != Optional(PeerID(str: "BBB")))
-        #expect(PeerID(str: "BBB") != peerID)
-        #expect(Optional(PeerID(str: "BBB")) != Optional(peerID))
+        #expect(peerID != PeerID(str: "bbb"))
+        #expect(peerID != Optional(PeerID(str: "bbb")))
+        #expect(PeerID(str: "bbb") != peerID)
+        #expect(Optional(PeerID(str: "bbb")) != Optional(peerID))
     }
     
     // MARK: - Computed properties

localPackages/BitLogger/Package.swift

@@ -18,10 +18,6 @@ let package = Package(
         .target(
             name: "BitLogger",
             path: "Sources"
-        ),
-        .testTarget(
-            name: "BitLoggerTests",
-            dependencies: ["BitLogger"]
         )
     ]
 )

localPackages/BitLogger/Sources/OSLog+Categories.swift

@@ -6,13 +6,11 @@
 // For more information, see <https://unlicense.org>
 //
 
-#if canImport(os.log)
 import os.log
-#endif
 
 public extension OSLog {
     private static let subsystem = "chat.bitchat"
-
+    
     static let noise        = OSLog(subsystem: subsystem, category: "noise")
     static let encryption   = OSLog(subsystem: subsystem, category: "encryption")
     static let keychain     = OSLog(subsystem: subsystem, category: "keychain")

localPackages/BitLogger/Sources/SecureLogger.swift

@@ -7,53 +7,7 @@
 //
 
 import Foundation
-#if canImport(os.log)
 import os.log
-#else
-public struct OSLog {
-    public let subsystem: String
-    public let category: String
-
-    public init(subsystem: String, category: String) {
-        self.subsystem = subsystem
-        self.category = category
-    }
-}
-
-public struct OSLogType: CustomStringConvertible {
-    private let label: String
-
-    private init(_ label: String) {
-        self.label = label
-    }
-
-    public var description: String { label }
-
-    public static let debug = OSLogType("debug")
-    public static let info = OSLogType("info")
-    public static let `default` = OSLogType("default")
-    public static let error = OSLogType("error")
-    public static let fault = OSLogType("fault")
-}
-
-@usableFromInline
-let secureLoggerFallbackFormatter: ISO8601DateFormatter = {
-    let formatter = ISO8601DateFormatter()
-    formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
-    return formatter
-}()
-
-@usableFromInline
-func os_log(_ message: StaticString, log: OSLog, type: OSLogType, _ args: CVarArg...) {
-    let rawFormat = String(describing: message)
-    let format = rawFormat
-        .replacingOccurrences(of: "%{public}@", with: "%@")
-        .replacingOccurrences(of: "%{private}@", with: "%@")
-    let formatted = String(format: format, arguments: args)
-    let timestamp = secureLoggerFallbackFormatter.string(from: Date())
-    print("[\(timestamp)] [\(log.subsystem)::\(log.category)] [\(type.description)] \(formatted)")
-}
-#endif
 
 /// Centralized security-aware logging framework
 /// Provides safe logging that filters sensitive data and security events
@@ -68,6 +22,22 @@ public final class SecureLogger {
         return formatter
     }()
     
+    // MARK: - Cached Regex Patterns
+    
+    private static let fingerprintPattern = #/[a-fA-F0-9]{64}/#
+    private static let base64Pattern = #/[A-Za-z0-9+/]{40,}={0,2}/#
+    private static let passwordPattern = #/password["\s:=]+["']?[^"'\s]+["']?/#
+    private static let peerIDPattern = #/peerID: ([a-zA-Z0-9]{8})[a-zA-Z0-9]+/#
+    
+    // MARK: - Sanitization Cache
+    
+    private static let sanitizationCache: NSCache<NSString, NSString> = {
+        let cache = NSCache<NSString, NSString>()
+        cache.countLimit = 100 // Keep last 100 sanitized strings
+        return cache
+    }()
+    private static let cacheQueue = DispatchQueue(label: "chat.bitchat.securelogger.cache", attributes: .concurrent)
+    
     // MARK: - Log Levels
     
     enum LogLevel {
@@ -145,8 +115,8 @@ public extension SecureLogger {
     static func error(_ error: Error, context: @autoclosure () -> String, category: OSLog = .noise,
                       file: String = #file, line: Int = #line, function: String = #function) {
         let location = formatLocation(file: file, line: line, function: function)
-        let sanitized = context().sanitized()
-        let errorDesc = error.localizedDescription.sanitized()
+        let sanitized = sanitize(context())
+        let errorDesc = sanitize(error.localizedDescription)
         
         #if DEBUG
         os_log("%{public}@ Error in %{public}@: %{public}@", log: category, type: .error, location, sanitized, errorDesc)
@@ -170,15 +140,15 @@ public extension SecureLogger {
         var message: String {
             switch self {
             case .handshakeStarted(let peerID):
-                return "Handshake started with peer: \(peerID.sanitized())"
+                return "Handshake started with peer: \(sanitize(peerID))"
             case .handshakeCompleted(let peerID):
-                return "Handshake completed with peer: \(peerID.sanitized())"
+                return "Handshake completed with peer: \(sanitize(peerID))"
             case .handshakeFailed(let peerID, let error):
-                return "Handshake failed with peer: \(peerID.sanitized()), error: \(error)"
+                return "Handshake failed with peer: \(sanitize(peerID)), error: \(error)"
             case .sessionExpired(let peerID):
-                return "Session expired for peer: \(peerID.sanitized())"
+                return "Session expired for peer: \(sanitize(peerID))"
             case .authenticationFailed(let peerID):
-                return "Authentication failed for peer: \(peerID.sanitized())"
+                return "Authentication failed for peer: \(sanitize(peerID))"
             }
         }
     }
@@ -233,7 +203,7 @@ private extension SecureLogger {
                     file: String, line: Int, function: String) {
         guard shouldLog(level) else { return }
         let location = formatLocation(file: file, line: line, function: function)
-        let sanitized = "\(location) \(message())".sanitized()
+        let sanitized = sanitize("\(location) \(message())")
         
         #if DEBUG
         os_log("%{public}@", log: category, type: level.osLogType, sanitized)
@@ -266,6 +236,58 @@ private extension SecureLogger {
         let timestamp = timestampFormatter.string(from: Date())
         return "[\(timestamp)] [\(fileName):\(line) \(function)]"
     }
+    
+    /// Sanitize strings to remove potentially sensitive data
+    static func sanitize(_ input: String) -> String {
+        let key = input as NSString
+        
+        // Check cache first
+        var cachedValue: String?
+        cacheQueue.sync {
+            cachedValue = sanitizationCache.object(forKey: key) as String?
+        }
+        
+        if let cached = cachedValue {
+            return cached
+        }
+        
+        // Perform sanitization
+        var sanitized = input
+        
+        // Remove full fingerprints (keep first 8 chars for debugging)
+        sanitized = sanitized.replacing(fingerprintPattern) { match in
+            let fingerprint = String(match.output)
+            return String(fingerprint.prefix(8)) + "..."
+        }
+        
+        // Remove base64 encoded data that might be keys
+        sanitized = sanitized.replacing(base64Pattern) { _ in
+            "<base64-data>"
+        }
+        
+        // Remove potential passwords (assuming they're in quotes or after "password:")
+        sanitized = sanitized.replacing(passwordPattern) { _ in
+            "password: <redacted>"
+        }
+        
+        // Truncate peer IDs to first 8 characters
+        sanitized = sanitized.replacing(peerIDPattern) { match in
+            "peerID: \(match.1)..."
+        }
+        
+        // Cache the result
+        cacheQueue.sync {
+            sanitizationCache.setObject(sanitized as NSString, forKey: key)
+        }
+        
+        return sanitized
+    }
+    
+    /// Sanitize individual values
+    static func sanitize<T>(_ value: T) -> String {
+        let stringValue = String(describing: value)
+        return sanitize(stringValue)
+    }
 }
 
 // MARK: - Migration Helper

localPackages/BitLogger/Sources/String+Sanitization.swift

@@ -1,67 +0,0 @@
-//
-// String+Sanitization.swift
-// BitLogger
-//
-// This is free and unencumbered software released into the public domain.
-// For more information, see <https://unlicense.org>
-//
-
-import Foundation
-
-extension String {
-    /// Sanitize strings to remove potentially sensitive data
-    func sanitized() -> String {
-        let key = self as NSString
-        
-        // Check cache first
-        if let cached = Self.queue.sync(execute: { Self.cache.object(forKey: key) }) {
-            return cached as String
-        }
-        
-        var sanitized = self
-        
-        // Remove full fingerprints (keep first 8 chars for debugging)
-        let fingerprintPattern = #/[a-fA-F0-9]{64}/#
-        sanitized = sanitized.replacing(fingerprintPattern) { match in
-            let fingerprint = String(match.output)
-            return String(fingerprint.prefix(8)) + "..."
-        }
-        
-        // Remove base64 encoded data that might be keys
-        let base64Pattern = #/[A-Za-z0-9+/]{40,}={0,2}/#
-        sanitized = sanitized.replacing(base64Pattern) { _ in
-            "<base64-data>"
-        }
-        
-        // Remove potential passwords (assuming they're in quotes or after "password:")
-        let passwordPattern = #/password["\s:=]+["']?[^"'\s]+["']?/#
-        sanitized = sanitized.replacing(passwordPattern) { _ in
-            "password: <redacted>"
-        }
-        
-        // Truncate peer IDs to first 8 characters
-        let peerIDPattern = #/peerID: ([a-zA-Z0-9]{8})[a-zA-Z0-9]+/#
-        sanitized = sanitized.replacing(peerIDPattern) { match in
-            "peerID: \(match.1)..."
-        }
-        
-        // Cache the result
-        Self.queue.sync {
-            Self.cache.setObject(sanitized as NSString, forKey: key)
-        }
-        
-        return sanitized
-    }
-}
-
-// MARK: - Cache Helpers
-
-private extension String {
-    static let queue = DispatchQueue(label: "chat.bitchat.securelogger.cache", attributes: .concurrent)
-
-    static let cache: NSCache<NSString, NSString> = {
-        let cache = NSCache<NSString, NSString>()
-        cache.countLimit = 100 // Keep last 100 sanitized strings
-        return cache
-    }()
-}

localPackages/BitLogger/Tests/StringSanitizationTests.swift

@@ -1,143 +0,0 @@
-//
-//  StringSanitizationTests.swift
-//  BitLogger
-//
-//  Created by Islam on 19/10/2025.
-//
-
-import Testing
-@testable import BitLogger
-
-struct StringSanitizationTests {
-    
-    @Test("64-hex fingerprint is truncated to first 8 chars followed by ellipsis")
-    func fingerprintTruncation() async throws {
-        let fingerprint = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
-        #expect(fingerprint.count == 64)
-        
-        let input = "fingerprint=\(fingerprint)"
-        let output = input.sanitized()
-        
-        #expect(output.contains("fingerprint=01234567..."))
-        // Ensure no full fingerprint remains
-        #expect(output.contains(fingerprint) == false)
-    }
-    
-    @Test("Multiple fingerprints in a string are all truncated")
-    func multipleFingerprintTruncation() async throws {
-        let fp1 = String(repeating: "a", count: 64)
-        let fp2 = String(repeating: "b", count: 64)
-        let input = "fp1=\(fp1) fp2=\(fp2)"
-        let output = input.sanitized()
-        #expect(output.contains("fp1=aaaaaaaa..."))
-        #expect(output.contains("fp2=bbbbbbbb..."))
-        #expect(output.contains(fp1) == false)
-        #expect(output.contains(fp2) == false)
-    }
-    
-    @Test("Base64-like long data is replaced with <base64-data>")
-    func base64Replacement() async throws {
-        // 44+ chars of base64 characters
-        let base64ish = "QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVo5ODc2NTQzMjE="
-        let input = "payload=\(base64ish)"
-        let output = input.sanitized()
-        #expect(output == "payload=<base64-data>")
-    }
-    
-    @Test("Base64-like without padding is replaced with <base64-data>")
-    func base64NoPaddingReplacement() async throws {
-        let base64ish = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
-        #expect(base64ish.count >= 40)
-        let input = "b64:\(base64ish)"
-        let output = input.sanitized()
-        #expect(output == "b64:<base64-data>")
-    }
-    
-    @Test("Short base64-like strings (below threshold) are not replaced")
-    func shortBase64NotReplaced() async throws {
-        let short = "QUJDREVGR0hJSktMTU5P" // < 40 chars
-        let input = "payload=\(short)"
-        let output = input.sanitized()
-        #expect(output == input)
-    }
-    
-    @Test("Password redaction for key:value formats", arguments: [
-        "password: secret123",
-        "password=secret123",
-        "password = secret123",
-        "password: 'secret123'",
-        "password:\"secret123\"",
-        "password='secret123'"
-    ])
-    func passwordRedactionKeyValue(password: String) async throws {
-        #expect(password.sanitized() == "password: <redacted>")
-    }
-    
-    @Test("Password redaction inside wider messages")
-    func passwordRedactionInContext() async throws {
-        let input = "user=john password: 'p@ssW0rd' attempt=1"
-        let output = input.sanitized()
-        #expect(output == "user=john password: <redacted> attempt=1")
-    }
-    
-    @Test("PeerID is truncated to first 8 chars followed by ellipsis")
-    func peerIDTruncation() async throws {
-        let peer = "ABCDEF12GHIJKL34"
-        let input = "peerID: \(peer)"
-        let output = input.sanitized()
-        #expect(output == "peerID: ABCDEF12...")
-    }
-    
-    @Test("PeerID not truncated when exactly 8 chars")
-    func peerIDExactlyEightNotTruncated() async throws {
-        let peer = "ABCDEF12"
-        let input = "peerID: \(peer)"
-        let output = input.sanitized()
-        // Pattern only matches when there are more than 8 trailing chars, so unchanged
-        #expect(output == input)
-    }
-    
-    @Test("Non-matching content remains unchanged")
-    func nonMatchingUnchanged() async throws {
-        let input = "Hello world 123 - nothing sensitive here."
-        let output = input.sanitized()
-        #expect(output == input)
-    }
-    
-    @Test("Idempotency: sanitizing twice yields same result")
-    func idempotentSanitization() async throws {
-        let input = """
-        fingerprint=0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef \
-        password: "superSecret" \
-        peerID: ZYXWVUT987654321 \
-        payload=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/
-        """
-        let once = input.sanitized()
-        let twice = once.sanitized()
-        #expect(once == twice)
-    }
-    
-    @Test("Mixed content: all rules apply in a single string")
-    func mixedContent() async throws {
-        let fingerprint = "fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210"
-        let base64ish = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
-        let peer = "PEERID01EXTRA"
-        let input = "fp=\(fingerprint) password='x' peerID: \(peer) data=\(base64ish)"
-        let output = input.sanitized()
-        #expect(output.contains("fp=fedcba98..."))
-        #expect(output.contains("password: <redacted>"))
-        #expect(output.contains("peerID: PEERID01..."))
-        #expect(output.contains("data=<base64-data>"))
-        #expect(output.contains(fingerprint) == false)
-        #expect(output.contains(base64ish) == false)
-    }
-    
-    @Test("Cache returns consistent result for repeated inputs")
-    func cacheHitConsistency() async throws {
-        let input = "password: hunter2"
-        let first = input.sanitized()
-        let second = input.sanitized()
-        #expect(first == "password: <redacted>")
-        #expect(first == second)
-    }
-}

localPackages/Tor/Sources/TorManager.swift

@@ -1,23 +1,11 @@
 import BitLogger
 import Foundation
-#if canImport(Network)
 import Network
-#endif
-#if canImport(Darwin)
 import Darwin
-#elseif canImport(Glibc)
-import Glibc
-#endif
 
-#if !canImport(Network)
-private final class NWPathMonitor {
-    var pathUpdateHandler: ((Any) -> Void)?
-
-    func start(queue: DispatchQueue) {
-        // Path monitoring is unavailable on this platform; nothing to do.
-    }
-}
-#endif
+// Declare C entrypoint for Tor when statically linked from an xcframework.
+@_silgen_name("tor_main")
+private func tor_main_c(_ argc: Int32, _ argv: UnsafeMutablePointer<UnsafeMutablePointer<CChar>?>?) -> Int32
 
 // Preferred: tiny C glue that uses Tor's embedding API (tor_api.h)
 @_silgen_name("tor_host_start")
@@ -298,6 +286,150 @@ public final class TorManager: ObservableObject {
         }
     }
 
+    // MARK: - Dynamic loader path (no Swift module required)
+
+    /// Attempt to locate an embedded tor framework binary and launch Tor via `tor_run_main`.
+    /// Returns true if the attempt started and port probing was scheduled.
+    private func startTorViaDlopen() -> Bool {
+        guard let fwURL = frameworkBinaryURL() else {
+            SecureLogger.warning("TorManager: no embedded tor framework found", category: .session)
+            return false
+        }
+
+        // Load the library
+        let mode = RTLD_NOW | RTLD_LOCAL
+        SecureLogger.info("TorManager: dlopen(\(fwURL.lastPathComponent))…", category: .session)
+        guard let handle = dlopen(fwURL.path, mode) else {
+            let err = String(cString: dlerror())
+            self.lastError = NSError(domain: "TorManager", code: -10, userInfo: [NSLocalizedDescriptionKey: "dlopen failed: \(err)"])
+            self.isStarting = false
+            return false
+        }
+
+        // Resolve tor_main(argc, argv)
+        typealias TorMainType = @convention(c) (Int32, UnsafeMutablePointer<UnsafeMutablePointer<CChar>?>?) -> Int32
+        guard let sym = dlsym(handle, "tor_main") else {
+            // Keep handle open but report error
+            let err = String(cString: dlerror())
+            self.lastError = NSError(domain: "TorManager", code: -11, userInfo: [NSLocalizedDescriptionKey: "dlsym tor_main failed: \(err)"])
+            self.isStarting = false
+            return false
+        }
+        let torMain = unsafeBitCast(sym, to: TorMainType.self)
+        self._dlHandle = handle
+
+        // Prepare args: tor -f <torrc>
+        var argv: [String] = ["tor"]
+        if let torrc = torrcURL()?.path {
+            argv.append(contentsOf: ["-f", torrc])
+        }
+        // Run Tor on a background thread to avoid blocking the main actor
+        SecureLogger.info("TorManager: launching tor_main with torrc", category: .session)
+        let argc = Int32(argv.count)
+        DispatchQueue.global(qos: .utility).async {
+            // Build stable C argv in this thread
+            let cStrings: [UnsafeMutablePointer<CChar>?] = argv.map { strdup($0) }
+            let cArgv = UnsafeMutablePointer<UnsafeMutablePointer<CChar>?>.allocate(capacity: cStrings.count + 1)
+            for i in 0..<cStrings.count { cArgv[i] = cStrings[i] }
+            cArgv[cStrings.count] = nil
+
+            _ = torMain(argc, cArgv)
+
+            // Free args after exit (Tor usually never returns)
+            for ptr in cStrings.compactMap({ $0 }) { free(ptr) }
+            cArgv.deallocate()
+        }
+
+        // Start control-port monitor and probe readiness asynchronously
+        startControlMonitorIfNeeded()
+        Task.detached(priority: .userInitiated) { [weak self] in
+            guard let self else { return }
+            let ready = await self.waitForSocksReady(timeout: 60.0)
+            await MainActor.run {
+                self.socksReady = ready
+                if !ready {
+                    self.lastError = NSError(domain: "TorManager", code: -12, userInfo: [NSLocalizedDescriptionKey: "Tor SOCKS not reachable after dlopen start"])
+                    SecureLogger.error("TorManager: SOCKS not reachable (timeout)", category: .session)
+                } else {
+                    SecureLogger.info("TorManager: SOCKS ready at \(self.socksHost):\(self.socksPort)", category: .session)
+                }
+                // isStarting will be cleared when bootstrap reaches 100%
+            }
+        }
+
+        return true
+    }
+
+    private var _dlHandle: UnsafeMutableRawPointer?
+
+    private func frameworkBinaryURL() -> URL? {
+        // Try common embedded locations for the framework binary name
+        let candidates = [
+            "tor-nolzma.framework/tor-nolzma",
+            "Tor.framework/Tor",
+        ]
+        if let base = Bundle.main.privateFrameworksURL {
+            for rel in candidates {
+                let url = base.appendingPathComponent(rel)
+                if FileManager.default.fileExists(atPath: url.path) { return url }
+            }
+        }
+        // For macOS apps, also try Contents/Frameworks explicitly
+        #if os(macOS)
+        if let appURL = Bundle.main.bundleURL as URL?,
+           let frameworksURL = Optional(appURL.appendingPathComponent("Contents/Frameworks", isDirectory: true)) {
+            for rel in candidates {
+                let url = frameworksURL.appendingPathComponent(rel)
+                if FileManager.default.fileExists(atPath: url.path) { return url }
+            }
+        }
+        #endif
+        return nil
+    }
+
+    // MARK: - Static-link path (no module import)
+    private func startTorViaLinkedSymbol() -> Bool {
+        // Attempt to start tor_run_main directly (statically linked). If the
+        // symbol is not present at link-time, builds will fail — which is
+        // expected when the xcframework is absent.
+        var argv: [String] = ["tor"]
+        if let torrc = torrcURL()?.path { argv.append(contentsOf: ["-f", torrc]) }
+
+        SecureLogger.info("TorManager: starting tor_main (static)", category: .session)
+        let argc = Int32(argv.count)
+        DispatchQueue.global(qos: .utility).async {
+            // Build stable C argv in this thread
+            let cStrings: [UnsafeMutablePointer<CChar>?] = argv.map { strdup($0) }
+            let cArgv = UnsafeMutablePointer<UnsafeMutablePointer<CChar>?>.allocate(capacity: cStrings.count + 1)
+            for i in 0..<cStrings.count { cArgv[i] = cStrings[i] }
+            cArgv[cStrings.count] = nil
+
+            _ = tor_main_c(argc, cArgv)
+
+            // If tor_main ever returns, free memory
+            for ptr in cStrings.compactMap({ $0 }) { free(ptr) }
+            cArgv.deallocate()
+        }
+
+        // Start control monitor early
+        startControlMonitorIfNeeded()
+        Task.detached(priority: .userInitiated) { [weak self] in
+            guard let self else { return }
+            let ready = await self.waitForSocksReady(timeout: 60.0)
+            await MainActor.run {
+                self.socksReady = ready
+                if ready {
+                    SecureLogger.info("TorManager: SOCKS ready at \(self.socksHost):\(self.socksPort)", category: .session)
+                } else {
+                    self.lastError = NSError(domain: "TorManager", code: -13, userInfo: [NSLocalizedDescriptionKey: "Tor SOCKS not reachable after static start"])
+                    SecureLogger.error("TorManager: SOCKS not reachable (timeout)", category: .session)
+                }
+                // isStarting will be cleared when bootstrap reaches 100%
+            }
+        }
+        return true
+    }
+    
     // MARK: - ControlPort monitoring (bootstrap progress)
     private func startControlMonitorIfNeeded() {
         guard !controlMonitorStarted else { return }
@@ -308,6 +440,10 @@ public final class TorManager: ObservableObject {
         }
     }
 
+    private func controlMonitorLoop() async {}
+
+    private func tryControlSessionOnce() async -> Bool { false }
+
     // iOS: Poll GETINFO periodically to track bootstrap progress without long-lived control readers.
     private func bootstrapPollLoop() async {
         let deadline = Date().addingTimeInterval(75)