Refactor sheet presentations to use parent-child pattern

Consolidates 9 competing sheet modifiers into a single unified system
with a SheetType enum and priority-based selection. Implements parent-child
presentation pattern for image picker as suggested by @qalandarov in PR #834:
- Main view presents image picker when NOT in a sheet
- DM/people sheet presents image picker when IN a sheet

Benefits:
- Simpler code without complex conditional bindings
- Better architecture matching UI hierarchy
- Easier to maintain with clear separation of concerns
- Type-safe enum-based sheet management

Addresses feedback on PR #834.

.github/workflows/fetch_georelays.yml

@@ -7,6 +7,7 @@ on:
 
 permissions:
   contents: write
+  pull-requests: write
 
 jobs:
   update-relay-data:
@@ -17,24 +18,54 @@ jobs:
         uses: actions/checkout@v4
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
-      
+          fetch-depth: 0
+
       - name: Fetch GeoRelays
         run: |
-          wget https://raw.githubusercontent.com/permissionlesstech/georelays/refs/heads/main/nostr_relays.csv
+          wget -q https://raw.githubusercontent.com/permissionlesstech/georelays/refs/heads/main/nostr_relays.csv
           mv nostr_relays.csv ./relays/online_relays_gps.csv
 
-      - name: Check for changes
+      - name: Configure git
-        id: git-check
         run: |
-          git diff --exit-code || echo "changes=true" >> $GITHUB_OUTPUT
+          git config user.email "action@github.com"
-    
+          git config user.name "GitHub Action"
-      - name: Commit and push changes
+
-        if: steps.git-check.outputs.changes == 'true'
+      - name: Create update branch if changes
+        id: create_branch
         run: |
-          git config --local user.email "action@github.com"
+          # exit early if no changes
-          git config --local user.name "GitHub Action"
+          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 add relays/online_relays_gps.csv
-          git commit -m "Automated update of relay data - $(date -u)"
+          git commit -m "Automated update of relay data - $(date -u --rfc-3339=seconds)"
-          git push
+          echo "changed=true" >> $GITHUB_OUTPUT
-        env:
+          echo "branch=$BRANCH" >> $GITHUB_OUTPUT
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - 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"

bitchat/Localizable.xcstrings

@@ -6268,10 +6268,6 @@
         }
       }
     },
-    "Choose an image" : {
-      "comment" : "A label displayed above a button that allows the user to choose an image to send.",
-      "isCommentAutoGenerated" : true
-    },
     "close" : {
       "comment" : "Button to dismiss fullscreen media viewer",
       "localizations" : {
@@ -35705,7 +35701,545 @@
           }
         }
       }
+    },
+    "Voice notes are only available in mesh chats." : {
+      "extractionState" : "manual",
+      "localizations" : {
+        "ar" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "الملاحظات الصوتية متاحة فقط في محادثات الميش."
+          }
+        },
+        "bn" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "ভয়েস নোট শুধু মেশ চ্যাটে উপলব্ধ।"
+          }
+        },
+        "de" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Sprachnachrichten sind nur im Mesh-Chat verfügbar."
+          }
+        },
+        "en" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Voice notes are only available in mesh chats."
+          }
+        },
+        "es" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Las notas de voz solo están disponibles en los chats de mesh."
+          }
+        },
+        "fil" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Ang mga voice note ay available lamang sa mga mesh chat."
+          }
+        },
+        "fr" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Les notes vocales sont uniquement disponibles dans les discussions mesh."
+          }
+        },
+        "he" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "הערות קוליות זמינות רק בצ׳אט של mesh."
+          }
+        },
+        "hi" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "वॉइस नोट्स केवल मेश चैट में ही उपलब्ध हैं।"
+          }
+        },
+        "id" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Catatan suara hanya tersedia di obrolan mesh."
+          }
+        },
+        "it" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Le note vocali sono disponibili solo nelle chat mesh."
+          }
+        },
+        "ja" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "ボイスメモはメッシュチャットでのみ利用できます。"
+          }
+        },
+        "ko" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "음성 메모는 메쉬 채팅에서만 사용할 수 있습니다."
+          }
+        },
+        "ms" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Nota suara hanya tersedia dalam sembang mesh."
+          }
+        },
+        "ne" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "भ्वाइस नोटहरू केवल मेष च्याटमा मात्र उपलब्ध छन्।"
+          }
+        },
+        "nl" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Spraaknotities zijn alleen beschikbaar in mesh-chats."
+          }
+        },
+        "pl" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Notatki głosowe są dostępne tylko na czatach mesh."
+          }
+        },
+        "pt" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "As notas de voz só estão disponíveis nos chats mesh."
+          }
+        },
+        "pt-BR" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "As mensagens de voz só estão disponíveis nos chats mesh."
+          }
+        },
+        "ru" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Голосовые сообщения доступны только в mesh-чатах."
+          }
+        },
+        "sv" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Röstanteckningar är bara tillgängliga i mesh-chattar."
+          }
+        },
+        "ta" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "குரல் குறிப்புகள் மெஷ் உரையாடல்களில் மட்டுமே கிடைக்கும்."
+          }
+        },
+        "th" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "บันทึกเสียงใช้งานได้เฉพาะในแชต mesh เท่านั้น"
+          }
+        },
+        "tr" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Sesli notlar yalnızca mesh sohbetlerinde kullanılabilir."
+          }
+        },
+        "uk" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Голосові нотатки доступні лише в mesh-чатах."
+          }
+        },
+        "ur" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "وائس نوٹس صرف میش چیٹس میں دستیاب ہیں۔"
+          }
+        },
+        "vi" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Ghi chú giọng nói chỉ khả dụng trong các cuộc trò chuyện mesh."
+          }
+        },
+        "zh-Hans" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "语音消息仅可在 mesh 聊天中使用。"
+          }
+        },
+        "zh-Hant" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "語音訊息僅能在 mesh 聊天中使用。"
+          }
+        }
+      }
+    },
+    "Images are only available in mesh chats." : {
+      "extractionState" : "manual",
+      "localizations" : {
+        "ar" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "الصور متاحة فقط في محادثات الميش."
+          }
+        },
+        "bn" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "ছবি শুধু মেশ চ্যাটে উপলব্ধ।"
+          }
+        },
+        "de" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Bilder sind nur im Mesh-Chat verfügbar."
+          }
+        },
+        "en" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Images are only available in mesh chats."
+          }
+        },
+        "es" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Las imágenes solo están disponibles en los chats de mesh."
+          }
+        },
+        "fil" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Ang mga larawan ay available lamang sa mga mesh chat."
+          }
+        },
+        "fr" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Les images sont uniquement disponibles dans les discussions mesh."
+          }
+        },
+        "he" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "תמונות זמינות רק בצ׳אט של mesh."
+          }
+        },
+        "hi" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "चित्र केवल मेश चैट में ही उपलब्ध हैं।"
+          }
+        },
+        "id" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Gambar hanya tersedia di obrolan mesh."
+          }
+        },
+        "it" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Le immagini sono disponibili solo nelle chat mesh."
+          }
+        },
+        "ja" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "画像はメッシュチャットでのみ利用できます。"
+          }
+        },
+        "ko" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "이미지는 메쉬 채팅에서만 사용할 수 있습니다."
+          }
+        },
+        "ms" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Imej hanya tersedia dalam sembang mesh."
+          }
+        },
+        "ne" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "तस्बिरहरू केवल मेष च्याटमा मात्र उपलब्ध छन्।"
+          }
+        },
+        "nl" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Afbeeldingen zijn alleen beschikbaar in mesh-chats."
+          }
+        },
+        "pl" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Obrazy są dostępne tylko na czatach mesh."
+          }
+        },
+        "pt" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "As imagens só estão disponíveis nos chats mesh."
+          }
+        },
+        "pt-BR" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "As imagens só estão disponíveis nos chats mesh."
+          }
+        },
+        "ru" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Изображения доступны только в mesh-чатах."
+          }
+        },
+        "sv" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Bilder är bara tillgängliga i mesh-chattar."
+          }
+        },
+        "ta" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "படங்கள் மெஷ் உரையாடல்களில் மட்டுமே கிடைக்கும்."
+          }
+        },
+        "th" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "รูปภาพใช้งานได้เฉพาะในแชต mesh เท่านั้น"
+          }
+        },
+        "tr" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Görseller yalnızca mesh sohbetlerinde kullanılabilir."
+          }
+        },
+        "uk" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Зображення доступні лише в mesh-чатах."
+          }
+        },
+        "ur" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "تصاویر صرف میش چیٹس میں دستیاب ہیں۔"
+          }
+        },
+        "vi" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Hình ảnh chỉ khả dụng trong các cuộc trò chuyện mesh."
+          }
+        },
+        "zh-Hans" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "图片仅可在 mesh 聊天中使用。"
+          }
+        },
+        "zh-Hant" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "圖片僅能在 mesh 聊天中使用。"
+          }
+        }
+      }
+    },
+    "Choose an image" : {
+      "comment" : "A label displayed above a button that allows the user to choose an image to send.",
+      "extractionState" : "manual",
+      "localizations" : {
+        "ar" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "اختر صورة"
+          }
+        },
+        "bn" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "একটি ছবি নির্বাচন করুন"
+          }
+        },
+        "de" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Bild auswählen"
+          }
+        },
+        "en" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Choose an image"
+          }
+        },
+        "es" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Elige una imagen"
+          }
+        },
+        "fil" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Pumili ng larawan"
+          }
+        },
+        "fr" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Choisir une image"
+          }
+        },
+        "he" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "בחר תמונה"
+          }
+        },
+        "hi" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "एक चित्र चुनें"
+          }
+        },
+        "id" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Pilih gambar"
+          }
+        },
+        "it" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Scegli un’immagine"
+          }
+        },
+        "ja" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "画像を選択"
+          }
+        },
+        "ko" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "이미지를 선택하세요"
+          }
+        },
+        "ms" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Pilih imej"
+          }
+        },
+        "ne" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "एउटा तस्वीर चयन गर्नुहोस्"
+          }
+        },
+        "nl" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Kies een afbeelding"
+          }
+        },
+        "pl" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Wybierz obraz"
+          }
+        },
+        "pt" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Escolher uma imagem"
+          }
+        },
+        "pt-BR" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Escolha uma imagem"
+          }
+        },
+        "ru" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Выберите изображение"
+          }
+        },
+        "sv" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Välj en bild"
+          }
+        },
+        "ta" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "ஒரு படத்தைத் தேர்ந்தெடுக்கவும்"
+          }
+        },
+        "th" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "เลือกภาพ"
+          }
+        },
+        "tr" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Bir görüntü seç"
+          }
+        },
+        "uk" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Виберіть зображення"
+          }
+        },
+        "ur" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "ایک تصویر منتخب کریں"
+          }
+        },
+        "vi" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Chọn một hình ảnh"
+          }
+        },
+        "zh-Hans" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "选择图像"
+          }
+        },
+        "zh-Hant" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "選擇圖像"
+          }
+        }
+      }
     }
   },
   "version" : "1.1"
-}
+}

bitchat/Models/ReadReceipt.swift

@@ -11,11 +11,11 @@ import Foundation
 struct ReadReceipt: Codable {
     let originalMessageID: String
     let receiptID: String
-    var readerID: String  // Who read it
+    var readerID: PeerID  // Who read it
     let readerNickname: String
     let timestamp: Date
     
-    init(originalMessageID: String, readerID: String, readerNickname: String) {
+    init(originalMessageID: String, readerID: PeerID, 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: String, readerNickname: String, timestamp: Date) {
+    private init(originalMessageID: String, receiptID: String, readerID: PeerID, 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
+        var tempID = readerID.id
         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 = readerIDData.hexEncodedString()
+        let readerID = PeerID(hexData: readerIDData)
-        guard PeerID(str: readerID).isValid else { return nil }
+        guard readerID.isValid else { return nil }
         
         guard let timestamp = dataCopy.readDate(at: &offset),
               InputValidator.validateTimestamp(timestamp),

bitchat/Nostr/GeoRelayDirectory.swift

@@ -1,6 +1,11 @@
 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
@@ -12,19 +17,32 @@ 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 // 24h
+    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 init() {
-        // Load cached or bundled data synchronously
+        entries = loadLocalEntries()
-        self.entries = self.loadLocalEntries()
+        registerObservers()
-        // Fire-and-forget remote refresh if stale
+        startRefreshTimer()
         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)
@@ -62,42 +80,119 @@ final class GeoRelayDirectory {
     }
 
     // MARK: - Remote Fetch
-    func prefetchIfNeeded() {
+    func prefetchIfNeeded(force: Bool = false) {
+        guard !isFetching else { return }
+
         let now = Date()
         let last = UserDefaults.standard.object(forKey: lastFetchKey) as? Date ?? .distantPast
-        guard now.timeIntervalSince(last) >= fetchInterval else { return }
+
+        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()
         fetchRemote()
     }
 
     private func fetchRemote() {
-        let req = URLRequest(url: remoteURL, cachePolicy: .reloadIgnoringLocalCacheData, timeoutInterval: 15)
+        guard !isFetching else { return }
-        // Ensure Tor readiness before fetching (fail-closed by default)
+        isFetching = true
-        Task.detached {
+
+        let request = URLRequest(
+            url: remoteURL,
+            cachePolicy: .reloadIgnoringLocalCacheData,
+            timeoutInterval: 15
+        )
+
+        Task.detached { [weak self] in
+            guard let self else { return }
+
             let ready = await TorManager.shared.awaitReady()
             if !ready {
-                SecureLogger.warning("GeoRelayDirectory: Tor not ready; skipping remote fetch (fail-closed)", category: .session)
+                await self.handleFetchFailure(.torNotReady)
                 return
             }
-            let task = TorURLSession.shared.session.dataTask(with: req) { [weak self] data, _, error in
+
-                guard let self = self else { return }
+            do {
-                if let data = data, error == nil, let text = String(data: data, encoding: .utf8) {
+                let (data, _) = try await TorURLSession.shared.session.data(for: request)
-                    let parsed = GeoRelayDirectory.parseCSV(text)
+                guard let text = String(data: data, encoding: .utf8) else {
-                    if !parsed.isEmpty {
+                    await self.handleFetchFailure(.invalidData)
-                        Task { @MainActor in
+                    return
-                            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
-                    }
                 }
-                SecureLogger.warning("GeoRelayDirectory: remote fetch failed; keeping local entries", category: .session)
+
+                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))
             }
-            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 {
@@ -110,30 +205,35 @@ final class GeoRelayDirectory {
     // MARK: - Loading
     private func loadLocalEntries() -> [Entry] {
         // Prefer cached file if present
-        if let cache = self.cacheURL(),
+        if let cache = 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 []
     }
@@ -141,7 +241,6 @@ 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 }
@@ -162,11 +261,67 @@ 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 }
+        } 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
+            self?.prefetchIfNeeded(force: true)
+        }
+        observers.append(torReady)
+
+#if os(iOS)
+        let didBecomeActive = center.addObserver(
+            forName: UIApplication.didBecomeActiveNotification,
+            object: nil,
+            queue: .main
+        ) { [weak self] _ in
+            self?.prefetchIfNeeded()
+        }
+        observers.append(didBecomeActive)
+#elseif os(macOS)
+        let didBecomeActive = center.addObserver(
+            forName: NSApplication.didBecomeActiveNotification,
+            object: nil,
+            queue: .main
+        ) { [weak self] _ 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)
     }
 }
 

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: String, senderPeerID: String) -> String? {
+    static func encodePMForNostr(content: String, messageID: String, recipientPeerID: PeerID, senderPeerID: PeerID) -> 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 recipientIDHex: String = normalizeRecipientPeerID(recipientPeerID)
+        let recipientID = normalizeRecipientPeerID(recipientPeerID)
 
         let packet = BitchatPacket(
             type: MessageType.noiseEncrypted.rawValue,
-            senderID: Data(hexString: senderPeerID) ?? Data(),
+            senderID: Data(hexString: senderPeerID.id) ?? Data(),
-            recipientID: Data(hexString: recipientIDHex),
+            recipientID: Data(hexString: recipientID.id),
             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: String, senderPeerID: String) -> String? {
+    static func encodeAckForNostr(type: NoisePayloadType, messageID: String, recipientPeerID: PeerID, senderPeerID: PeerID) -> String? {
         guard type == .delivered || type == .readReceipt else { return nil }
 
         var payload = Data([type.rawValue])
         payload.append(Data(messageID.utf8))
 
-        let recipientIDHex: String = normalizeRecipientPeerID(recipientPeerID)
+        let recipientID = normalizeRecipientPeerID(recipientPeerID)
 
         let packet = BitchatPacket(
             type: MessageType.noiseEncrypted.rawValue,
-            senderID: Data(hexString: senderPeerID) ?? Data(),
+            senderID: Data(hexString: senderPeerID.id) ?? Data(),
-            recipientID: Data(hexString: recipientIDHex),
+            recipientID: Data(hexString: recipientID.id),
             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: String) -> String? {
+    static func encodeAckForNostrNoRecipient(type: NoisePayloadType, messageID: String, senderPeerID: PeerID) -> 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) ?? Data(),
+            senderID: Data(hexString: senderPeerID.id) ?? 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: String) -> String? {
+    static func encodePMForNostrNoRecipient(content: String, messageID: String, senderPeerID: PeerID) -> 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) ?? Data(),
+            senderID: Data(hexString: senderPeerID.id) ?? 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: String) -> String {
+    private static func normalizeRecipientPeerID(_ recipientPeerID: PeerID) -> PeerID {
-        if let maybeData = Data(hexString: recipientPeerID) {
+        if let maybeData = Data(hexString: recipientPeerID.id) {
             if maybeData.count == 32 {
                 // Treat as Noise static public key; derive peerID from fingerprint
-                return PeerID(publicKey: maybeData).id
+                return PeerID(publicKey: maybeData)
             } else if maybeData.count == 8 {
                 // Already an 8-byte peer ID
                 return recipientPeerID

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.id, senderPeerID: senderPeerID.id) else {
+            guard let embedded = NostrEmbeddedBitChat.encodePMForNostr(content: content, messageID: messageID, recipientPeerID: peerID, senderPeerID: senderPeerID) 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.id, senderPeerID: senderPeerID.id) else {
+            guard let embedded = NostrEmbeddedBitChat.encodePMForNostr(content: content, messageID: UUID().uuidString, recipientPeerID: peerID, senderPeerID: senderPeerID) 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.id, senderPeerID: senderPeerID.id) else {
+            guard let ack = NostrEmbeddedBitChat.encodeAckForNostr(type: .delivered, messageID: messageID, recipientPeerID: peerID, senderPeerID: senderPeerID) 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.id) else { return }
+            guard let embedded = NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(type: .delivered, messageID: messageID, senderPeerID: senderPeerID) 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.id) else { return }
+            guard let embedded = NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(type: .readReceipt, messageID: messageID, senderPeerID: senderPeerID) 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.id) else {
+            guard let embedded = NostrEmbeddedBitChat.encodePMForNostrNoRecipient(content: content, messageID: messageID, senderPeerID: senderPeerID) 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.id, senderPeerID: senderPeerID.id) else {
+            guard let ack = NostrEmbeddedBitChat.encodeAckForNostr(type: .readReceipt, messageID: item.receipt.originalMessageID, recipientPeerID: item.peerID, senderPeerID: senderPeerID) else {
                 SecureLogger.error("NostrTransport: failed to embed READ ack", category: .session)
                 scheduleNextReadAck(); return
             }

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.id ?? "",
+            readerID: meshService?.myPeerID ?? PeerID(str: ""),
             readerNickname: meshService?.myNickname ?? ""
         )
         

bitchat/Services/TransportConfig.swift

@@ -145,6 +145,9 @@ 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/ViewModels/ChatViewModel.swift

@@ -145,6 +145,19 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
         }
     }
 
+    private typealias GeoOutgoingContext = (channel: GeohashChannel, event: NostrEvent, identity: NostrIdentity, teleported: Bool)
+
+    @MainActor
+    private var canSendMediaInCurrentContext: Bool {
+        if let peer = selectedPrivateChatPeer {
+            return !(peer.isGeoDM || peer.isGeoChat)
+        }
+        switch activeChannel {
+        case .mesh: return true
+        case .location: return false
+        }
+    }
+
     private var rateBucketsBySender: [String: TokenBucket] = [:]
     private var rateBucketsByContent: [String: TokenBucket] = [:]
     private let senderBucketCapacity: Double = TransportConfig.uiSenderRateBucketCapacity
@@ -1443,20 +1456,48 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
         // Parse mentions from the content (use original content for user intent)
         let mentions = parseMentions(from: content)
 
+        var geoContext: GeoOutgoingContext? = nil
+
         // Add message to local display
         var displaySender = nickname
         var localSenderPeerID = meshService.myPeerID
-        if case .location(let ch) = activeChannel,
+        var messageID: String? = nil
-           let myGeoIdentity = try? idBridge.deriveIdentity(forGeohash: ch.geohash) {
+        var messageTimestamp = Date()
-            let suffix = String(myGeoIdentity.publicKeyHex.suffix(4))
+
-            displaySender = nickname + "#" + suffix
+        switch activeChannel {
-            localSenderPeerID = PeerID(nostr: myGeoIdentity.publicKeyHex)
+        case .mesh:
+            break
+        case .location(let ch):
+            do {
+                let identity = try idBridge.deriveIdentity(forGeohash: ch.geohash)
+                let suffix = String(identity.publicKeyHex.suffix(4))
+                displaySender = nickname + "#" + suffix
+                localSenderPeerID = PeerID(nostr: identity.publicKeyHex)
+                let teleported = LocationChannelManager.shared.teleported
+                let event = try NostrProtocol.createEphemeralGeohashEvent(
+                    content: trimmed,
+                    geohash: ch.geohash,
+                    senderIdentity: identity,
+                    nickname: nickname,
+                    teleported: teleported
+                )
+                messageID = event.id
+                messageTimestamp = Date(timeIntervalSince1970: TimeInterval(event.created_at))
+                geoContext = (channel: ch, event: event, identity: identity, teleported: teleported)
+            } catch {
+                SecureLogger.error("❌ Failed to prepare geohash message: \(error)", category: .session)
+                addSystemMessage(
+                    String(localized: "system.location.send_failed", comment: "System message when a location channel send fails")
+                )
+                return
+            }
         }
 
         let message = BitchatMessage(
+            id: messageID,
             sender: displaySender,
             content: trimmed,
-            timestamp: Date(),
+            timestamp: messageTimestamp,
             isRelay: false,
             senderPeerID: localSenderPeerID,
             mentions: mentions.isEmpty ? nil : mentions
@@ -1487,10 +1528,10 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
 
         // UI updates automatically via @Published var messages
 
-        updateChannelActivityTimeThenSend(content: content, trimmed: trimmed, mentions: mentions)
+        updateChannelActivityTimeThenSend(content: content, trimmed: trimmed, mentions: mentions, geoContext: geoContext)
     }
 
-    private func updateChannelActivityTimeThenSend(content: String, trimmed: String, mentions: [String]) {
+    private func updateChannelActivityTimeThenSend(content: String, trimmed: String, mentions: [String], geoContext: GeoOutgoingContext?) {
         switch activeChannel {
         case .mesh:
             lastPublicActivityAt["mesh"] = Date()
@@ -1498,58 +1539,54 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
             meshService.sendMessage(content, mentions: mentions)
         case .location(let ch):
             lastPublicActivityAt["geo:\(ch.geohash)"] = Date()
+            guard let context = geoContext, context.channel.geohash == ch.geohash else {
+                SecureLogger.error("Geo: missing send context for \(ch.geohash)", category: .session)
+                addSystemMessage(
+                    String(localized: "system.location.send_failed", comment: "System message when a location channel send fails")
+                )
+                return
+            }
             // Send to geohash channel via Nostr ephemeral
             Task { @MainActor in
-                sendGeohash(ch: ch, content: trimmed)
+                self.sendGeohash(context: context)
             }
         }
     }
     
     @MainActor
-    private func sendGeohash(ch: GeohashChannel, content: String) {
+    private func sendGeohash(context: GeoOutgoingContext) {
-        do {
+        let ch = context.channel
-            let identity = try idBridge.deriveIdentity(forGeohash: ch.geohash)
+        let event = context.event
+        let identity = context.identity
 
-            let event = try NostrProtocol.createEphemeralGeohashEvent(
+        let targetRelays = GeoRelayDirectory.shared.closestRelays(
-                content: content,
+            toGeohash: ch.geohash,
-                geohash: ch.geohash,
+            count: TransportConfig.nostrGeoRelayCount
-                senderIdentity: identity,
+        )
-                nickname: nickname,
-                teleported: LocationChannelManager.shared.teleported
-            )
-            
-            let targetRelays = GeoRelayDirectory.shared.closestRelays(
-                toGeohash: ch.geohash,
-                count: TransportConfig.nostrGeoRelayCount
-            )
-            
-            if targetRelays.isEmpty {
-                SecureLogger.warning("Geo: no geohash relays available for \(ch.geohash); not sending", category: .session)
-            } else {
-                NostrRelayManager.shared.sendEvent(event, to: targetRelays)
-            }
 
-            // Track ourselves as active participant
+        if targetRelays.isEmpty {
-            recordGeoParticipant(pubkeyHex: identity.publicKeyHex)
+            SecureLogger.warning("Geo: no geohash relays available for \(ch.geohash); not sending", category: .session)
-            nostrKeyMapping[PeerID(nostr: identity.publicKeyHex)] = identity.publicKeyHex
+        } else {
-            SecureLogger.debug("GeoTeleport: sent geo message pub=\(identity.publicKeyHex.prefix(8))… teleported=\(LocationChannelManager.shared.teleported)", category: .session)
+            NostrRelayManager.shared.sendEvent(event, to: targetRelays)
-            
-            // If we tagged this as teleported, also mark our pubkey in teleportedGeo for UI
-            // Only when not in our regional set (and regional list is known)
-            let hasRegional = !LocationChannelManager.shared.availableChannels.isEmpty
-            let inRegional = LocationChannelManager.shared.availableChannels.contains { $0.geohash == ch.geohash }
-            
-            if LocationChannelManager.shared.teleported && hasRegional && !inRegional {
-                let key = identity.publicKeyHex.lowercased()
-                teleportedGeo = teleportedGeo.union([key])
-                SecureLogger.info("GeoTeleport: mark self teleported key=\(key.prefix(8))… total=\(teleportedGeo.count)", category: .session)
-            }
-        } catch {
-            SecureLogger.error("❌ Failed to send geohash message: \(error)", category: .session)
-            addSystemMessage(
-                String(localized: "system.location.send_failed", comment: "System message when a location channel send fails")
-            )
         }
+
+        // Track ourselves as active participant
+        recordGeoParticipant(pubkeyHex: identity.publicKeyHex)
+        nostrKeyMapping[PeerID(nostr: identity.publicKeyHex)] = identity.publicKeyHex
+        SecureLogger.debug("GeoTeleport: sent geo message pub=\(identity.publicKeyHex.prefix(8))… teleported=\(context.teleported)", category: .session)
+
+        // If we tagged this as teleported, also mark our pubkey in teleportedGeo for UI
+        // Only when not in our regional set (and regional list is known)
+        let hasRegional = !LocationChannelManager.shared.availableChannels.isEmpty
+        let inRegional = LocationChannelManager.shared.availableChannels.contains { $0.geohash == ch.geohash }
+
+        if context.teleported && hasRegional && !inRegional {
+            let key = identity.publicKeyHex.lowercased()
+            teleportedGeo = teleportedGeo.union([key])
+            SecureLogger.info("GeoTeleport: mark self teleported key=\(key.prefix(8))… total=\(teleportedGeo.count)", category: .session)
+        }
+
+        recordProcessedEvent(event.id)
     }
 
     @MainActor
@@ -2407,6 +2444,13 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
 
     @MainActor
     func sendVoiceNote(at url: URL) {
+        guard canSendMediaInCurrentContext else {
+            SecureLogger.info("Voice note blocked outside mesh/private context", category: .session)
+            try? FileManager.default.removeItem(at: url)
+            addSystemMessage("Voice notes are only available in mesh chats.")
+            return
+        }
+
         let targetPeer = selectedPrivateChatPeer
         let message = enqueueMediaMessage(content: "[voice] \(url.lastPathComponent)", targetPeer: targetPeer?.id)
         let messageID = message.id
@@ -2455,6 +2499,13 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
 
     @MainActor
     func sendImage(from sourceURL: URL, cleanup: (() -> Void)? = nil) {
+        guard canSendMediaInCurrentContext else {
+            SecureLogger.info("Image send blocked outside mesh/private context", category: .session)
+            cleanup?()
+            addSystemMessage("Images are only available in mesh chats.")
+            return
+        }
+
         let targetPeer = selectedPrivateChatPeer
 
         Task.detached(priority: .userInitiated) { [weak self] in
@@ -3442,7 +3493,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
                     if !sentReadReceipts.contains(message.id) {
                         // Use stable Noise key hex if available; else fall back to peerID
                         let recipPeer = peerID.isHex ? peerID : (unifiedPeerService.getPeer(by: peerID)?.peerID ?? peerID)
-                        let receipt = ReadReceipt(originalMessageID: message.id, readerID: meshService.myPeerID.id, readerNickname: nickname)
+                        let receipt = ReadReceipt(originalMessageID: message.id, readerID: meshService.myPeerID, readerNickname: nickname)
                         messageRouter.sendReadReceipt(receipt, to: recipPeer)
                         sentReadReceipts.insert(message.id)
                     }
@@ -5788,7 +5839,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
         }
         if !sentReadReceipts.contains(message.id) {
             if let key {
-                let receipt = ReadReceipt(originalMessageID: message.id, readerID: meshService.myPeerID.id, readerNickname: nickname)
+                let receipt = ReadReceipt(originalMessageID: message.id, readerID: meshService.myPeerID, readerNickname: nickname)
                 SecureLogger.debug("Viewing chat; sending READ ack for \(message.id.prefix(8))… via router", category: .session)
                 messageRouter.sendReadReceipt(receipt, to: PeerID(hexData: key))
                 sentReadReceipts.insert(message.id)
@@ -6231,7 +6282,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
             if !sentReadReceipts.contains(message.id) {
                 let receipt = ReadReceipt(
                     originalMessageID: message.id,
-                    readerID: meshService.myPeerID.id,
+                    readerID: meshService.myPeerID,
                     readerNickname: nickname
                 )
                 

bitchat/Views/ContentView.swift

@@ -27,6 +27,37 @@ private struct MessageDisplayItem: Identifiable {
     let message: BitchatMessage
 }
 
+// MARK: - Sheet Management
+
+private enum SheetType: Identifiable {
+    case peopleOrChat
+    case appInfo
+    case fingerprint(PeerID)
+    case imagePreview(URL)
+    case verification
+    case locationChannels
+    case locationNotes
+
+    var id: String {
+        switch self {
+        case .peopleOrChat:
+            return "peopleOrChat"
+        case .appInfo:
+            return "appInfo"
+        case .fingerprint(let peerID):
+            return "fingerprint-\(peerID.id)"
+        case .imagePreview(let url):
+            return "imagePreview-\(url.path)"
+        case .verification:
+            return "verification"
+        case .locationChannels:
+            return "locationChannels"
+        case .locationNotes:
+            return "locationNotes"
+        }
+    }
+}
+
 // MARK: - Main Content View
 
 struct ContentView: View {
@@ -80,7 +111,7 @@ struct ContentView: View {
     // Timer-based refresh removed; use LocationChannelManager live updates instead
     // Window sizes for rendering (infinite scroll up)
     @State private var windowCountPublic: Int = 300
-    @State private var windowCountPrivate: [String: Int] = [:]
+    @State private var windowCountPrivate: [PeerID: Int] = [:]
     
     // MARK: - Computed Properties
     
@@ -121,10 +152,98 @@ struct ContentView: View {
             return viewModel.visibleGeohashPeople().count
         }
     }
-    
+
-    
+    // MARK: - Sheet Management
+
+    /// Determines which sheet should currently be active based on all state variables.
+    /// Priority is determined by the order of checks (first match wins).
+    private var currentSheet: SheetType? {
+        // People or private chat sheet (highest priority - primary navigation)
+        if showSidebar || viewModel.selectedPrivateChatPeer != nil {
+            return .peopleOrChat
+        }
+
+        // Verification sheet
+        if showVerifySheet {
+            return .verification
+        }
+
+        // Location channels sheet
+        if showLocationChannelsSheet {
+            return .locationChannels
+        }
+
+        // Location notes sheet
+        if showLocationNotes {
+            return .locationNotes
+        }
+
+        // App info sheet
+        if showAppInfo {
+            return .appInfo
+        }
+
+        // Fingerprint sheet
+        if let peerID = viewModel.showingFingerprintFor {
+            return .fingerprint(peerID)
+        }
+
+        // Image preview sheet
+        if let url = imagePreviewURL {
+            return .imagePreview(url)
+        }
+
+        return nil
+    }
+
+    /// Binding that maps between the SheetType enum and the individual state variables.
+    /// When a sheet is presented, it reads from currentSheet.
+    /// When a sheet is dismissed, it clears all related state variables.
+    private var sheetBinding: Binding<SheetType?> {
+        Binding(
+            get: {
+                return currentSheet
+            },
+            set: { newSheet in
+                // First, clear all sheet-related state to ensure clean transitions
+                showSidebar = false
+                if viewModel.selectedPrivateChatPeer != nil {
+                    viewModel.endPrivateChat()
+                }
+                showAppInfo = false
+                viewModel.showingFingerprintFor = nil
+                imagePreviewURL = nil
+                showVerifySheet = false
+                showLocationChannelsSheet = false
+                showLocationNotes = false
+                notesGeohash = nil
+
+                // Now set the new sheet state if one was requested
+                if let sheet = newSheet {
+                    switch sheet {
+                    case .peopleOrChat:
+                        showSidebar = true
+                    case .appInfo:
+                        showAppInfo = true
+                    case .fingerprint(let peerID):
+                        viewModel.showingFingerprintFor = peerID
+                    case .imagePreview(let url):
+                        imagePreviewURL = url
+                    case .verification:
+                        showVerifySheet = true
+                    case .locationChannels:
+                        showLocationChannelsSheet = true
+                    case .locationNotes:
+                        showLocationNotes = true
+                    }
+                }
+            }
+        )
+    }
+
+
     private struct PrivateHeaderContext {
-        let headerPeerID: String
+        let headerPeerID: PeerID
         let peer: BitchatPeer?
         let displayName: String
         let isNostrAvailable: Bool
@@ -132,7 +251,7 @@ struct ContentView: View {
 
 // MARK: - Body
 
-    var body: some View {
+    private var mainContent: some View {
         VStack(spacing: 0) {
             mainHeaderView
                 .onAppear {
@@ -176,38 +295,104 @@ struct ContentView: View {
                 showSidebar = true
             }
         }
-        .sheet(
+    }
-            isPresented: Binding(
+
-                get: { showSidebar || viewModel.selectedPrivateChatPeer != nil },
+    var body: some View {
-                set: { isPresented in
+        mainContent
-                    if !isPresented {
+        // MARK: - Consolidated Sheet Presentation
-                        showSidebar = false
+        .sheet(item: sheetBinding) { sheet in
-                        viewModel.endPrivateChat()
+            switch sheet {
+            case .peopleOrChat:
+                peopleSheetView
+
+            case .appInfo:
+                AppInfoView()
+                    .onAppear { viewModel.isAppInfoPresented = true }
+                    .onDisappear { viewModel.isAppInfoPresented = false }
+
+            case .fingerprint(let peerID):
+                FingerprintView(viewModel: viewModel, peerID: peerID)
+
+            case .imagePreview(let url):
+                ImagePreviewView(url: url)
+
+            case .verification:
+                VerificationSheetView(isPresented: $showVerifySheet)
+                    .environmentObject(viewModel)
+
+            case .locationChannels:
+                LocationChannelsSheet(isPresented: $showLocationChannelsSheet)
+                    .onAppear { viewModel.isLocationChannelsSheetPresented = true }
+                    .onDisappear { viewModel.isLocationChannelsSheetPresented = false }
+
+            case .locationNotes:
+                Group {
+                    if let gh = notesGeohash ?? LocationChannelManager.shared.availableChannels.first(where: { $0.level == .building })?.geohash {
+                        LocationNotesView(geohash: gh)
+                            .environmentObject(viewModel)
+                    } else {
+                        VStack(spacing: 12) {
+                            HStack {
+                                Text("content.notes.title")
+                                    .font(.bitchatSystem(size: 16, weight: .bold, design: .monospaced))
+                                Spacer()
+                                Button(action: { showLocationNotes = false }) {
+                                    Image(systemName: "xmark")
+                                        .font(.bitchatSystem(size: 13, weight: .semibold, design: .monospaced))
+                                        .foregroundColor(textColor)
+                                        .frame(width: 32, height: 32)
+                                }
+                                .buttonStyle(.plain)
+                                .accessibilityLabel(String(localized: "common.close", comment: "Accessibility label for close buttons"))
+                            }
+                            .frame(height: headerHeight)
+                            .padding(.horizontal, 12)
+                            .background(backgroundColor.opacity(0.95))
+                            Text("content.notes.location_unavailable")
+                                .font(.bitchatSystem(size: 14, design: .monospaced))
+                                .foregroundColor(secondaryTextColor)
+                            Button("content.location.enable") {
+                                LocationChannelManager.shared.enableLocationChannels()
+                                LocationChannelManager.shared.refreshChannels()
+                            }
+                            .buttonStyle(.bordered)
+                            Spacer()
+                        }
+                        .background(backgroundColor)
+                        .foregroundColor(textColor)
+                    }
+                }
+                .onAppear {
+                    LocationChannelManager.shared.enableLocationChannels()
+                    LocationChannelManager.shared.beginLiveRefresh()
+                }
+                .onDisappear {
+                    LocationChannelManager.shared.endLiveRefresh()
+                }
+                .onChange(of: locationManager.availableChannels) { channels in
+                    if let current = channels.first(where: { $0.level == .building })?.geohash,
+                        notesGeohash != current {
+                        notesGeohash = current
+                        #if os(iOS)
+                        let generator = UIImpactFeedbackGenerator(style: .light)
+                        generator.prepare()
+                        generator.impactOccurred()
+                        #endif
                     }
                 }
-            )
-        ) {
-            peopleSheetView
-                #if os(iOS)
-                .presentationDetents([.large])
-                .presentationDragIndicator(.visible)
-                #endif
-        }
-        .sheet(isPresented: $showAppInfo) {
-            AppInfoView()
-                .onAppear { viewModel.isAppInfoPresented = true }
-                .onDisappear { viewModel.isAppInfoPresented = false }
-        }
-        .sheet(isPresented: Binding(
-            get: { viewModel.showingFingerprintFor != nil },
-            set: { _ in viewModel.showingFingerprintFor = nil }
-        )) {
-            if let peerID = viewModel.showingFingerprintFor {
-                FingerprintView(viewModel: viewModel, peerID: peerID.id)
             }
         }
-#if os(iOS)
+        // MARK: - Image Picker for Main View
-        .sheet(isPresented: $showImagePicker) {
+        // Only present when NOT in a DM or people sheet (parent-child pattern)
+        #if os(iOS)
+        .sheet(isPresented: Binding(
+            get: { showImagePicker && !showSidebar && viewModel.selectedPrivateChatPeer == nil },
+            set: { newValue in
+                if !newValue {
+                    showImagePicker = false
+                }
+            }
+        )) {
             ImagePickerView(sourceType: imagePickerSourceType) { image in
                 showImagePicker = false
                 if let image = image {
@@ -223,13 +408,18 @@ struct ContentView: View {
                     }
                 }
             }
-            .presentationDetents([.large])
-            .presentationDragIndicator(.hidden)
             .ignoresSafeArea()
         }
-#endif
+        #endif
-#if os(macOS)
+        #if os(macOS)
-        .sheet(isPresented: $showMacImagePicker) {
+        .sheet(isPresented: Binding(
+            get: { showMacImagePicker && !showSidebar && viewModel.selectedPrivateChatPeer == nil },
+            set: { newValue in
+                if !newValue {
+                    showMacImagePicker = false
+                }
+            }
+        )) {
             MacImagePickerView { url in
                 showMacImagePicker = false
                 if let url = url {
@@ -246,15 +436,7 @@ struct ContentView: View {
                 }
             }
         }
-#endif
+        #endif
-        .sheet(isPresented: Binding(
-            get: { imagePreviewURL != nil },
-            set: { presenting in if !presenting { imagePreviewURL = nil } }
-        )) {
-            if let url = imagePreviewURL {
-                ImagePreviewView(url: url)
-            }
-        }
         .alert("Recording Error", isPresented: $showRecordingAlert, actions: {
             Button("OK", role: .cancel) {}
         }, message: {
@@ -334,9 +516,9 @@ struct ContentView: View {
     
     // MARK: - Message List View
     
-    private func messagesView(privatePeer: String?, isAtBottom: Binding<Bool>) -> some View {
+    private func messagesView(privatePeer: PeerID?, isAtBottom: Binding<Bool>) -> some View {
         let messages: [BitchatMessage] = {
-            if let peerID = PeerID(str: privatePeer) {
+            if let peerID = privatePeer {
                 return viewModel.getPrivateChatMessages(for: peerID)
             }
             return viewModel.messages
@@ -476,7 +658,7 @@ struct ContentView: View {
             }
             .onChange(of: viewModel.privateChats) { _ in
                 if let peerID = privatePeer,
-                   let messages = viewModel.privateChats[PeerID(str: peerID)],
+                   let messages = viewModel.privateChats[peerID],
                    !messages.isEmpty {
                     // If the newest private message is from me, always scroll
                     let lastMsg = messages.last!
@@ -531,7 +713,7 @@ struct ContentView: View {
             }
             .onAppear {
                 // Also check when view appears
-                if let peerID = PeerID(str: privatePeer) {
+                if let peerID = privatePeer {
                     // Try multiple times to ensure read receipts are sent
                     viewModel.markPrivateMessagesAsRead(from: peerID)
                     
@@ -832,10 +1014,10 @@ struct ContentView: View {
     }
 
     private func scrollToBottom(on proxy: ScrollViewProxy,
-                                privatePeer: String?,
+                                privatePeer: PeerID?,
                                 isAtBottom: Binding<Bool>) {
         let targetID: String? = {
-            if let peer = PeerID(str: privatePeer),
+            if let peer = privatePeer,
                let last = viewModel.getPrivateChatMessages(for: peer).suffix(300).last?.id {
                 return "dm:\(peer)|\(last)"
             }
@@ -861,7 +1043,7 @@ struct ContentView: View {
 
         DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) {
             let secondTarget: String? = {
-                if let peer = PeerID(str: privatePeer),
+                if let peer = privatePeer,
                    let last = viewModel.getPrivateChatMessages(for: peer).suffix(300).last?.id {
                     return "dm:\(peer)|\(last)"
                 }
@@ -912,6 +1094,61 @@ struct ContentView: View {
         #if os(macOS)
         .frame(minWidth: 420, minHeight: 520)
         #endif
+        // MARK: - Image Picker for DM Context (Parent-Child Pattern)
+        // Present image picker when IN a sheet (DM or people sheet)
+        #if os(iOS)
+        .sheet(isPresented: Binding(
+            get: { showImagePicker && (showSidebar || viewModel.selectedPrivateChatPeer != nil) },
+            set: { newValue in
+                if !newValue {
+                    showImagePicker = false
+                }
+            }
+        )) {
+            ImagePickerView(sourceType: imagePickerSourceType) { image in
+                showImagePicker = false
+                if let image = image {
+                    Task {
+                        do {
+                            let processedURL = try ImageUtils.processImage(image)
+                            await MainActor.run {
+                                viewModel.sendImage(from: processedURL)
+                            }
+                        } catch {
+                            SecureLogger.error("Image processing failed: \(error)", category: .session)
+                        }
+                    }
+                }
+            }
+            .ignoresSafeArea()
+        }
+        #endif
+        #if os(macOS)
+        .sheet(isPresented: Binding(
+            get: { showMacImagePicker && (showSidebar || viewModel.selectedPrivateChatPeer != nil) },
+            set: { newValue in
+                if !newValue {
+                    showMacImagePicker = false
+                }
+            }
+        )) {
+            MacImagePickerView { url in
+                showMacImagePicker = false
+                if let url = url {
+                    Task {
+                        do {
+                            let processedURL = try ImageUtils.processImage(at: url)
+                            await MainActor.run {
+                                viewModel.sendImage(from: processedURL)
+                            }
+                        } catch {
+                            SecureLogger.error("Image processing failed: \(error)", category: .session)
+                        }
+                    }
+                }
+            }
+        }
+        #endif
     }
     
     // MARK: - People Sheet Views
@@ -998,14 +1235,14 @@ struct ContentView: View {
                             textColor: textColor,
                             secondaryTextColor: secondaryTextColor,
                             onTapPeer: { peerID in
-                                viewModel.startPrivateChat(with: PeerID(str: peerID))
+                                viewModel.startPrivateChat(with: peerID)
                                 showSidebar = true
                             },
                             onToggleFavorite: { peerID in
-                                viewModel.toggleFavorite(peerID: PeerID(str: peerID))
+                                viewModel.toggleFavorite(peerID: peerID)
                             },
                             onShowFingerprint: { peerID in
-                                viewModel.showFingerprint(for: PeerID(str: peerID))
+                                viewModel.showFingerprint(for: peerID)
                             }
                         )
                     }
@@ -1020,7 +1257,7 @@ struct ContentView: View {
 
     private var privateChatSheetView: some View {
         VStack(spacing: 0) {
-            if let privatePeerID = viewModel.selectedPrivateChatPeer?.id {
+            if let privatePeerID = viewModel.selectedPrivateChatPeer {
                 let headerContext = makePrivateHeaderContext(for: privatePeerID)
 
                 HStack(spacing: 12) {
@@ -1044,12 +1281,11 @@ struct ContentView: View {
 
                     HStack(spacing: 8) {
                         privateHeaderInfo(context: headerContext, privatePeerID: privatePeerID)
-                        let peerID = PeerID(str: headerContext.headerPeerID)
+                        let isFavorite = viewModel.isFavorite(peerID: headerContext.headerPeerID)
-                        let isFavorite = viewModel.isFavorite(peerID: peerID)
 
-                        if !privatePeerID.hasPrefix("nostr_") {
+                        if !privatePeerID.isGeoDM {
                             Button(action: {
-                                viewModel.toggleFavorite(peerID: peerID)
+                                viewModel.toggleFavorite(peerID: headerContext.headerPeerID)
                             }) {
                                 Image(systemName: isFavorite ? "star.fill" : "star")
                                     .font(.bitchatSystem(size: 14))
@@ -1088,7 +1324,7 @@ struct ContentView: View {
                 .background(backgroundColor)
             }
 
-            messagesView(privatePeer: viewModel.selectedPrivateChatPeer?.id, isAtBottom: $isAtBottomPrivate)
+            messagesView(privatePeer: viewModel.selectedPrivateChatPeer, isAtBottom: $isAtBottomPrivate)
                 .background(backgroundColor)
                 .frame(maxWidth: .infinity, maxHeight: .infinity)
             Divider()
@@ -1110,9 +1346,9 @@ struct ContentView: View {
         )
     }
 
-    private func privateHeaderInfo(context: PrivateHeaderContext, privatePeerID: String) -> some View {
+    private func privateHeaderInfo(context: PrivateHeaderContext, privatePeerID: PeerID) -> some View {
         Button(action: {
-            viewModel.showFingerprint(for: PeerID(str: context.headerPeerID))
+            viewModel.showFingerprint(for: context.headerPeerID)
         }) {
             HStack(spacing: 6) {
                 if let connectionState = context.peer?.connectionState {
@@ -1135,7 +1371,7 @@ struct ContentView: View {
                     case .offline:
                         EmptyView()
                     }
-                } else if viewModel.meshService.isPeerReachable(PeerID(str: context.headerPeerID)) {
+                } else if viewModel.meshService.isPeerReachable(context.headerPeerID) {
                     Image(systemName: "point.3.filled.connected.trianglepath.dotted")
                         .font(.bitchatSystem(size: 14))
                         .foregroundColor(textColor)
@@ -1145,7 +1381,7 @@ struct ContentView: View {
                         .font(.bitchatSystem(size: 14))
                         .foregroundColor(.purple)
                         .accessibilityLabel(String(localized: "content.accessibility.available_nostr", comment: "Accessibility label for Nostr-available peer indicator"))
-                } else if viewModel.meshService.isPeerConnected(PeerID(str: context.headerPeerID)) || viewModel.connectedPeers.contains(PeerID(str: context.headerPeerID)) {
+                } else if viewModel.meshService.isPeerConnected(context.headerPeerID) || viewModel.connectedPeers.contains(context.headerPeerID) {
                     Image(systemName: "dot.radiowaves.left.and.right")
                         .font(.bitchatSystem(size: 14))
                         .foregroundColor(textColor)
@@ -1156,14 +1392,14 @@ struct ContentView: View {
                     .font(.bitchatSystem(size: 16, weight: .medium, design: .monospaced))
                     .foregroundColor(textColor)
 
-                if !privatePeerID.hasPrefix("nostr_") {
+                if !privatePeerID.isGeoDM {
-                    let statusPeerID: String = {
+                    let statusPeerID: PeerID = {
-                        if privatePeerID.count == 64, let short = viewModel.getShortIDForNoiseKey(privatePeerID) {
+                        if privatePeerID.id.count == 64, let short = viewModel.getShortIDForNoiseKey(privatePeerID.id) {
-                            return short.id
+                            return short
                         }
                         return context.headerPeerID
                     }()
-                    let encryptionStatus = viewModel.getEncryptionStatus(for: PeerID(str: statusPeerID))
+                    let encryptionStatus = viewModel.getEncryptionStatus(for: statusPeerID)
                     if let icon = encryptionStatus.icon {
                         Image(systemName: icon)
                             .font(.bitchatSystem(size: 14))
@@ -1195,33 +1431,33 @@ struct ContentView: View {
         .frame(height: headerHeight)
     }
 
-    private func makePrivateHeaderContext(for privatePeerID: String) -> PrivateHeaderContext {
+    private func makePrivateHeaderContext(for privatePeerID: PeerID) -> PrivateHeaderContext {
-        let headerPeerID: String = {
+        let headerPeerID: PeerID = {
-            if privatePeerID.count == 64, let short = viewModel.getShortIDForNoiseKey(privatePeerID) {
+            if privatePeerID.id.count == 64, let short = viewModel.getShortIDForNoiseKey(privatePeerID.id) {
-                return short.id
+                return short
             }
             return privatePeerID
         }()
 
-        let peer = viewModel.getPeer(byID: PeerID(str: headerPeerID))
+        let peer = viewModel.getPeer(byID: headerPeerID)
 
         let displayName: String = {
-            if privatePeerID.hasPrefix("nostr_"), case .location(let ch) = locationManager.selectedChannel {
+            if privatePeerID.isGeoDM, case .location(let ch) = locationManager.selectedChannel {
-                let disp = viewModel.geohashDisplayName(for: PeerID(str: privatePeerID))
+                let disp = viewModel.geohashDisplayName(for: privatePeerID)
                 return "#\(ch.geohash)/@\(disp)"
             }
             if let name = peer?.displayName { return name }
-            if let name = viewModel.meshService.peerNickname(peerID: PeerID(str: headerPeerID)) { return name }
+            if let name = viewModel.meshService.peerNickname(peerID: headerPeerID) { return name }
-            if let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: Data(hexString: headerPeerID) ?? Data()),
+            if let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: Data(hexString: headerPeerID.id) ?? Data()),
                !fav.peerNickname.isEmpty { return fav.peerNickname }
-            if headerPeerID.count == 16 {
+            if headerPeerID.id.count == 16 {
-                let candidates = viewModel.identityManager.getCryptoIdentitiesByPeerIDPrefix(PeerID(str: headerPeerID))
+                let candidates = viewModel.identityManager.getCryptoIdentitiesByPeerIDPrefix(headerPeerID)
                 if let id = candidates.first,
                    let social = viewModel.identityManager.getSocialIdentity(for: id.fingerprint) {
                     if let pet = social.localPetname, !pet.isEmpty { return pet }
                     if !social.claimedNickname.isEmpty { return social.claimedNickname }
                 }
-            } else if headerPeerID.count == 64, let keyData = Data(hexString: headerPeerID) {
+            } else if let keyData = headerPeerID.noiseKey {
                 let fp = keyData.sha256Fingerprint()
                 if let social = viewModel.identityManager.getSocialIdentity(for: fp) {
                     if let pet = social.localPetname, !pet.isEmpty { return pet }
@@ -1233,7 +1469,7 @@ struct ContentView: View {
 
         let isNostrAvailable: Bool = {
             guard let connectionState = peer?.connectionState else {
-                if let noiseKey = Data(hexString: headerPeerID),
+                if let noiseKey = Data(hexString: headerPeerID.id),
                    let favoriteStatus = FavoritesPersistenceService.shared.getFavoriteStatus(for: noiseKey),
                    favoriteStatus.isMutual {
                     return true
@@ -1450,79 +1686,9 @@ struct ContentView: View {
                     showSidebar.toggle()
                 }
             }
-            .sheet(isPresented: $showVerifySheet) {
-                VerificationSheetView(isPresented: $showVerifySheet)
-                    .environmentObject(viewModel)
-            }
         }
         .frame(height: headerHeight)
         .padding(.horizontal, 12)
-        .sheet(isPresented: $showLocationChannelsSheet) {
-            LocationChannelsSheet(isPresented: $showLocationChannelsSheet)
-                .onAppear { viewModel.isLocationChannelsSheetPresented = true }
-                .onDisappear { viewModel.isLocationChannelsSheetPresented = false }
-        }
-        .sheet(isPresented: $showLocationNotes, onDismiss: {
-            notesGeohash = nil
-        }) {
-            Group {
-                if let gh = notesGeohash ?? LocationChannelManager.shared.availableChannels.first(where: { $0.level == .building })?.geohash {
-                    LocationNotesView(geohash: gh)
-                        .environmentObject(viewModel)
-                } else {
-                    VStack(spacing: 12) {
-                        HStack {
-                            Text("content.notes.title")
-                                .font(.bitchatSystem(size: 16, weight: .bold, design: .monospaced))
-                            Spacer()
-                            Button(action: { showLocationNotes = false }) {
-                                Image(systemName: "xmark")
-                                    .font(.bitchatSystem(size: 13, weight: .semibold, design: .monospaced))
-                                    .foregroundColor(textColor)
-                                    .frame(width: 32, height: 32)
-                            }
-                            .buttonStyle(.plain)
-                            .accessibilityLabel(String(localized: "common.close", comment: "Accessibility label for close buttons"))
-                        }
-                        .frame(height: headerHeight)
-                        .padding(.horizontal, 12)
-                        .background(backgroundColor.opacity(0.95))
-                        Text("content.notes.location_unavailable")
-                            .font(.bitchatSystem(size: 14, design: .monospaced))
-                            .foregroundColor(secondaryTextColor)
-                        Button("content.location.enable") {
-                            LocationChannelManager.shared.enableLocationChannels()
-                            LocationChannelManager.shared.refreshChannels()
-                        }
-                        .buttonStyle(.bordered)
-                        Spacer()
-                    }
-                    .background(backgroundColor)
-                    .foregroundColor(textColor)
-                    // per-sheet global onChange added below
-                }
-            }
-            .onAppear {
-                // Ensure we are authorized and start live location updates (distance-filtered)
-                LocationChannelManager.shared.enableLocationChannels()
-                LocationChannelManager.shared.beginLiveRefresh()
-            }
-            .onDisappear {
-                LocationChannelManager.shared.endLiveRefresh()
-            }
-            .onChange(of: locationManager.availableChannels) { channels in
-                if let current = channels.first(where: { $0.level == .building })?.geohash,
-                    notesGeohash != current {
-                    notesGeohash = current
-                    #if os(iOS)
-                    // Light taptic when geohash changes while the sheet is open
-                    let generator = UIImpactFeedbackGenerator(style: .light)
-                    generator.prepare()
-                    generator.impactOccurred()
-                    #endif
-                }
-            }
-        }
         .onAppear {
             if case .mesh = locationManager.selectedChannel,
                locationManager.permissionState == .authorized,
@@ -1752,7 +1918,7 @@ private extension ContentView {
 
     private func expandWindow(ifNeededFor message: BitchatMessage,
                               allMessages: [BitchatMessage],
-                              privatePeer: String?,
+                              privatePeer: PeerID?,
                               proxy: ScrollViewProxy) {
         let step = TransportConfig.uiWindowStepCount
         let contextKey: String = {
@@ -1812,7 +1978,19 @@ private extension ContentView {
     }
 
     private var shouldShowMediaControls: Bool {
-        if viewModel.selectedPrivateChatPeer != nil {
+        if let peer = viewModel.selectedPrivateChatPeer, !(peer.isGeoDM || peer.isGeoChat) {
+            return true
+        }
+        switch locationManager.selectedChannel {
+        case .mesh:
+            return true
+        case .location:
+            return false
+        }
+    }
+
+    private var shouldShowVoiceControl: Bool {
+        if let peer = viewModel.selectedPrivateChatPeer, !(peer.isGeoDM || peer.isGeoChat) {
             return true
         }
         switch locationManager.selectedChannel {
@@ -1857,17 +2035,23 @@ private extension ContentView {
         #endif
     }
 
+    @ViewBuilder
     var sendOrMicButton: some View {
         let hasText = !trimmedMessageText.isEmpty
-        return ZStack {
+        if shouldShowVoiceControl {
-            micButtonView
+            ZStack {
-                .opacity(hasText ? 0 : 1)
+                micButtonView
-                .allowsHitTesting(!hasText)
+                    .opacity(hasText ? 0 : 1)
+                    .allowsHitTesting(!hasText)
+                sendButtonView(enabled: hasText)
+                    .opacity(hasText ? 1 : 0)
+                    .allowsHitTesting(hasText)
+            }
+            .frame(width: 36, height: 36)
+        } else {
             sendButtonView(enabled: hasText)
-                .opacity(hasText ? 1 : 0)
+                .frame(width: 36, height: 36)
-                .allowsHitTesting(hasText)
         }
-        .frame(width: 36, height: 36)
     }
 
     private var micButtonView: some View {
@@ -1920,6 +2104,7 @@ private extension ContentView {
     }
 
     func startVoiceRecording() {
+        guard shouldShowVoiceControl else { return }
         guard !isRecordingVoiceNote && !isPreparingVoiceNote else { return }
         isPreparingVoiceNote = true
         Task { @MainActor in

bitchat/Views/FingerprintView.swift

@@ -10,7 +10,7 @@ import SwiftUI
 
 struct FingerprintView: View {
     @ObservedObject var viewModel: ChatViewModel
-    let peerID: String
+    let peerID: PeerID
     @Environment(\.dismiss) var dismiss
     @Environment(\.colorScheme) var colorScheme
     
@@ -65,15 +65,15 @@ struct FingerprintView: View {
             
             VStack(alignment: .leading, spacing: 16) {
                 // Prefer short mesh ID for session/encryption status
-                let statusPeerID: String = {
+                let statusPeerID: PeerID = {
-                    if peerID.count == 64, let short = viewModel.getShortIDForNoiseKey(peerID) { return short.id }
+                    if peerID.id.count == 64, let short = viewModel.getShortIDForNoiseKey(peerID.id) { return short }
                     return peerID
                 }()
                 // Resolve a friendly name
                 let peerNickname: String = {
-                    if let p = viewModel.getPeer(byID: PeerID(str: statusPeerID)) { return p.displayName }
+                    if let p = viewModel.getPeer(byID: statusPeerID) { return p.displayName }
-                    if let name = viewModel.meshService.peerNickname(peerID: PeerID(str: statusPeerID)) { return name }
+                    if let name = viewModel.meshService.peerNickname(peerID: statusPeerID) { return name }
-                    if peerID.count == 64, let data = Data(hexString: peerID) {
+                    if let data = peerID.noiseKey {
                         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) {
@@ -84,7 +84,7 @@ struct FingerprintView: View {
                     return Strings.unknownPeer()
                 }()
                 // Accurate encryption state based on short ID session
-                let encryptionStatus = viewModel.getEncryptionStatus(for: PeerID(str: statusPeerID))
+                let encryptionStatus = viewModel.getEncryptionStatus(for: statusPeerID)
                 
                 HStack {
                     if let icon = encryptionStatus.icon {
@@ -115,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: PeerID(str: statusPeerID)) {
+                    if let fingerprint = viewModel.getFingerprint(for: statusPeerID) {
                         Text(formatFingerprint(fingerprint))
                             .font(.bitchatSystem(size: 14, design: .monospaced))
                             .foregroundColor(textColor)
@@ -176,7 +176,6 @@ 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)
@@ -240,8 +239,6 @@ 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,9 +125,6 @@ struct LocationChannelsSheet: View {
             .navigationTitle("")
             #endif
         }
-        #if os(iOS)
-        .presentationDetents([.large])
-        #endif
         #if os(macOS)
         .frame(minWidth: 420, minHeight: 520)
         #endif

bitchat/Views/LocationNotesView.swift

@@ -78,9 +78,6 @@ struct LocationNotesView: View {
             .navigationTitle("")
             #endif
         }
-       #if os(iOS)
-        .presentationDetents([.large])
-        #endif
         .background(backgroundColor)
         .onDisappear { manager.cancel() }
         .onChange(of: geohash) { newValue in

bitchat/Views/MeshPeerList.swift

@@ -4,9 +4,9 @@ struct MeshPeerList: View {
     @ObservedObject var viewModel: ChatViewModel
     let textColor: Color
     let secondaryTextColor: Color
-    let onTapPeer: (String) -> Void
+    let onTapPeer: (PeerID) -> Void
-    let onToggleFavorite: (String) -> Void
+    let onToggleFavorite: (PeerID) -> Void
-    let onShowFingerprint: (String) -> Void
+    let onShowFingerprint: (PeerID) -> Void
     @Environment(\.colorScheme) var colorScheme
 
     @State private var orderedIDs: [String] = []
@@ -130,7 +130,7 @@ struct MeshPeerList: View {
                         }
 
                         if !isMe {
-                            Button(action: { onToggleFavorite(peer.peerID.id) }) {
+                            Button(action: { onToggleFavorite(peer.peerID) }) {
                                 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.id) } }
+                    .onTapGesture { if !isMe { onTapPeer(peer.peerID) } }
-                    .onTapGesture(count: 2) { if !isMe { onShowFingerprint(peer.peerID.id) } }
+                    .onTapGesture(count: 2) { if !isMe { onShowFingerprint(peer.peerID) } }
                 }
             }
             // Seed and update order outside result builder

bitchat/Views/VerificationViews.swift

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

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 = "0123456789abcdef" // 8-byte hex peer ID
+        let senderPeerID = PeerID(str: "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 = "fedcba9876543210" // 8-byte hex peer ID
+        let senderPeerID = PeerID(str: "fedcba9876543210") // 8-byte hex peer ID
         let embedded = try #require(
             NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(type: .readReceipt, messageID: messageID, senderPeerID: senderPeerID),
             "Failed to embed read ack"

localPackages/BitLogger/Package.swift

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

localPackages/BitLogger/Sources/SecureLogger.swift

@@ -68,22 +68,6 @@ 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 {
@@ -161,8 +145,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 = sanitize(context())
+        let sanitized = context().sanitized()
-        let errorDesc = sanitize(error.localizedDescription)
+        let errorDesc = error.localizedDescription.sanitized()
         
         #if DEBUG
         os_log("%{public}@ Error in %{public}@: %{public}@", log: category, type: .error, location, sanitized, errorDesc)
@@ -186,15 +170,15 @@ public extension SecureLogger {
         var message: String {
             switch self {
             case .handshakeStarted(let peerID):
-                return "Handshake started with peer: \(sanitize(peerID))"
+                return "Handshake started with peer: \(peerID.sanitized())"
             case .handshakeCompleted(let peerID):
-                return "Handshake completed with peer: \(sanitize(peerID))"
+                return "Handshake completed with peer: \(peerID.sanitized())"
             case .handshakeFailed(let peerID, let error):
-                return "Handshake failed with peer: \(sanitize(peerID)), error: \(error)"
+                return "Handshake failed with peer: \(peerID.sanitized()), error: \(error)"
             case .sessionExpired(let peerID):
-                return "Session expired for peer: \(sanitize(peerID))"
+                return "Session expired for peer: \(peerID.sanitized())"
             case .authenticationFailed(let peerID):
-                return "Authentication failed for peer: \(sanitize(peerID))"
+                return "Authentication failed for peer: \(peerID.sanitized())"
             }
         }
     }
@@ -249,7 +233,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 = sanitize("\(location) \(message())")
+        let sanitized = "\(location) \(message())".sanitized()
         
         #if DEBUG
         os_log("%{public}@", log: category, type: level.osLogType, sanitized)
@@ -282,58 +266,6 @@ 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

@@ -0,0 +1,67 @@
+//
+// 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

@@ -0,0 +1,143 @@
+//
+//  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)
+    }
+}