project: add TransportConfig.swift to Share Extension target to fix build

Add comprehensive TransportConfig constants for UI, Nostr, and BLE; adopt across ChatViewModel, ContentView, BLEService, ShareViewController, and BitchatApp to remove scattered literals. Standardize Nostr lookbacks/limits, UI delays/animations, and BLE announce/duty-cycle/candidate caps. Preserve behavior while making tuning explicit and safe.

Highlights:\n- UI: animations, scroll throttle, long-message thresholds, batch stagger, color hue tuning, rate-limit buckets, read-receipt debounce, startup delays, share accept/dismiss windows, migration cutoff.\n- Nostr: short display length (8), conv-key prefix length (16), DM lookback (24h), geohash sample lookback/limits; consistent use throughout ChatViewModel.\n- BLE: dynamic RSSI defaults, announce intervals/base+jitter, duty cycles (dense/sparse), fragment/ingress lifetimes, expected write timings/spacing, recent packet window (30s/100), peer inactivity timeout; unified candidate caps (100).\n- Share: use constant dismiss delay; App: use constant share accept window.\n\nRisk/impact: behavior-equivalent with centralized knobs; easier to tune without code edits.

.gitignore

@@ -71,3 +71,7 @@ __pycache__/
 # Local build results
 .Result*/
 .Result*.xcresult/
+TestResult.xcresult/
+*.xcresult/
+build.log
+*.log

bitchat.xcodeproj/project.pbxproj

@@ -29,6 +29,9 @@
 		047502B72E55FED60083520F /* GeohashPeopleList.swift in Sources */ = {isa = PBXBuildFile; fileRef = 047502B22E55FED60083520F /* GeohashPeopleList.swift */; };
 		047502B92E560F690083520F /* RelayController.swift in Sources */ = {isa = PBXBuildFile; fileRef = 047502B82E560F690083520F /* RelayController.swift */; };
 		047502BA2E560F690083520F /* RelayController.swift in Sources */ = {isa = PBXBuildFile; fileRef = 047502B82E560F690083520F /* RelayController.swift */; };
+		048A4BE72E5CCCC300162C4A /* TransportConfig.swift in Sources */ = {isa = PBXBuildFile; fileRef = 048A4BE62E5CCCC300162C4A /* TransportConfig.swift */; };
+		048A4BE82E5CCCC300162C4A /* TransportConfig.swift in Sources */ = {isa = PBXBuildFile; fileRef = 048A4BE62E5CCCC300162C4A /* TransportConfig.swift */; };
+		048A4BE92E5CCCC300162C4B /* TransportConfig.swift in Sources */ = {isa = PBXBuildFile; fileRef = 048A4BE62E5CCCC300162C4A /* TransportConfig.swift */; };
 		049BD3902E4EC4F0001A566B /* PrivateChatManager.swift in Sources */ = {isa = PBXBuildFile; fileRef = 049BD38F2E4EC4F0001A566B /* PrivateChatManager.swift */; };
 		049BD3912E4EC4F0001A566B /* AutocompleteService.swift in Sources */ = {isa = PBXBuildFile; fileRef = 049BD38C2E4EC4F0001A566B /* AutocompleteService.swift */; };
 		049BD3922E4EC4F0001A566B /* CommandProcessor.swift in Sources */ = {isa = PBXBuildFile; fileRef = 049BD38D2E4EC4F0001A566B /* CommandProcessor.swift */; };
@@ -56,6 +59,8 @@
 		0AE840940F21AFC07C226636 /* PrivateChatE2ETests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8A262EDDC04B7D7B5E31F321 /* PrivateChatE2ETests.swift */; };
 		0B6F25559A21F8C69C8357C6 /* BinaryProtocolTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0B3CC6FA298729906109F61B /* BinaryProtocolTests.swift */; };
 		10E68BB889356219189E38EC /* BitchatApp.swift in Sources */ = {isa = PBXBuildFile; fileRef = EF625BB3AD919322C01A46B2 /* BitchatApp.swift */; };
+		1234567890ABCDEFFEDCBA13 /* PeerDisplayNameResolver.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1234567890ABCDEFFEDCBA02 /* PeerDisplayNameResolver.swift */; };
+		1234567890ABCDEFFEDCBA14 /* PeerDisplayNameResolver.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1234567890ABCDEFFEDCBA02 /* PeerDisplayNameResolver.swift */; };
 		132DF1E24B4E9C7DCDAD4376 /* FingerprintView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9195CDC7EB236AFBC9A4D41A /* FingerprintView.swift */; };
 		17901751FD8010AFC8E750F2 /* bitchatShareExtension.appex in Embed Foundation Extensions */ = {isa = PBXBuildFile; fileRef = 61F92EBA29C47C0FCC482F1F /* bitchatShareExtension.appex */; settings = {ATTRIBUTES = (RemoveHeadersOnCopy, ); }; };
 		1D9674FA5F998503831DC281 /* ContentView.swift in Sources */ = {isa = PBXBuildFile; fileRef = A08E03AA0C63E97C91749AEC /* ContentView.swift */; };
@@ -102,11 +107,17 @@
 		9C7D287C8E67AAE576A5ECB7 /* ShareViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = C1B378C16594575FCC7F9C75 /* ShareViewController.swift */; };
 		9CCF09F7527EC681A13FC246 /* NoiseSecurityConsiderations.swift in Sources */ = {isa = PBXBuildFile; fileRef = 43B4548DAFC9F7AA8873DA53 /* NoiseSecurityConsiderations.swift */; };
 		A0A1C26EFBFDD5B8EFEEDE57 /* PublicChatE2ETests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D22BF09A49010947CEFE45E2 /* PublicChatE2ETests.swift */; };
+		A1B2C3D44E5F60718293A4B5 /* XChaCha20Poly1305Compat.swift in Sources */ = {isa = PBXBuildFile; fileRef = A1B2C3D44E5F60718293A4B4 /* XChaCha20Poly1305Compat.swift */; };
+		A1B2C3D54E5F60718293A4B6 /* XChaCha20Poly1305Compat.swift in Sources */ = {isa = PBXBuildFile; fileRef = A1B2C3D44E5F60718293A4B4 /* XChaCha20Poly1305Compat.swift */; };
 		A2977428C1D9EF9944C4BFAF /* BLEServiceTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 980B109CBA72BC996455C62B /* BLEServiceTests.swift */; };
 		A7187D48B07C6857DE01D0ED /* NoiseProtocol.swift in Sources */ = {isa = PBXBuildFile; fileRef = 43613045E63D21D429396805 /* NoiseProtocol.swift */; };
 		AA11BB22CC33DD44EE55FF66 /* MessageTextHelpers.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA11BB22CC33DD44EE55FF68 /* MessageTextHelpers.swift */; };
 		AA11BB22CC33DD44EE55FF67 /* MessageTextHelpers.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA11BB22CC33DD44EE55FF68 /* MessageTextHelpers.swift */; };
 		AA6E067DB034FC0FA23C28A9 /* BinaryProtocolTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0B3CC6FA298729906109F61B /* BinaryProtocolTests.swift */; };
+		AA77BB11CC22DD33EE44FF55 /* VerificationService.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA77BB10CC22DD33EE44FF55 /* VerificationService.swift */; };
+		AA77BB12CC22DD33EE44FF56 /* VerificationService.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA77BB10CC22DD33EE44FF55 /* VerificationService.swift */; };
+		AA77BB14CC22DD33EE44FF58 /* VerificationViews.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA77BB13CC22DD33EE44FF57 /* VerificationViews.swift */; };
+		AA77BB15CC22DD33EE44FF59 /* VerificationViews.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA77BB13CC22DD33EE44FF57 /* VerificationViews.swift */; };
 		ABAF130D88561F4A646F0430 /* AppInfoView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 763E0DBA9492A654FC0CDCB9 /* AppInfoView.swift */; };
 		ACE2ED172C37F01561E50B71 /* FavoritesPersistenceService.swift in Sources */ = {isa = PBXBuildFile; fileRef = 419BFFF209EBA93F410E9E9F /* FavoritesPersistenceService.swift */; };
 		AD11E46940D742AEAF547EB2 /* AppInfoView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 763E0DBA9492A654FC0CDCB9 /* AppInfoView.swift */; };
@@ -140,12 +151,6 @@
 		F455F011B3B648ADA233F998 /* BinaryProtocol.swift in Sources */ = {isa = PBXBuildFile; fileRef = A2136C3E22D02D4A8DBE7EAB /* BinaryProtocol.swift */; };
 		FB8819B4C84FAFEF5C36B216 /* KeychainManager.swift in Sources */ = {isa = PBXBuildFile; fileRef = 136696FC4436A02D98CE6A77 /* KeychainManager.swift */; };
 		FBC409E105493C491531B59A /* NostrProtocol.swift in Sources */ = {isa = PBXBuildFile; fileRef = 2E5A9FF4AEA8A923317ED26A /* NostrProtocol.swift */; };
-		A1B2C3D44E5F60718293A4B5 /* XChaCha20Poly1305Compat.swift in Sources */ = {isa = PBXBuildFile; fileRef = A1B2C3D44E5F60718293A4B4 /* XChaCha20Poly1305Compat.swift */; };
-		A1B2C3D54E5F60718293A4B6 /* XChaCha20Poly1305Compat.swift in Sources */ = {isa = PBXBuildFile; fileRef = A1B2C3D44E5F60718293A4B4 /* XChaCha20Poly1305Compat.swift */; };
-		AA77BB11CC22DD33EE44FF55 /* VerificationService.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA77BB10CC22DD33EE44FF55 /* VerificationService.swift */; };
-		AA77BB12CC22DD33EE44FF56 /* VerificationService.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA77BB10CC22DD33EE44FF55 /* VerificationService.swift */; };
-		AA77BB14CC22DD33EE44FF58 /* VerificationViews.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA77BB13CC22DD33EE44FF57 /* VerificationViews.swift */; };
-		AA77BB15CC22DD33EE44FF59 /* VerificationViews.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA77BB13CC22DD33EE44FF57 /* VerificationViews.swift */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXContainerItemProxy section */
@@ -199,6 +204,7 @@
 		047502B22E55FED60083520F /* GeohashPeopleList.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GeohashPeopleList.swift; sourceTree = "<group>"; };
 		047502B32E55FED60083520F /* MeshPeerList.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MeshPeerList.swift; sourceTree = "<group>"; };
 		047502B82E560F690083520F /* RelayController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RelayController.swift; sourceTree = "<group>"; };
+		048A4BE62E5CCCC300162C4A /* TransportConfig.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TransportConfig.swift; sourceTree = "<group>"; };
 		049BD38C2E4EC4F0001A566B /* AutocompleteService.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AutocompleteService.swift; sourceTree = "<group>"; };
 		049BD38D2E4EC4F0001A566B /* CommandProcessor.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CommandProcessor.swift; sourceTree = "<group>"; };
 		049BD38F2E4EC4F0001A566B /* PrivateChatManager.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PrivateChatManager.swift; sourceTree = "<group>"; };
@@ -214,6 +220,7 @@
 		05BA20BC0F123F1507C5C247 /* IdentityModels.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = IdentityModels.swift; sourceTree = "<group>"; };
 		0B3CC6FA298729906109F61B /* BinaryProtocolTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BinaryProtocolTests.swift; sourceTree = "<group>"; };
 		11186E29A064E8D210880E1B /* BitchatPeer.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BitchatPeer.swift; sourceTree = "<group>"; };
+		1234567890ABCDEFFEDCBA02 /* PeerDisplayNameResolver.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PeerDisplayNameResolver.swift; sourceTree = "<group>"; };
 		136696FC4436A02D98CE6A77 /* KeychainManager.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = KeychainManager.swift; sourceTree = "<group>"; };
 		229F17B68CFF7AB1BC91C847 /* BitchatProtocol.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BitchatProtocol.swift; sourceTree = "<group>"; };
 		2E346DF8E026FD34EE3DD038 /* TestHelpers.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TestHelpers.swift; sourceTree = "<group>"; };
@@ -244,8 +251,11 @@
 		980B109CBA72BC996455C62B /* BLEServiceTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BLEServiceTests.swift; sourceTree = "<group>"; };
 		9AB6BE4ABD7F5088E9865E56 /* NoiseSession.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NoiseSession.swift; sourceTree = "<group>"; };
 		A08E03AA0C63E97C91749AEC /* ContentView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ContentView.swift; sourceTree = "<group>"; };
+		A1B2C3D44E5F60718293A4B4 /* XChaCha20Poly1305Compat.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = XChaCha20Poly1305Compat.swift; sourceTree = "<group>"; };
 		A2136C3E22D02D4A8DBE7EAB /* BinaryProtocol.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BinaryProtocol.swift; sourceTree = "<group>"; };
 		AA11BB22CC33DD44EE55FF68 /* MessageTextHelpers.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MessageTextHelpers.swift; sourceTree = "<group>"; };
+		AA77BB10CC22DD33EE44FF55 /* VerificationService.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = VerificationService.swift; sourceTree = "<group>"; };
+		AA77BB13CC22DD33EE44FF57 /* VerificationViews.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = VerificationViews.swift; sourceTree = "<group>"; };
 		B1D6A89B36A3D31E590B94E5 /* NoiseHandshakeCoordinator.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NoiseHandshakeCoordinator.swift; sourceTree = "<group>"; };
 		C0DB1DE27F0AAB5092663E8E /* bitchatTests_iOS.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = bitchatTests_iOS.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
 		C1B378C16594575FCC7F9C75 /* ShareViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ShareViewController.swift; sourceTree = "<group>"; };
@@ -264,9 +274,6 @@
 		FDC18D910D6FF2E8B1B6C885 /* SecureIdentityStateManager.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SecureIdentityStateManager.swift; sourceTree = "<group>"; };
 		FE7CCF2BD78A3F3DAE6DA145 /* MockBLEService.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MockBLEService.swift; sourceTree = "<group>"; };
 		FF7AF93D874001FBD94C8306 /* bitchat-macOS.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text.plist.entitlements; path = "bitchat-macOS.entitlements"; sourceTree = "<group>"; };
-		A1B2C3D44E5F60718293A4B4 /* XChaCha20Poly1305Compat.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = XChaCha20Poly1305Compat.swift; sourceTree = "<group>"; };
-		AA77BB10CC22DD33EE44FF55 /* VerificationService.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = VerificationService.swift; sourceTree = "<group>"; };
-		AA77BB13CC22DD33EE44FF57 /* VerificationViews.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = VerificationViews.swift; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -321,6 +328,7 @@
 				A2E8C336FA1ADBEC03261DFD /* bitchatShareExtension */,
 				C3D98EB3E1B455E321F519F4 /* bitchatTests */,
 				9F37F9F2C353B58AC809E93B /* Products */,
+				048A4BE52E5CCC5C00162C4A /* Recovered References */,
 			);
 			sourceTree = "<group>";
 		};
@@ -403,6 +411,7 @@
 		9A78348821A7D3374607D4E3 /* Utils */ = {
 			isa = PBXGroup;
 			children = (
+				1234567890ABCDEFFEDCBA02 /* PeerDisplayNameResolver.swift */,
 				049BD3AA2E51E38E001A566B /* PeerIDResolver.swift */,
 				049BD3A42E51DC0E001A566B /* MessageDeduplicator.swift */,
 				32F149C43D1915831B60FE09 /* CompressionUtil.swift */,
@@ -511,6 +520,7 @@
 		D98A3186D7E4C72E35BDF7FE /* Services */ = {
 			isa = PBXGroup;
 			children = (
+				048A4BE62E5CCCC300162C4A /* TransportConfig.swift */,
 				AA77BB10CC22DD33EE44FF55 /* VerificationService.swift */,
 				047502B82E560F690083520F /* RelayController.swift */,
 				0475028B2E54171C0083520F /* LocationChannelManager.swift */,
@@ -724,6 +734,7 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				048A4BE92E5CCCC300162C4B /* TransportConfig.swift in Sources */,
 				9C7D287C8E67AAE576A5ECB7 /* ShareViewController.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
@@ -732,11 +743,14 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+                048A4BE72E5CCCC300162C4A /* TransportConfig.swift in Sources */,
+                1234567890ABCDEFFEDCBA13 /* PeerDisplayNameResolver.swift in Sources */,
 				AA77BB12CC22DD33EE44FF56 /* VerificationService.swift in Sources */,
 				AA77BB15CC22DD33EE44FF59 /* VerificationViews.swift in Sources */,
 				A1B2C3D54E5F60718293A4B6 /* XChaCha20Poly1305Compat.swift in Sources */,
 				AD11E46940D742AEAF547EB2 /* AppInfoView.swift in Sources */,
 				9B51E9B63A3EA59B1A7874BD /* BinaryEncodingUtils.swift in Sources */,
+
 				049BD3B42E51F319001A566B /* NostrTransport.swift in Sources */,
 				049BD3B52E51F319001A566B /* MessageRouter.swift in Sources */,
 				4B747085D07A1BCE0F5BA612 /* BinaryProtocol.swift in Sources */,
@@ -789,11 +803,14 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+                048A4BE82E5CCCC300162C4A /* TransportConfig.swift in Sources */,
+                1234567890ABCDEFFEDCBA14 /* PeerDisplayNameResolver.swift in Sources */,
 				AA77BB11CC22DD33EE44FF55 /* VerificationService.swift in Sources */,
 				AA77BB14CC22DD33EE44FF58 /* VerificationViews.swift in Sources */,
 				A1B2C3D44E5F60718293A4B5 /* XChaCha20Poly1305Compat.swift in Sources */,
 				ABAF130D88561F4A646F0430 /* AppInfoView.swift in Sources */,
 				AFB6AEFCABBE97441CB3102B /* BinaryEncodingUtils.swift in Sources */,
+
 				049BD3B22E51F319001A566B /* NostrTransport.swift in Sources */,
 				049BD3B32E51F319001A566B /* MessageRouter.swift in Sources */,
 				F455F011B3B648ADA233F998 /* BinaryProtocol.swift in Sources */,

bitchat/BitchatApp.swift

@@ -99,30 +99,18 @@ struct BitchatApp: App {
             return
         }
         
-        // Only process if shared within last 30 seconds
-        if Date().timeIntervalSince(sharedDate) < 30 {
+        // Only process if shared within configured window
+        if Date().timeIntervalSince(sharedDate) < TransportConfig.uiShareAcceptWindowSeconds {
             let contentType = userDefaults.string(forKey: "sharedContentType") ?? "text"
             
             // Clear the shared content
             userDefaults.removeObject(forKey: "sharedContent")
             userDefaults.removeObject(forKey: "sharedContentType")
             userDefaults.removeObject(forKey: "sharedContentDate")
-            userDefaults.synchronize()
+            // No need to force synchronize here
             
-            // Show notification about shared content
+            // Send the shared content immediately on the main queue
             DispatchQueue.main.async {
-                // Add system message about sharing
-                let systemMessage = BitchatMessage(
-                    sender: "system",
-                    content: "preparing to share \(contentType)...",
-                    timestamp: Date(),
-                    isRelay: false
-                )
-                self.chatViewModel.messages.append(systemMessage)
-            }
-            
-            // Send the shared content after a short delay
-            DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
                 if contentType == "url" {
                     // Try to parse as JSON first
                     if let data = sharedContent.data(using: .utf8),

bitchat/Identity/IdentityModels.swift

@@ -173,56 +173,7 @@ struct PendingActions {
     var setPetname: String?
 }
 
-// MARK: - Privacy Settings
-
-struct PrivacySettings: Codable {
-    // Level 1: Maximum privacy (default)
-    var persistIdentityCache = false
-    var showLastSeen = false
-    
-    // Level 2: Convenience
-    var autoAcceptKnownFingerprints = false
-    var rememberNicknameHistory = false
-    
-    // Level 3: Social
-    var shareTrustNetworkHints = false  // "3 mutual contacts trust this person"
-}
-
-// MARK: - Conflict Resolution
-
-/// Strategies for resolving identity conflicts in the decentralized network.
-/// Handles cases where multiple peers claim the same nickname or when
-/// identity mappings become ambiguous due to network partitions.
-enum ConflictResolution {
-    case acceptNew(petname: String)      // "John (2)"
-    case rejectNew
-    case blockFingerprint(String)
-    case alertUser(message: String)
-}
-
-// MARK: - UI State
-
-struct PeerUIState {
-    let peerID: String
-    let nickname: String
-    var identityState: IdentityState
-    var connectionQuality: ConnectionQuality
-    
-    enum IdentityState {
-        case unknown                    // Gray - No identity info
-        case unverifiedKnown(String)   // Blue - Handshake done, matches cache
-        case verified(String)          // Green - Cryptographically verified
-        case conflict(String, String)  // Red - Nickname doesn't match fingerprint
-        case pending                   // Yellow - Handshake in progress
-    }
-}
-
-enum ConnectionQuality {
-    case excellent
-    case good
-    case poor
-    case disconnected
-}
+//
 
 // MARK: - Migration Support
-// Removed LegacyFavorite - no longer needed
+//

bitchat/Models/BitchatPeer.swift

@@ -89,219 +89,4 @@ struct BitchatPeer: Identifiable, Equatable {
     }
 }
 
-// MARK: - Peer Manager
-
-/// Manages the collection of peers and their states
-@MainActor
-class PeerManager: ObservableObject {
-    @Published var peers: [BitchatPeer] = []
-    @Published var favorites: [BitchatPeer] = []
-    @Published var mutualFavorites: [BitchatPeer] = []
-    
-    private let meshService: Transport
-    private let favoritesService = FavoritesPersistenceService.shared
-    
-    init(meshService: Transport) {
-        self.meshService = meshService
-        updatePeers()
-        
-        // Listen for updates
-        NotificationCenter.default.addObserver(
-            self,
-            selector: #selector(handleFavoriteChanged),
-            name: .favoriteStatusChanged,
-            object: nil
-        )
-    }
-    
-    @objc private func handleFavoriteChanged() {
-        SecureLogger.log("⭐ Favorite status changed notification received, updating peers", 
-                        category: SecureLogger.session, level: .debug)
-        updatePeers()
-    }
-    
-    deinit {
-        NotificationCenter.default.removeObserver(self)
-    }
-    
-    func updatePeers() {
-        // Reduce log verbosity - only log when count changes
-        let previousCount = peers.count
-        
-        // Get current mesh peers
-        let meshPeers = meshService.getPeerNicknames()
-        
-        // Build peer list
-        var allPeers: [BitchatPeer] = []
-        var connectedNicknames: Set<String> = []
-        var addedPeerIDs: Set<String> = []
-        
-        // Add connected mesh peers (only if actually connected or relay connected)
-        for (peerID, nickname) in meshPeers {
-            guard let noiseKey = Data(hexString: peerID) else { continue }
-            
-            // Safety check: Never add our own peer ID
-            if peerID == meshService.myPeerID {
-                continue
-            }
-            
-            // Check if this peer is actually connected
-            let isConnected = meshService.isPeerConnected(peerID)
-            
-            // Skip disconnected peers unless they're favorites (handled later)
-            if !isConnected {
-                continue
-            }
-            
-            if isConnected {
-                connectedNicknames.insert(nickname)
-            }
-            
-            // Track that we've added this peer ID
-            addedPeerIDs.insert(peerID)
-            
-            var peer = BitchatPeer(
-                id: peerID,
-                noisePublicKey: noiseKey,
-                nickname: nickname,
-                isConnected: isConnected
-            )
-            // Set favorite status - check both by current noise key and by nickname
-            if let favoriteStatus = favoritesService.getFavoriteStatus(for: noiseKey) {
-                peer.favoriteStatus = favoriteStatus
-                peer.nostrPublicKey = favoriteStatus.peerNostrPublicKey
-            } else {
-                // Check if we have a favorite for this nickname (peer may have reconnected with new ID)
-                let favoriteByNickname = favoritesService.favorites.values.first { $0.peerNickname == nickname }
-                if let favorite = favoriteByNickname {
-                    SecureLogger.log("🔄 Found favorite for '\(nickname)' by nickname, updating noise key", 
-                                    category: SecureLogger.session, level: .info)
-                    // Update the favorite's noise key to match the current connection
-                    favoritesService.updateNoisePublicKey(from: favorite.peerNoisePublicKey, to: noiseKey, peerNickname: nickname)
-                    // Get the updated favorite with the new key
-                    peer.favoriteStatus = favoritesService.getFavoriteStatus(for: noiseKey)
-                    peer.nostrPublicKey = peer.favoriteStatus?.peerNostrPublicKey ?? favorite.peerNostrPublicKey
-                }
-            }
-            allPeers.append(peer)
-        }
-        
-        // Add offline favorites (only those not currently connected AND that we actively favorite)
-        
-        for (favoriteKey, favorite) in favoritesService.favorites {
-            let favoriteID = favorite.peerNoisePublicKey.hexEncodedString()
-            
-            // Skip if this peer is already connected (by nickname)
-            if connectedNicknames.contains(favorite.peerNickname) {
-                // Skipping favorite - already connected
-                continue
-            }
-            
-            // Skip if we already added a peer with this ID (prevents duplicates)
-            if addedPeerIDs.contains(favoriteID) {
-                // Skipping favorite - peer ID already added
-                continue
-            }
-            
-            // Only add peers that WE favorite (not just ones who favorite us)
-            if !favorite.isFavorite {
-                // Skipping - we don't favorite them
-                continue
-            }
-            
-            // Add this favorite as an offline peer
-            SecureLogger.log("  - Adding offline favorite '\(favorite.peerNickname)' (key: \(favoriteKey.hexEncodedString()), ID: \(favoriteID), mutual: \(favorite.isMutual))", 
-                            category: SecureLogger.session, level: .info)
-            
-            var peer = BitchatPeer(
-                id: favoriteID,
-                noisePublicKey: favorite.peerNoisePublicKey,
-                nickname: favorite.peerNickname,
-                isConnected: false
-            )
-            // Set favorite status
-            peer.favoriteStatus = favorite
-            peer.nostrPublicKey = favorite.peerNostrPublicKey
-            addedPeerIDs.insert(favoriteID)  // Track that we've added this ID
-            allPeers.append(peer)
-        }
-        
-        // Filter out "Unknown" peers unless they are favorites or have a favorite relationship
-        allPeers = allPeers.filter { peer in
-            !(peer.displayName == "Unknown" && peer.favoriteStatus == nil)
-        }
-        
-        // Sort: Connected first, then favorites, then alphabetical
-        allPeers.sort { lhs, rhs in
-            // Direct connections first
-            if lhs.isConnected != rhs.isConnected {
-                return lhs.isConnected
-            }
-            // Then favorites
-            if lhs.isFavorite != rhs.isFavorite {
-                return lhs.isFavorite
-            }
-            // Finally alphabetical
-            return lhs.displayName < rhs.displayName
-        }
-        
-        // Single pass to compute all subsets and counts
-        var favorites: [BitchatPeer] = []
-        var mutualFavorites: [BitchatPeer] = []
-        var connectedCount = 0
-        var offlineCount = 0
-        
-        for peer in allPeers {
-            if peer.isFavorite {
-                favorites.append(peer)
-            }
-            if peer.isMutualFavorite {
-                mutualFavorites.append(peer)
-            }
-            if peer.isConnected {
-                connectedCount += 1
-            } else {
-                offlineCount += 1
-            }
-        }
-        
-        // Final safety check: ensure no duplicate IDs
-        var finalPeers: [BitchatPeer] = []
-        var seenIDs: Set<String> = []
-        for peer in allPeers {
-            if !seenIDs.contains(peer.id) {
-                seenIDs.insert(peer.id)
-                finalPeers.append(peer)
-            } else {
-                SecureLogger.log("⚠️ Removing duplicate peer ID in final check: \(peer.id) (\(peer.displayName))", 
-                               category: SecureLogger.session, level: .warning)
-            }
-        }
-        
-        self.peers = finalPeers
-        self.favorites = favorites
-        self.mutualFavorites = mutualFavorites
-        
-        // Log peer list summary sparingly at debug level
-        if favoritesService.favorites.count > 0 {
-            SecureLogger.log("📊 Peer list update: \(allPeers.count) total (\(connectedCount) connected, \(offlineCount) offline), \(favorites.count) favorites, \(mutualFavorites.count) mutual", 
-                            category: SecureLogger.session, level: .debug)
-        } else if previousCount != allPeers.count {
-            SecureLogger.log("✅ Updated peer list: \(allPeers.count) total peers", 
-                            category: SecureLogger.session, level: .debug)
-        }
-    }
-    
-    func toggleFavorite(_ peer: BitchatPeer) {
-        if peer.isFavorite {
-            favoritesService.removeFavorite(peerNoisePublicKey: peer.noisePublicKey)
-        } else {
-            favoritesService.addFavorite(
-                peerNoisePublicKey: peer.noisePublicKey,
-                peerNostrPublicKey: peer.nostrPublicKey,
-                peerNickname: peer.nickname
-            )
-        }
-        updatePeers()
-    }
-}
+//

bitchat/Nostr/GeoRelayDirectory.swift

@@ -14,7 +14,7 @@ final class GeoRelayDirectory {
     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 = 60 * 60 * 24 // 24h
+    private let fetchInterval: TimeInterval = TransportConfig.geoRelayFetchIntervalSeconds // 24h
 
     private init() {
         // Load cached or bundled data synchronously

bitchat/Nostr/NostrProtocol.swift

@@ -122,8 +122,8 @@ struct NostrProtocol {
             tags: tags,
             content: content
         )
-        let signingKey = try senderIdentity.signingKey()
-        return try event.sign(with: signingKey)
+        let schnorrKey = try senderIdentity.schnorrSigningKey()
+        return try event.sign(with: schnorrKey)
     }
     
     // MARK: - Private Methods
@@ -149,9 +149,8 @@ struct NostrProtocol {
             content: encrypted
         )
         
-        // Convert to P256K.Signing.PrivateKey for signing (temporary until we update sign method)
-        let signingKey = try P256K.Signing.PrivateKey(dataRepresentation: senderKey.dataRepresentation)
-        return try seal.sign(with: signingKey)
+        // Sign the seal with the sender's Schnorr private key
+        return try seal.sign(with: senderKey)
     }
     
     private static func createGiftWrap(
@@ -181,9 +180,8 @@ struct NostrProtocol {
             content: encrypted
         )
         
-        // Convert to P256K.Signing.PrivateKey for signing (temporary until we update sign method)
-        let signingKey = try P256K.Signing.PrivateKey(dataRepresentation: wrapKey.dataRepresentation)
-        return try giftWrap.sign(with: signingKey)
+        // Sign the gift wrap with the wrap Schnorr private key
+        return try giftWrap.sign(with: wrapKey)
     }
     
     private static func unwrapGiftWrap(
@@ -416,7 +414,7 @@ struct NostrProtocol {
         
         // Log with explicit UTC and local time for debugging
         let formatter = DateFormatter()
-        // Removed unnecessary date formatting operations
+        //
         formatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
         formatter.timeZone = TimeZone(abbreviation: "UTC")
         
@@ -472,19 +470,16 @@ struct NostrEvent: Codable {
         self.sig = dict["sig"] as? String
     }
     
-    func sign(with key: P256K.Signing.PrivateKey) throws -> NostrEvent {
+    func sign(with key: P256K.Schnorr.PrivateKey) throws -> NostrEvent {
         let (eventId, eventIdHash) = try calculateEventId()
         
-        // Convert to Schnorr key for Nostr signing
-        let schnorrKey = try P256K.Schnorr.PrivateKey(dataRepresentation: key.dataRepresentation)
-        
-        // Sign with Schnorr
+        // Sign with Schnorr (BIP-340)
         var messageBytes = [UInt8](eventIdHash)
         var auxRand = [UInt8](repeating: 0, count: 32)
         _ = auxRand.withUnsafeMutableBytes { ptr in
             SecRandomCopyBytes(kSecRandomDefault, 32, ptr.baseAddress!)
         }
-        let schnorrSignature = try schnorrKey.signature(message: &messageBytes, auxiliaryRand: &auxRand)
+        let schnorrSignature = try key.signature(message: &messageBytes, auxiliaryRand: &auxRand)
         
         let signatureHex = schnorrSignature.dataRepresentation.hexEncodedString()
         

bitchat/Nostr/NostrRelayManager.swift

@@ -48,10 +48,10 @@ class NostrRelayManager: ObservableObject {
     private let messageQueueLock = NSLock()
     
     // Exponential backoff configuration
-    private let initialBackoffInterval: TimeInterval = 1.0  // Start with 1 second
-    private let maxBackoffInterval: TimeInterval = 300.0    // Max 5 minutes
-    private let backoffMultiplier: Double = 2.0            // Double each time
-    private let maxReconnectAttempts = 10                  // Stop after 10 attempts
+    private let initialBackoffInterval: TimeInterval = TransportConfig.nostrRelayInitialBackoffSeconds
+    private let maxBackoffInterval: TimeInterval = TransportConfig.nostrRelayMaxBackoffSeconds
+    private let backoffMultiplier: Double = TransportConfig.nostrRelayBackoffMultiplier
+    private let maxReconnectAttempts = TransportConfig.nostrRelayMaxReconnectAttempts
     
     // Reconnection timer
     private var reconnectionTimer: Timer?
@@ -289,7 +289,7 @@ class NostrRelayManager: ObservableObject {
                         
                         // Only log non-gift-wrap events to reduce noise
                         if event.kind != 1059 {
-                            SecureLogger.log("📥 Received Nostr event (kind: \(event.kind)) from relay: \(relayUrl)", 
+                            SecureLogger.log("📥 Event kind=\(event.kind) id=\(event.id.prefix(16))… relay=\(relayUrl)",
                                             category: SecureLogger.session, level: .debug)
                         }
                         
@@ -321,11 +321,11 @@ class NostrRelayManager: ObservableObject {
                         let reason = array.count >= 4 ? (array[3] as? String ?? "no reason given") : "no reason given"
                         if success {
                             _ = Self.pendingGiftWrapIDs.remove(eventId)
-                            SecureLogger.log("✅ Event accepted id=\(eventId.prefix(16))... by relay: \(relayUrl)",
+                            SecureLogger.log("✅ Accepted id=\(eventId.prefix(16))… relay=\(relayUrl)",
                                             category: SecureLogger.session, level: .debug)
                         } else {
                             let isGiftWrap = Self.pendingGiftWrapIDs.remove(eventId) != nil
-                            SecureLogger.log("📮 Event \(eventId.prefix(16))... rejected by relay: \(reason)", 
+                            SecureLogger.log("📮 Rejected id=\(eventId.prefix(16))… reason=\(reason)", 
                                             category: SecureLogger.session, level: isGiftWrap ? .warning : .error)
                         }
                     }
@@ -353,7 +353,7 @@ class NostrRelayManager: ObservableObject {
             let data = try encoder.encode(req)
             let message = String(data: data, encoding: .utf8) ?? ""
             
-            SecureLogger.log("📤 Sending Nostr event (kind: \(event.kind)) to relay: \(relayUrl)", 
+            SecureLogger.log("📤 Send kind=\(event.kind) id=\(event.id.prefix(16))… relay=\(relayUrl)", 
                             category: SecureLogger.session, level: .debug)
             
             connection.send(.string(message)) { [weak self] error in
@@ -568,7 +568,7 @@ struct NostrFilter: Encodable {
         filter.kinds = [1059] // Gift wrap kind
         filter.since = since?.timeIntervalSince1970.toInt()
         filter.tagFilters = ["p": [pubkey]]
-        filter.limit = 100 // Add a reasonable limit
+        filter.limit = TransportConfig.nostrRelayDefaultFetchLimit // reasonable limit
         return filter
     }
 

bitchat/Protocols/BitchatProtocol.swift

@@ -181,8 +181,7 @@ enum LazyHandshakeState {
     case failed(Error)         // Handshake failed
 }
 
-// MARK: - Special Recipients (removed)
-// Previously defined broadcast identifiers were unused; removed for simplicity.
+//
 
 // MARK: - Core Protocol Structures
 
@@ -268,8 +267,7 @@ struct BitchatPacket: Codable {
     }
 }
 
-// MARK: - Delivery Acknowledgments (removed)
-// Legacy DeliveryAck structures are no longer used; delivery status flows via Noise payloads.
+//
 
 // MARK: - Read Receipts
 
@@ -361,7 +359,7 @@ struct ReadReceipt: Codable {
 }
 
 
-// PeerIdentityBinding removed (unused).
+//
 
 
 // MARK: - Delivery Status

bitchat/Services/AutocompleteService.swift

@@ -14,7 +14,7 @@ class AutocompleteService {
     private let commandRegex = try? NSRegularExpression(pattern: "^/([a-z]*)$", options: [])
     
     private let commands = [
-        "/msg", "/who", "/clear", "/help",
+        "/msg", "/who", "/clear",
         "/hug", "/slap", "/fav", "/unfav",
         "/block", "/unblock"
     ]
@@ -95,10 +95,10 @@ class AutocompleteService {
     
     private func needsArgument(command: String) -> Bool {
         switch command {
-        case "/who", "/clear", "/help":
+        case "/who", "/clear":
             return false
         default:
             return true
         }
     }
-}
+}

bitchat/Services/BLEService.swift

@@ -22,12 +22,12 @@ final class BLEService: NSObject {
     static let characteristicUUID = CBUUID(string: "A1B2C3D4-E5F6-4A5B-8C9D-0E1F2A3B4C5D")
     
     // Default per-fragment chunk size when link limits are unknown
-    private let defaultFragmentSize = 469 // ~512 MTU minus protocol overhead
-    private let maxMessageLength = 10_000
-    private let messageTTL: UInt8 = 7
+    private let defaultFragmentSize = TransportConfig.bleDefaultFragmentSize
+    private let maxMessageLength = InputValidator.Limits.maxMessageLength
+    private let messageTTL: UInt8 = TransportConfig.messageTTLDefault
     // Flood/battery controls
-    private let maxInFlightAssemblies = 128 // cap concurrent fragment assemblies
-    private let highDegreeThreshold = 6 // for adaptive TTL/probabilistic relays
+    private let maxInFlightAssemblies = TransportConfig.bleMaxInFlightAssemblies // cap concurrent fragment assemblies
+    private let highDegreeThreshold = TransportConfig.bleHighDegreeThreshold // for adaptive TTL/probabilistic relays
     
     // MARK: - Core State (5 Essential Collections)
     
@@ -70,7 +70,7 @@ final class BLEService: NSObject {
     
     // Simple announce throttling
     private var lastAnnounceSent = Date.distantPast
-    private let announceMinInterval: TimeInterval = 1.0
+    private let announceMinInterval: TimeInterval = TransportConfig.bleAnnounceMinInterval
     
     // Application state tracking (thread-safe)
     #if os(iOS)
@@ -112,6 +112,16 @@ final class BLEService: NSObject {
     private var scheduledRelays: [String: DispatchWorkItem] = [:]
     // Track short-lived traffic bursts to adapt announces/scanning under load
     private var recentPacketTimestamps: [Date] = []
+
+    // Ingress link tracking for last-hop suppression
+    private enum LinkID: Hashable {
+        case peripheral(String)
+        case central(String)
+    }
+    private var ingressByMessageID: [String: (link: LinkID, timestamp: Date)] = [:]
+
+    // Backpressure-aware write queue per peripheral
+    private var pendingPeripheralWrites: [String: [Data]] = [:]
     
     // MARK: - Maintenance Timer
     
@@ -119,8 +129,8 @@ final class BLEService: NSObject {
     private var maintenanceCounter = 0  // Track maintenance cycles
 
     // MARK: - Connection budget & scheduling (central role)
-    private let maxCentralLinks = 6
-    private let connectRateLimitInterval: TimeInterval = 0.5
+    private let maxCentralLinks = TransportConfig.bleMaxCentralLinks
+    private let connectRateLimitInterval: TimeInterval = TransportConfig.bleConnectRateLimitInterval
     private var lastGlobalConnectAttempt: Date = .distantPast
     private struct ConnectionCandidate {
         let peripheral: CBPeripheral
@@ -132,13 +142,13 @@ final class BLEService: NSObject {
     private var connectionCandidates: [ConnectionCandidate] = []
     private var failureCounts: [String: Int] = [:] // Peripheral UUID -> failures
     private var lastIsolatedAt: Date? = nil
-    private var dynamicRSSIThreshold: Int = -90
+    private var dynamicRSSIThreshold: Int = TransportConfig.bleDynamicRSSIThresholdDefault
 
     // MARK: - Adaptive scanning duty-cycle
     private var scanDutyTimer: DispatchSourceTimer?
     private var dutyEnabled: Bool = true
-    private var dutyOnDuration: TimeInterval = 5
-    private var dutyOffDuration: TimeInterval = 10
+    private var dutyOnDuration: TimeInterval = TransportConfig.bleDutyOnDuration
+    private var dutyOffDuration: TimeInterval = TransportConfig.bleDutyOffDuration
     private var dutyActive: Bool = false
 
     // MARK: - Link capability snapshots (thread-safe via bleQueue)
@@ -156,6 +166,88 @@ final class BLEService: NSObject {
             return bleQueue.sync { (self.subscribedCentrals, self.centralToPeerID) }
         }
     }
+
+    // MARK: - Helpers: IDs, selection, and write backpressure
+    private func makeMessageID(for packet: BitchatPacket) -> String {
+        let senderID = packet.senderID.hexEncodedString()
+        return "\(senderID)-\(packet.timestamp)-\(packet.type)"
+    }
+
+    private func subsetSizeForFanout(_ n: Int) -> Int {
+        guard n > 0 else { return 0 }
+        if n <= 2 { return n }
+        // approx ceil(log2(n)) + 1 without floating point
+        var v = n - 1
+        var bits = 0
+        while v > 0 { v >>= 1; bits += 1 }
+        return min(n, max(1, bits + 1))
+    }
+
+    private func selectDeterministicSubset(ids: [String], k: Int, seed: String) -> Set<String> {
+        guard k > 0 && ids.count > k else { return Set(ids) }
+        // Stable order by SHA256(seed || "::" || id)
+        var scored: [(score: [UInt8], id: String)] = []
+        for id in ids {
+            let msg = (seed + "::" + id).data(using: .utf8) ?? Data()
+            let digest = Array(SHA256.hash(data: msg))
+            scored.append((digest, id))
+        }
+        scored.sort { a, b in
+            for i in 0..<min(a.score.count, b.score.count) {
+                if a.score[i] != b.score[i] { return a.score[i] < b.score[i] }
+            }
+            return a.id < b.id
+        }
+        return Set(scored.prefix(k).map { $0.id })
+    }
+
+    private func writeOrEnqueue(_ data: Data, to peripheral: CBPeripheral, characteristic: CBCharacteristic) {
+        // BLE operations run on bleQueue; keep queue affinity
+        bleQueue.async { [weak self] in
+            guard let self = self else { return }
+            let uuid = peripheral.identifier.uuidString
+            if peripheral.canSendWriteWithoutResponse {
+                peripheral.writeValue(data, for: characteristic, type: .withoutResponse)
+            } else {
+                self.collectionsQueue.async(flags: .barrier) {
+                    self.pendingPeripheralWrites[uuid, default: []].append(data)
+                }
+            }
+        }
+    }
+
+    private func drainPendingWrites(for peripheral: CBPeripheral) {
+        let uuid = peripheral.identifier.uuidString
+        bleQueue.async { [weak self] in
+            guard let self = self else { return }
+            guard let state = self.peripherals[uuid], let ch = state.characteristic else { return }
+            var queueCopy: [Data] = []
+            self.collectionsQueue.sync {
+                queueCopy = self.pendingPeripheralWrites[uuid] ?? []
+            }
+            guard !queueCopy.isEmpty else { return }
+            var sent = 0
+            for item in queueCopy {
+                if peripheral.canSendWriteWithoutResponse {
+                    peripheral.writeValue(item, for: ch, type: .withoutResponse)
+                    sent += 1
+                } else {
+                    break
+                }
+            }
+            if sent > 0 {
+                self.collectionsQueue.async(flags: .barrier) {
+                    var q = self.pendingPeripheralWrites[uuid] ?? []
+                    if sent <= q.count {
+                        q.removeFirst(sent)
+                    } else {
+                        q.removeAll()
+                    }
+                    self.pendingPeripheralWrites[uuid] = q.isEmpty ? nil : q
+                }
+            }
+        }
+    }
     
     // MARK: - Peer snapshots publisher (non-UI convenience)
     private let peerSnapshotSubject = PassthroughSubject<[TransportPeerSnapshot], Never>()
@@ -165,20 +257,15 @@ final class BLEService: NSObject {
 
     func currentPeerSnapshots() -> [TransportPeerSnapshot] {
         collectionsQueue.sync {
-            // Compute nickname collision counts for connected peers
-            let connected = peers.values.filter { $0.isConnected }
-            var counts: [String: Int] = [:]
-            for p in connected { counts[p.nickname, default: 0] += 1 }
-            // Include our own nickname in collision counts so remote matching ours gets suffixed
-            counts[myNickname, default: 0] += 1
-            return peers.values.map { info in
-                var display = info.nickname
-                if info.isConnected, (counts[info.nickname] ?? 0) > 1 {
-                    display += "#" + String(info.id.prefix(4))
-                }
-                return TransportPeerSnapshot(
+            let snapshot = Array(peers.values)
+            let resolvedNames = PeerDisplayNameResolver.resolve(
+                snapshot.map { ($0.id, $0.nickname, $0.isConnected) },
+                selfNickname: myNickname
+            )
+            return snapshot.map { info in
+                TransportPeerSnapshot(
                     id: info.id,
-                    nickname: display,
+                    nickname: resolvedNames[info.id] ?? info.nickname,
                     isConnected: info.isConnected,
                     noisePublicKey: info.noisePublicKey,
                     lastSeen: info.lastSeen
@@ -259,7 +346,9 @@ final class BLEService: NSObject {
         
         // Single maintenance timer for all periodic tasks (dispatch-based for determinism)
         let timer = DispatchSource.makeTimerSource(queue: bleQueue)
-        timer.schedule(deadline: .now() + 10.0, repeating: 10.0, leeway: .seconds(1))
+        timer.schedule(deadline: .now() + TransportConfig.bleMaintenanceInterval,
+                       repeating: TransportConfig.bleMaintenanceInterval,
+                       leeway: .seconds(TransportConfig.bleMaintenanceLeewaySeconds))
         timer.setEventHandler { [weak self] in
             self?.performMaintenance()
         }
@@ -341,7 +430,7 @@ final class BLEService: NSObject {
         
         // Send initial announce after services are ready
         // Use longer delay to avoid conflicts with other announces
-        messageQueue.asyncAfter(deadline: .now() + 2.0) { [weak self] in
+        messageQueue.asyncAfter(deadline: .now() + TransportConfig.bleInitialAnnounceDelaySeconds) { [weak self] in
             self?.sendAnnounce(forceSend: true)
         }
     }
@@ -369,7 +458,7 @@ final class BLEService: NSObject {
             // Send to peripherals we're connected to as central
             for state in peripherals.values where state.isConnected {
                 if let characteristic = state.characteristic {
-                    state.peripheral.writeValue(data, for: characteristic, type: .withoutResponse)
+                    writeOrEnqueue(data, to: state.peripheral, characteristic: characteristic)
                 }
             }
             
@@ -380,7 +469,7 @@ final class BLEService: NSObject {
         }
         
         // Give leave message a moment to send
-        Thread.sleep(forTimeInterval: 0.05)
+        Thread.sleep(forTimeInterval: TransportConfig.bleThreadSleepWriteShortDelaySeconds)
         
         // Clear pending notifications
         collectionsQueue.sync(flags: .barrier) {
@@ -422,22 +511,9 @@ final class BLEService: NSObject {
 
     func getPeerNicknames() -> [String: String] {
         return collectionsQueue.sync {
-            // Only connected peers
             let connected = peers.filter { $0.value.isConnected }
-            // Count collisions by nickname (include our own nickname)
-            var counts: [String: Int] = [:]
-            for (_, info) in connected { counts[info.nickname, default: 0] += 1 }
-            counts[myNickname, default: 0] += 1
-            // Build map with suffix for collisions
-            var result: [String: String] = [:]
-            for (id, info) in connected {
-                var name = info.nickname
-                if (counts[info.nickname] ?? 0) > 1 {
-                    name += "#" + String(id.prefix(4))
-                }
-                result[id] = name
-            }
-            return result
+            let tuples = connected.map { ($0.key, $0.value.nickname, true) }
+            return PeerDisplayNameResolver.resolve(tuples, selfNickname: myNickname)
         }
     }
     
@@ -638,7 +714,7 @@ final class BLEService: NSObject {
         }
     }
     
-    // Removed unused getPeers(): use getPeerNicknames() from Transport
+    //
     
     // MARK: - Private Message Handling
     
@@ -877,7 +953,7 @@ final class BLEService: NSObject {
            let state = (DispatchQueue.getSpecific(key: bleQueueKey) != nil) ? peripherals[peripheralUUID] : bleQueue.sync(execute: { peripherals[peripheralUUID] }),
            state.isConnected,
            let characteristic = state.characteristic {
-            state.peripheral.writeValue(data, for: characteristic, type: .withoutResponse)
+            writeOrEnqueue(data, to: state.peripheral, characteristic: characteristic)
             sentEncrypted = true
         }
 
@@ -889,7 +965,7 @@ final class BLEService: NSObject {
                 if success { sentEncrypted = true; break }
                 collectionsQueue.async(flags: .barrier) { [weak self] in
                     guard let self = self else { return }
-                    if self.pendingNotifications.count < 20 {
+                    if self.pendingNotifications.count < TransportConfig.blePendingNotificationsCapCount {
                         self.pendingNotifications.append((data: data, centrals: [central]))
                         SecureLogger.log("📋 Queued encrypted packet for retry (notification queue full)", category: SecureLogger.session, level: .debug)
                     }
@@ -908,6 +984,10 @@ final class BLEService: NSObject {
     }
 
     private func sendOnAllLinks(packet: BitchatPacket, data: Data, pad: Bool, directedOnlyPeer: String?) {
+        // Determine last-hop link for this message to avoid echoing back
+        let messageID = makeMessageID(for: packet)
+        let ingressLink: LinkID? = collectionsQueue.sync { ingressByMessageID[messageID]?.link }
+
         let states = snapshotPeripheralStates()
         var minCentralWriteLen: Int?
         for s in states where s.isConnected {
@@ -932,15 +1012,54 @@ final class BLEService: NSObject {
             sendFragmentedPacket(packet, pad: pad, maxChunk: chunk, directedOnlyPeer: directedOnlyPeer)
             return
         }
-        // Writes to connected peripherals
-        for s in states where s.isConnected {
-            if let ch = s.characteristic {
-                s.peripheral.writeValue(data, for: ch, type: .withoutResponse)
+        // Build link lists and apply K-of-N fanout for broadcasts; always exclude ingress link
+        let connectedPeripheralIDs: [String] = states.filter { $0.isConnected }.map { $0.peripheral.identifier.uuidString }
+        let subscribedCentrals: [CBCentral]
+        var centralIDs: [String] = []
+        if let _ = characteristic {
+            let (centrals, _) = snapshotSubscribedCentrals()
+            subscribedCentrals = centrals
+            centralIDs = centrals.map { $0.identifier.uuidString }
+        } else {
+            subscribedCentrals = []
+        }
+
+        // Exclude ingress link
+        var allowedPeripheralIDs = connectedPeripheralIDs
+        var allowedCentralIDs = centralIDs
+        if let ingress = ingressLink {
+            switch ingress {
+            case .peripheral(let id):
+                allowedPeripheralIDs.removeAll { $0 == id }
+            case .central(let id):
+                allowedCentralIDs.removeAll { $0 == id }
             }
         }
-        // Notify all subscribed centrals
+
+        // For broadcast (no directed peer) and non-fragment, choose a subset deterministically
+        var selectedPeripheralIDs = Set(allowedPeripheralIDs)
+        var selectedCentralIDs = Set(allowedCentralIDs)
+        if directedOnlyPeer == nil && packet.type != MessageType.fragment.rawValue {
+            let kp = subsetSizeForFanout(allowedPeripheralIDs.count)
+            let kc = subsetSizeForFanout(allowedCentralIDs.count)
+            selectedPeripheralIDs = selectDeterministicSubset(ids: allowedPeripheralIDs, k: kp, seed: messageID)
+            selectedCentralIDs = selectDeterministicSubset(ids: allowedCentralIDs, k: kc, seed: messageID)
+        }
+
+        // Writes to selected connected peripherals
+        for s in states where s.isConnected {
+            let pid = s.peripheral.identifier.uuidString
+            guard selectedPeripheralIDs.contains(pid) else { continue }
+            if let ch = s.characteristic {
+                writeOrEnqueue(data, to: s.peripheral, characteristic: ch)
+            }
+        }
+        // Notify selected subscribed centrals
         if let ch = characteristic {
-            _ = peripheralManager?.updateValue(data, for: ch, onSubscribedCentrals: nil)
+            let targets = subscribedCentrals.filter { selectedCentralIDs.contains($0.identifier.uuidString) }
+            if !targets.isEmpty {
+                _ = peripheralManager?.updateValue(data, for: ch, onSubscribedCentrals: targets)
+            }
         }
     }
     
@@ -954,7 +1073,7 @@ final class BLEService: NSObject {
         
         // Fire-and-forget principle: always use .withoutResponse for speed
         // CoreBluetooth will handle fragmentation at L2CAP layer
-        peripheral.writeValue(data, for: characteristic, type: .withoutResponse)
+        writeOrEnqueue(data, to: peripheral, characteristic: characteristic)
     }
     
     // MARK: - Fragmentation (Required for messages > BLE MTU)
@@ -977,7 +1096,7 @@ final class BLEService: NSObject {
                 guard let self = self, let c = self.centralManager, c.state == .poweredOn else { return }
                 if c.isScanning { c.stopScan() }
                 // Resume scanning after we expect last fragment to be sent
-                let expectedMs = min(2000, totalFragments * 8) // ~8ms per fragment
+            let expectedMs = min(TransportConfig.bleExpectedWriteMaxMs, totalFragments * TransportConfig.bleExpectedWritePerFragmentMs) // ~8ms per fragment
                 self.bleQueue.asyncAfter(deadline: .now() + .milliseconds(expectedMs)) { [weak self] in
                     self?.startScanning()
                 }
@@ -1008,7 +1127,7 @@ final class BLEService: NSObject {
                 ttl: packet.ttl
             )
             // Pace fragments with small jitter to avoid bursts
-            let delayMs = index * 6 // ~6ms spacing per fragment
+            let delayMs = index * TransportConfig.bleFragmentSpacingMs // ~6ms spacing per fragment
             messageQueue.asyncAfter(deadline: .now() + .milliseconds(delayMs)) { [weak self] in
                 self?.broadcastPacket(fragmentPacket)
             }
@@ -1120,10 +1239,10 @@ final class BLEService: NSObject {
             guard let self = self else { return }
             let now = Date()
             self.recentPacketTimestamps.append(now)
-            // keep last 100 timestamps within 30s window
-            let cutoff = now.addingTimeInterval(-30)
-            if self.recentPacketTimestamps.count > 100 {
-                self.recentPacketTimestamps.removeFirst(self.recentPacketTimestamps.count - 100)
+            // keep last N timestamps within window
+            let cutoff = now.addingTimeInterval(-TransportConfig.bleRecentPacketWindowSeconds)
+            if self.recentPacketTimestamps.count > TransportConfig.bleRecentPacketWindowMaxCount {
+                self.recentPacketTimestamps.removeFirst(self.recentPacketTimestamps.count - TransportConfig.bleRecentPacketWindowMaxCount)
             }
             self.recentPacketTimestamps.removeAll { $0 < cutoff }
         }
@@ -1162,6 +1281,7 @@ final class BLEService: NSObject {
                 ttl: packet.ttl,
                 senderIsSelf: senderID == myPeerID,
                 isEncrypted: packet.type == MessageType.noiseEncrypted.rawValue,
+                isDirectedEncrypted: (packet.type == MessageType.noiseEncrypted.rawValue) && (packet.recipientID != nil),
                 isDirectedFragment: packet.type == MessageType.fragment.rawValue && packet.recipientID != nil,
                 isHandshake: packet.type == MessageType.noiseHandshake.rawValue,
                 degree: degree,
@@ -1486,7 +1606,7 @@ final class BLEService: NSObject {
         let timeSinceLastAnnounce = now.timeIntervalSince(lastAnnounceSent)
         
         // Even forced sends should respect a minimum interval to avoid overwhelming BLE
-        let minInterval = forceSend ? 0.2 : announceMinInterval
+        let minInterval = forceSend ? TransportConfig.bleForceAnnounceMinIntervalSeconds : announceMinInterval
         
         if timeSinceLastAnnounce < minInterval {
             // Skipping announce (rate limited)
@@ -1617,12 +1737,14 @@ final class BLEService: NSObject {
         let connectedCount = collectionsQueue.sync { peers.values.filter { $0.isConnected }.count }
         let elapsed = now.timeIntervalSince(lastAnnounceSent)
         if connectedCount == 0 {
-            // Discovery mode: keep frequent announces (~10s)
-            if elapsed >= 10.0 { sendAnnounce(forceSend: true) }
+            // Discovery mode: keep frequent announces
+            if elapsed >= TransportConfig.bleAnnounceIntervalSeconds { sendAnnounce(forceSend: true) }
         } else {
             // Connected mode: announce less often; much less in dense networks
-            let base = connectedCount >= 6 ? 90.0 : 45.0
-            let jitter = connectedCount >= 6 ? 20.0 : 7.5
+            let base = connectedCount >= TransportConfig.bleHighDegreeThreshold ?
+                TransportConfig.bleConnectedAnnounceBaseSecondsDense : TransportConfig.bleConnectedAnnounceBaseSecondsSparse
+            let jitter = connectedCount >= TransportConfig.bleHighDegreeThreshold ?
+                TransportConfig.bleConnectedAnnounceJitterDense : TransportConfig.bleConnectedAnnounceJitterSparse
             let target = base + Double.random(in: -jitter...jitter)
             if elapsed >= target { sendAnnounce(forceSend: true) }
         }
@@ -1663,7 +1785,7 @@ final class BLEService: NSObject {
         
         collectionsQueue.sync(flags: .barrier) {
             for (peerID, peer) in peers {
-                if peer.isConnected && now.timeIntervalSince(peer.lastSeen) > 20 {
+                if peer.isConnected && now.timeIntervalSince(peer.lastSeen) > TransportConfig.blePeerInactivityTimeoutSeconds {
                     // Check if we still have an active BLE connection to this peer
                     let hasPeripheralConnection = peerToPeripheralUUID[peerID] != nil &&
                                                  peripherals[peerToPeripheralUUID[peerID]!]?.isConnected == true
@@ -1703,9 +1825,9 @@ final class BLEService: NSObject {
         // Clean old processed messages efficiently
         messageDeduplicator.cleanup()
         
-        // Clean old fragments (> 30 seconds old)
+        // Clean old fragments (> configured seconds old)
         collectionsQueue.sync(flags: .barrier) {
-            let cutoff = now.addingTimeInterval(-30)
+            let cutoff = now.addingTimeInterval(-TransportConfig.bleFragmentLifetimeSeconds)
             let oldFragments = fragmentMetadata.filter { $0.value.timestamp < cutoff }.map { $0.key }
             for fragmentID in oldFragments {
                 incomingFragments.removeValue(forKey: fragmentID)
@@ -1713,8 +1835,8 @@ final class BLEService: NSObject {
             }
         }
 
-        // Clean old connection timeout backoff entries (> 2 minutes)
-        let timeoutCutoff = now.addingTimeInterval(-120)
+        // Clean old connection timeout backoff entries (> window)
+        let timeoutCutoff = now.addingTimeInterval(-TransportConfig.bleConnectTimeoutBackoffWindowSeconds)
         recentConnectTimeouts = recentConnectTimeouts.filter { $0.value >= timeoutCutoff }
 
         // Clean up stale scheduled relays that somehow persisted (> 2s)
@@ -1727,6 +1849,15 @@ final class BLEService: NSObject {
                 }
             }
         }
+
+        // Clean ingress link records older than configured seconds
+        collectionsQueue.async(flags: .barrier) { [weak self] in
+            guard let self = self else { return }
+            let cutoff = now.addingTimeInterval(-TransportConfig.bleIngressRecordLifetimeSeconds)
+            if !self.ingressByMessageID.isEmpty {
+                self.ingressByMessageID = self.ingressByMessageID.filter { $0.value.timestamp >= cutoff }
+            }
+        }
     }
 
     private func updateScanningDutyCycle(connectedCount: Int) {
@@ -1746,12 +1877,12 @@ final class BLEService: NSObject {
                 if !central.isScanning { startScanning() }
                 dutyActive = true
                 // Adjust duty cycle under dense networks to save battery
-                if connectedCount >= 6 {
-                    dutyOnDuration = 3
-                    dutyOffDuration = 15
+                if connectedCount >= TransportConfig.bleHighDegreeThreshold {
+                    dutyOnDuration = TransportConfig.bleDutyOnDurationDense
+                    dutyOffDuration = TransportConfig.bleDutyOffDurationDense
                 } else {
-                    dutyOnDuration = 5
-                    dutyOffDuration = 10
+                    dutyOnDuration = TransportConfig.bleDutyOnDuration
+                    dutyOffDuration = TransportConfig.bleDutyOffDuration
                 }
                 t.schedule(deadline: .now() + dutyOnDuration, repeating: dutyOnDuration + dutyOffDuration)
                 t.setEventHandler { [weak self] in
@@ -1785,25 +1916,25 @@ final class BLEService: NSObject {
             if lastIsolatedAt == nil { lastIsolatedAt = Date() }
             let iso = lastIsolatedAt ?? Date()
             let elapsed = Date().timeIntervalSince(iso)
-            if elapsed > 60 {
-                dynamicRSSIThreshold = -92
+            if elapsed > TransportConfig.bleIsolationRelaxThresholdSeconds {
+                dynamicRSSIThreshold = TransportConfig.bleRSSIIsolatedRelaxed
             } else {
-                dynamicRSSIThreshold = -90
+                dynamicRSSIThreshold = TransportConfig.bleRSSIIsolatedBase
             }
             return
         }
         lastIsolatedAt = nil
         // Base threshold when connected
-        var threshold = -90
+        var threshold = TransportConfig.bleDynamicRSSIThresholdDefault
         // If we're at budget or queue is large, prefer closer peers
         let linkCount = peripherals.values.filter { $0.isConnected || $0.isConnecting }.count
-        if linkCount >= maxCentralLinks || connectionCandidates.count > 20 {
-            threshold = -85
+        if linkCount >= maxCentralLinks || connectionCandidates.count > TransportConfig.bleConnectionCandidatesMax {
+            threshold = TransportConfig.bleRSSIConnectedThreshold
         }
         // If we have many recent timeouts, raise further
-        let recentTimeouts = recentConnectTimeouts.filter { Date().timeIntervalSince($0.value) < 60 }.count
-        if recentTimeouts >= 3 {
-            threshold = max(threshold, -80)
+        let recentTimeouts = recentConnectTimeouts.filter { Date().timeIntervalSince($0.value) < TransportConfig.bleRecentTimeoutWindowSeconds }.count
+        if recentTimeouts >= TransportConfig.bleRecentTimeoutCountThreshold {
+            threshold = max(threshold, TransportConfig.bleRSSIHighTimeoutThreshold)
         }
         dynamicRSSIThreshold = threshold
     }
@@ -1857,7 +1988,9 @@ extension BLEService: CBCentralManagerDelegate {
                 if a.rssi != b.rssi { return a.rssi > b.rssi }
                 return a.discoveredAt < b.discoveredAt
             }
-            if connectionCandidates.count > 100 { connectionCandidates.removeLast(connectionCandidates.count - 100) }
+            if connectionCandidates.count > TransportConfig.bleConnectionCandidatesMax {
+                connectionCandidates.removeLast(connectionCandidates.count - TransportConfig.bleConnectionCandidatesMax)
+            }
             return
         }
         
@@ -1871,7 +2004,9 @@ extension BLEService: CBCentralManagerDelegate {
                 if a.rssi != b.rssi { return a.rssi > b.rssi }
                 return a.discoveredAt < b.discoveredAt
             }
-            if connectionCandidates.count > 100 { connectionCandidates.removeLast(connectionCandidates.count - 100) }
+            if connectionCandidates.count > TransportConfig.bleConnectionCandidatesMax {
+                connectionCandidates.removeLast(connectionCandidates.count - TransportConfig.bleConnectionCandidatesMax)
+            }
             return
         }
 
@@ -1948,7 +2083,7 @@ extension BLEService: CBCentralManagerDelegate {
         
         // Set a timeout for the connection attempt (slightly longer for reliability)
         // Use BLE queue to mutate BLE-related state consistently
-        bleQueue.asyncAfter(deadline: .now() + 8.0) { [weak self] in
+        bleQueue.asyncAfter(deadline: .now() + TransportConfig.bleConnectTimeoutSeconds) { [weak self] in
             guard let self = self,
                   let state = self.peripherals[peripheralID],
                   state.isConnecting && !state.isConnected else { return }
@@ -2020,7 +2155,7 @@ func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeriph
         if centralManager?.state == .poweredOn {
             // Stop and restart scanning to ensure we get fresh discovery events
             centralManager?.stopScan()
-            bleQueue.asyncAfter(deadline: .now() + 0.1) { [weak self] in
+            bleQueue.asyncAfter(deadline: .now() + TransportConfig.bleRestartScanDelaySeconds) { [weak self] in
                 self?.startScanning()
             }
         }
@@ -2117,6 +2252,27 @@ extension BLEService {
 // Test-only helper to inject packets into the receive pipeline
 extension BLEService {
     func _test_handlePacket(_ packet: BitchatPacket, fromPeerID: String) {
+        // Ensure the synthetic peer is known and marked verified for public-message tests
+        let normalizedID = packet.senderID.hexEncodedString()
+        collectionsQueue.sync(flags: .barrier) {
+            if peers[normalizedID] == nil {
+                peers[normalizedID] = PeerInfo(
+                    id: normalizedID,
+                    nickname: "TestPeer_\(fromPeerID.prefix(4))",
+                    isConnected: true,
+                    noisePublicKey: packet.senderID,
+                    signingPublicKey: nil,
+                    isVerifiedNickname: true,
+                    lastSeen: Date()
+                )
+            } else {
+                var p = peers[normalizedID]!
+                p.isConnected = true
+                p.isVerifiedNickname = true
+                p.lastSeen = Date()
+                peers[normalizedID] = p
+            }
+        }
         if DispatchQueue.getSpecific(key: messageQueueKey) != nil {
             handleReceivedPacket(packet, from: fromPeerID)
         } else {
@@ -2197,7 +2353,7 @@ extension BLEService: CBPeripheralDelegate {
             SecureLogger.log("🔔 Subscribed to notifications from \(peripheral.name ?? "Unknown")", category: SecureLogger.session, level: .debug)
             
             // Send announce after subscription is confirmed (force send for new connection)
-            messageQueue.asyncAfter(deadline: .now() + 0.1) { [weak self] in
+            messageQueue.asyncAfter(deadline: .now() + TransportConfig.blePostSubscribeAnnounceDelaySeconds) { [weak self] in
                 self?.sendAnnounce(forceSend: true)
             }
         } else {
@@ -2220,7 +2376,9 @@ extension BLEService: CBPeripheralDelegate {
         
         // Process directly on main thread to avoid deadlocks (matches original implementation)
         guard let packet = BinaryProtocol.decode(data) else {
-            SecureLogger.log("❌ Failed to decode notification packet, full data: \(data.map { String(format: "%02x", $0) }.joined(separator: " "))",
+            // Avoid dumping entire payload; log size and short prefix for diagnostics
+            let prefix = data.prefix(16).map { String(format: "%02x", $0) }.joined(separator: " ")
+            SecureLogger.log("❌ Failed to decode notification packet (len=\(data.count), prefix=\(prefix))",
                             category: SecureLogger.session, level: .error)
             return
         }
@@ -2245,12 +2403,22 @@ extension BLEService: CBPeripheralDelegate {
                 peerToPeripheralUUID[senderID] = peripheralUUID
                 // Mapping update - direct announce from peer
             }
+            // Record ingress link for last-hop suppression and process
+            let msgID = makeMessageID(for: packet)
+            collectionsQueue.async(flags: .barrier) { [weak self] in
+                self?.ingressByMessageID[msgID] = (.peripheral(peripheralUUID), Date())
+            }
             // Process the announce packet regardless of whether we updated the mapping
             handleReceivedPacket(packet, from: senderID)
         } else {
             // For non-announce packets, DO NOT update mappings
             // These could be relayed packets from other peers
             // Always use the packet's original senderID
+            // Record ingress link for last-hop suppression and process
+            let msgID = makeMessageID(for: packet)
+            collectionsQueue.async(flags: .barrier) { [weak self] in
+                self?.ingressByMessageID[msgID] = (.peripheral(peripheralUUID), Date())
+            }
             handleReceivedPacket(packet, from: senderID)
         }
     }
@@ -2265,7 +2433,8 @@ extension BLEService: CBPeripheralDelegate {
     }
     
     func peripheralIsReady(toSendWriteWithoutResponse peripheral: CBPeripheral) {
-        // Suppress verbose ready logs
+        // Resume queued writes for this peripheral
+        drainPendingWrites(for: peripheral)
     }
     
     func peripheral(_ peripheral: CBPeripheral, didModifyServices invalidatedServices: [CBService]) {
@@ -2346,7 +2515,7 @@ extension BLEService: CBPeripheralManagerDelegate {
         SecureLogger.log("📥 Central subscribed: \(central.identifier.uuidString)", category: SecureLogger.session, level: .debug)
         subscribedCentrals.append(central)
         // Send announce to the newly subscribed central after a small delay to avoid overwhelming
-        messageQueue.asyncAfter(deadline: .now() + 0.4) { [weak self] in
+        messageQueue.asyncAfter(deadline: .now() + TransportConfig.blePostAnnounceDelaySeconds) { [weak self] in
             self?.sendAnnounce(forceSend: true)
         }
     }
@@ -2489,19 +2658,30 @@ extension BLEService: CBPeripheralManagerDelegate {
                 }
                 if packet.type == MessageType.announce.rawValue {
                     if packet.ttl == messageTTL { centralToPeerID[centralUUID] = senderID }
+                    // Record ingress link for last-hop suppression then process
+                    let msgID = makeMessageID(for: packet)
+                    collectionsQueue.async(flags: .barrier) { [weak self] in
+                        self?.ingressByMessageID[msgID] = (.central(centralUUID), Date())
+                    }
                     handleReceivedPacket(packet, from: senderID)
                 } else {
+                    // Record ingress link for last-hop suppression then process
+                    let msgID = makeMessageID(for: packet)
+                    collectionsQueue.async(flags: .barrier) { [weak self] in
+                        self?.ingressByMessageID[msgID] = (.central(centralUUID), Date())
+                    }
                     handleReceivedPacket(packet, from: senderID)
                 }
             } else {
                 // If buffer grows suspiciously large, reset to avoid memory leak
-                if combined.count > 1_000_000 { // 1MB cap for safety
+                if combined.count > TransportConfig.blePendingWriteBufferCapBytes { // cap for safety
                     pendingWriteBuffers.removeValue(forKey: centralUUID)
                     SecureLogger.log("⚠️ Dropping oversized pending write buffer (\(combined.count) bytes) for central \(centralUUID)", category: SecureLogger.session, level: .warning)
                 }
                 // If this was a single short write and still failed, log the raw chunk for debugging
                 if !hasMultiple, let only = sorted.first, let raw = only.value {
-                    SecureLogger.log("❌ Failed to decode packet from central, full data: \(raw.map { String(format: "%02x", $0) }.joined(separator: " "))", category: SecureLogger.session, level: .error)
+                    let prefix = raw.prefix(16).map { String(format: "%02x", $0) }.joined(separator: " ")
+                    SecureLogger.log("❌ Failed to decode packet from central (len=\(raw.count), prefix=\(prefix))", category: SecureLogger.session, level: .error)
                 }
             }
         }

bitchat/Services/CommandProcessor.swift

@@ -33,6 +33,15 @@ class CommandProcessor {
         guard let cmd = parts.first else { return .error(message: "Invalid command") }
         let args = parts.count > 1 ? String(parts[1]) : ""
         
+        // Geohash context: disable favoriting in public geohash or GeoDM
+        let inGeoPublic: Bool = {
+            switch LocationChannelManager.shared.selectedChannel {
+            case .mesh: return false
+            case .location: return true
+            }
+        }()
+        let inGeoDM = (chatViewModel?.selectedPrivateChatPeer?.hasPrefix("nostr_") == true)
+
         switch cmd {
         case "/m", "/msg":
             return handleMessage(args)
@@ -49,11 +58,14 @@ class CommandProcessor {
         case "/unblock":
             return handleUnblock(args)
         case "/fav":
+            if inGeoPublic || inGeoDM { return .error(message: "favorites are only for mesh peers in #mesh") }
             return handleFavorite(args, add: true)
         case "/unfav":
+            if inGeoPublic || inGeoDM { return .error(message: "favorites are only for mesh peers in #mesh") }
             return handleFavorite(args, add: false)
+        //
         case "/help", "/h":
-            return handleHelp()
+            return .error(message: "unknown command: \(cmd)")
         default:
             return .error(message: "unknown command: \(cmd)")
         }
@@ -85,19 +97,34 @@ class CommandProcessor {
     }
     
     private func handleWho() -> CommandResult {
-        guard let peers = meshService?.getPeerNicknames(), !peers.isEmpty else {
-            return .success(message: "no one else is online right now")
+        // Show geohash participants when in a geohash channel; otherwise mesh peers
+        switch LocationChannelManager.shared.selectedChannel {
+        case .location(let ch):
+            // Geohash context: show visible geohash participants (exclude self)
+            guard let vm = chatViewModel else { return .success(message: "nobody around") }
+            let myHex = (try? NostrIdentityBridge.deriveIdentity(forGeohash: ch.geohash))?.publicKeyHex.lowercased()
+            let people = vm.visibleGeohashPeople().filter { person in
+                if let me = myHex { return person.id.lowercased() != me }
+                return true
+            }
+            let names = people.map { $0.displayName }
+            if names.isEmpty { return .success(message: "no one else is online right now") }
+            return .success(message: "online: " + names.sorted().joined(separator: ", "))
+        case .mesh:
+            // Mesh context: show connected peer nicknames
+            guard let peers = meshService?.getPeerNicknames(), !peers.isEmpty else {
+                return .success(message: "no one else is online right now")
+            }
+            let onlineList = peers.values.sorted().joined(separator: ", ")
+            return .success(message: "online: \(onlineList)")
         }
-        
-        let onlineList = peers.values.sorted().joined(separator: ", ")
-        return .success(message: "online: \(onlineList)")
     }
     
     private func handleClear() -> CommandResult {
         if let peerID = chatViewModel?.selectedPrivateChatPeer {
             chatViewModel?.privateChats[peerID]?.removeAll()
         } else {
-            chatViewModel?.messages.removeAll()
+            chatViewModel?.clearCurrentPublicTimeline()
         }
         return .handled
     }
@@ -165,12 +192,8 @@ class CommandProcessor {
             let geoBlocked = Array(SecureIdentityStateManager.shared.getBlockedNostrPubkeys())
             var geoNames: [String] = []
             if let vm = chatViewModel {
-                #if os(iOS)
                 let visible = vm.visibleGeohashPeople()
                 let visibleIndex = Dictionary(uniqueKeysWithValues: visible.map { ($0.id.lowercased(), $0.displayName) })
-                #else
-                let visibleIndex: [String: String] = [:]
-                #endif
                 for pk in geoBlocked {
                     if let name = visibleIndex[pk.lowercased()] {
                         geoNames.append(name)

bitchat/Services/LocationChannelManager.swift

@@ -1,9 +1,9 @@
 import Foundation
-
-#if os(iOS)
-import CoreLocation
 import Combine
 
+#if os(iOS) || os(macOS)
+import CoreLocation
+
 /// Manages location permissions, one-shot location retrieval, and computing geohash channels.
 /// Not main-actor isolated to satisfy CLLocationManagerDelegate in Swift 6; state updates hop to MainActor.
 final class LocationChannelManager: NSObject, CLLocationManagerDelegate, ObservableObject {
@@ -39,7 +39,7 @@ final class LocationChannelManager: NSObject, CLLocationManagerDelegate, Observa
         super.init()
         cl.delegate = self
         cl.desiredAccuracy = kCLLocationAccuracyHundredMeters
-        cl.distanceFilter = 1000 // meters; we're not tracking continuously
+        cl.distanceFilter = TransportConfig.locationDistanceFilterMeters // meters; we're not tracking continuously
         // Load selection
         if let data = UserDefaults.standard.data(forKey: userDefaultsKey),
            let channel = try? JSONDecoder().decode(ChannelID.self, from: data) {
@@ -55,7 +55,7 @@ final class LocationChannelManager: NSObject, CLLocationManagerDelegate, Observa
             teleported = teleportedSet.contains(ch.geohash)
         }
         let status: CLAuthorizationStatus
-        if #available(iOS 14.0, *) {
+        if #available(iOS 14.0, macOS 11.0, *) {
             status = cl.authorizationStatus
         } else {
             status = CLLocationManager.authorizationStatus()
@@ -66,7 +66,7 @@ final class LocationChannelManager: NSObject, CLLocationManagerDelegate, Observa
     // MARK: - Public API
     func enableLocationChannels() {
         let status: CLAuthorizationStatus
-        if #available(iOS 14.0, *) {
+        if #available(iOS 14.0, macOS 11.0, *) {
             status = cl.authorizationStatus
         } else {
             status = CLLocationManager.authorizationStatus()
@@ -78,7 +78,7 @@ final class LocationChannelManager: NSObject, CLLocationManagerDelegate, Observa
             Task { @MainActor in self.permissionState = .restricted }
         case .denied:
             Task { @MainActor in self.permissionState = .denied }
-        case .authorizedAlways, .authorizedWhenInUse:
+        case .authorizedAlways, .authorizedWhenInUse, .authorized:
             Task { @MainActor in self.permissionState = .authorized }
             requestOneShotLocation()
         @unknown default:
@@ -93,7 +93,7 @@ final class LocationChannelManager: NSObject, CLLocationManagerDelegate, Observa
     }
 
     /// Begin periodic one-shot location refreshes while a selector UI is visible.
-    func beginLiveRefresh(interval: TimeInterval = 5.0) {
+    func beginLiveRefresh(interval: TimeInterval = TransportConfig.locationLiveRefreshInterval) {
         guard permissionState == .authorized else { return }
         // Switch to a lightweight periodic one-shot request (polling) while the sheet is open
         refreshTimer?.invalidate()
@@ -151,8 +151,8 @@ final class LocationChannelManager: NSObject, CLLocationManagerDelegate, Observa
         }
     }
 
-    // iOS 14+
-    @available(iOS 14.0, *)
+    // iOS 14+ / macOS 11+
+    @available(iOS 14.0, macOS 11.0, *)
     func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
         updatePermissionState(from: manager.authorizationStatus)
         if case .authorized = permissionState {
@@ -180,7 +180,7 @@ final class LocationChannelManager: NSObject, CLLocationManagerDelegate, Observa
         case .notDetermined: newState = .notDetermined
         case .restricted: newState = .restricted
         case .denied: newState = .denied
-        case .authorizedAlways, .authorizedWhenInUse: newState = .authorized
+        case .authorizedAlways, .authorizedWhenInUse, .authorized: newState = .authorized
         @unknown default: newState = .restricted
         }
         Task { @MainActor in self.permissionState = newState }
@@ -256,5 +256,4 @@ final class LocationChannelManager: NSObject, CLLocationManagerDelegate, Observa
         return dict
     }
 }
-
 #endif

bitchat/Services/NostrTransport.swift

@@ -20,7 +20,7 @@ final class NostrTransport: Transport {
     }
     private var readQueue: [QueuedRead] = []
     private var isSendingReadAcks = false
-    private let readAckInterval: TimeInterval = 0.35 // ~3 per second
+    private let readAckInterval: TimeInterval = TransportConfig.nostrReadAckInterval
 
     var myPeerID: String { senderPeerID }
     var myNickname: String { "" }
@@ -48,16 +48,7 @@ final class NostrTransport: Transport {
 
     func sendPrivateMessage(_ content: String, to peerID: String, recipientNickname: String, messageID: String) {
         Task { @MainActor in
-            // Resolve favorite by full noise key or by short peerID fallback
-            var recipientNostrPubkey: String?
-            if let noiseKey = Data(hexString: peerID),
-               let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: noiseKey) {
-                recipientNostrPubkey = fav.peerNostrPublicKey
-            }
-            if recipientNostrPubkey == nil, peerID.count == 16 {
-                recipientNostrPubkey = FavoritesPersistenceService.shared.getFavoriteStatus(forPeerID: peerID)?.peerNostrPublicKey
-            }
-            guard let recipientNpub = recipientNostrPubkey else { return }
+            guard let recipientNpub = resolveRecipientNpub(for: peerID) else { return }
             guard let senderIdentity = try? NostrIdentityBridge.getCurrentNostrIdentity() else { return }
             SecureLogger.log("NostrTransport: preparing PM to \(recipientNpub.prefix(16))… for peerID \(peerID.prefix(8))… id=\(messageID.prefix(8))…",
                             category: SecureLogger.session, level: .debug)
@@ -105,15 +96,7 @@ final class NostrTransport: Transport {
         guard !readQueue.isEmpty else { isSendingReadAcks = false; return }
         let item = readQueue.removeFirst()
         Task { @MainActor in
-            var recipientNostrPubkey: String?
-            if let noiseKey = Data(hexString: item.peerID),
-               let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: noiseKey) {
-                recipientNostrPubkey = fav.peerNostrPublicKey
-            }
-            if recipientNostrPubkey == nil, item.peerID.count == 16 {
-                recipientNostrPubkey = FavoritesPersistenceService.shared.getFavoriteStatus(forPeerID: item.peerID)?.peerNostrPublicKey
-            }
-            guard let recipientNpub = recipientNostrPubkey else { scheduleNextReadAck(); return }
+            guard let recipientNpub = resolveRecipientNpub(for: item.peerID) else { scheduleNextReadAck(); return }
             guard let senderIdentity = try? NostrIdentityBridge.getCurrentNostrIdentity() else { scheduleNextReadAck(); return }
             SecureLogger.log("NostrTransport: preparing READ ack for id=\(item.receipt.originalMessageID.prefix(8))… to \(recipientNpub.prefix(16))…",
                             category: SecureLogger.session, level: .debug)
@@ -149,15 +132,7 @@ final class NostrTransport: Transport {
 
     func sendFavoriteNotification(to peerID: String, isFavorite: Bool) {
         Task { @MainActor in
-            var recipientNostrPubkey: String?
-            if let noiseKey = Data(hexString: peerID),
-               let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: noiseKey) {
-                recipientNostrPubkey = fav.peerNostrPublicKey
-            }
-            if recipientNostrPubkey == nil, peerID.count == 16 {
-                recipientNostrPubkey = FavoritesPersistenceService.shared.getFavoriteStatus(forPeerID: peerID)?.peerNostrPublicKey
-            }
-            guard let recipientNpub = recipientNostrPubkey else { return }
+            guard let recipientNpub = resolveRecipientNpub(for: peerID) else { return }
             guard let senderIdentity = try? NostrIdentityBridge.getCurrentNostrIdentity() else { return }
             let content = isFavorite ? "[FAVORITED]:\(senderIdentity.npub)" : "[UNFAVORITED]:\(senderIdentity.npub)"
             SecureLogger.log("NostrTransport: preparing FAVORITE(\(isFavorite)) to \(recipientNpub.prefix(16))…",
@@ -183,18 +158,26 @@ final class NostrTransport: Transport {
         }
     }
 
+    // MARK: - Helpers
+    @MainActor
+    private func resolveRecipientNpub(for peerID: String) -> String? {
+        if let noiseKey = Data(hexString: peerID),
+           let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: noiseKey),
+           let npub = fav.peerNostrPublicKey {
+            return npub
+        }
+        if peerID.count == 16,
+           let fav = FavoritesPersistenceService.shared.getFavoriteStatus(forPeerID: peerID),
+           let npub = fav.peerNostrPublicKey {
+            return npub
+        }
+        return nil
+    }
+
     func sendBroadcastAnnounce() { /* no-op for Nostr */ }
     func sendDeliveryAck(for messageID: String, to peerID: String) {
         Task { @MainActor in
-            var recipientNostrPubkey: String?
-            if let noiseKey = Data(hexString: peerID),
-               let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: noiseKey) {
-                recipientNostrPubkey = fav.peerNostrPublicKey
-            }
-            if recipientNostrPubkey == nil, peerID.count == 16 {
-                recipientNostrPubkey = FavoritesPersistenceService.shared.getFavoriteStatus(forPeerID: peerID)?.peerNostrPublicKey
-            }
-            guard let recipientNpub = recipientNostrPubkey else { return }
+            guard let recipientNpub = resolveRecipientNpub(for: peerID) else { return }
             guard let senderIdentity = try? NostrIdentityBridge.getCurrentNostrIdentity() else { return }
             SecureLogger.log("NostrTransport: preparing DELIVERED ack for id=\(messageID.prefix(8))… to \(recipientNpub.prefix(16))…",
                             category: SecureLogger.session, level: .debug)

bitchat/Services/PrivateChatManager.swift

@@ -27,7 +27,7 @@ class PrivateChatManager: ObservableObject {
     }
 
     // Cap for messages stored per private chat
-    private let privateChatCap = 1337
+    private let privateChatCap = TransportConfig.privateChatCap
     
     /// Start a private chat with a peer
     func startChat(with peerID: String) {

bitchat/Services/RelayController.swift

@@ -12,6 +12,7 @@ struct RelayController {
     static func decide(ttl: UInt8,
                        senderIsSelf: Bool,
                        isEncrypted: Bool,
+                       isDirectedEncrypted: Bool,
                        isDirectedFragment: Bool,
                        isHandshake: Bool,
                        degree: Int,
@@ -19,7 +20,17 @@ struct RelayController {
         // Suppress obvious non-relays
         if ttl <= 1 || senderIsSelf { return RelayDecision(shouldRelay: false, newTTL: ttl, delayMs: 0) }
 
-        // Degree-aware probability to reduce floods in dense graphs
+        // For session-critical or directed traffic, be deterministic and reliable
+        if isHandshake || isDirectedFragment || isDirectedEncrypted {
+            // Always relay with no TTL cap for these types
+            let newTTL = (ttl &- 1)
+            // Slight jitter to desynchronize without adding too much latency
+            let delayRange: ClosedRange<Int> = isHandshake ? 20...60 : 40...120
+            let delayMs = Int.random(in: delayRange)
+            return RelayDecision(shouldRelay: true, newTTL: newTTL, delayMs: delayMs)
+        }
+
+        // Degree-aware probability to reduce floods in dense graphs (broadcast/public)
         let baseProb: Double
         switch degree {
         case 0...2: baseProb = 1.0
@@ -28,20 +39,22 @@ struct RelayController {
         case 7...9: baseProb = 0.55
         default:    baseProb = 0.45
         }
-        var prob = baseProb
-        if isHandshake { prob = max(0.3, baseProb - 0.2) }
-
-        // Sample a forwarding decision
+        let prob = baseProb
         let shouldRelay = Double.random(in: 0...1) <= prob
 
-        // TTL clamping in dense graphs
+        // TTL clamping in dense graphs (only for broadcast)
         let ttlCap: UInt8 = degree >= highDegreeThreshold ? 3 : 5
         let clamped = max(1, min(ttl, ttlCap))
         let newTTL = clamped &- 1
 
-        // Short jitter to desynchronize rebroadcasts
-        let delayMs = Int.random(in: 20...80)
+        // Wider jitter window to allow duplicate suppression to win more often
+        let delayMs: Int
+        switch degree {
+        case 0...2: delayMs = Int.random(in: 40...100)
+        case 3...5: delayMs = Int.random(in: 60...150)
+        case 6...9: delayMs = Int.random(in: 80...180)
+        default:    delayMs = Int.random(in: 100...220)
+        }
         return RelayDecision(shouldRelay: shouldRelay, newTTL: newTTL, delayMs: delayMs)
     }
 }
-

bitchat/Services/Transport.swift

@@ -3,7 +3,7 @@ import Combine
 
 /// Abstract transport interface used by ChatViewModel and services.
 /// BLEService implements this protocol; a future Nostr transport can too.
-struct TransportPeerSnapshot {
+struct TransportPeerSnapshot: Equatable, Hashable {
     let id: String
     let nickname: String
     let isConnected: Bool

bitchat/Services/TransportConfig.swift

@@ -0,0 +1,161 @@
+import Foundation
+
+/// Centralized knobs for transport- and UI-related limits.
+/// Keep values aligned with existing behavior when replacing magic numbers.
+enum TransportConfig {
+    // BLE / Protocol
+    static let bleDefaultFragmentSize: Int = 469            // ~512 MTU minus protocol overhead
+    static let messageTTLDefault: UInt8 = 7                 // Default TTL for mesh flooding
+    static let bleMaxInFlightAssemblies: Int = 128          // Cap concurrent fragment assemblies
+    static let bleHighDegreeThreshold: Int = 6              // For adaptive TTL/probabilistic relays
+
+    // UI / Storage Caps
+    static let privateChatCap: Int = 1337
+    static let meshTimelineCap: Int = 1337
+    static let geoTimelineCap: Int = 1337
+    static let contentLRUCap: Int = 2000
+
+    // Timers
+    static let networkResetGraceSeconds: TimeInterval = 600 // 10 minutes
+    static let basePublicFlushInterval: TimeInterval = 0.08  // ~12.5 fps batching
+
+    // BLE duty/announce/connect
+    static let bleConnectRateLimitInterval: TimeInterval = 0.5
+    static let bleMaxCentralLinks: Int = 6
+    static let bleDutyOnDuration: TimeInterval = 5.0
+    static let bleDutyOffDuration: TimeInterval = 10.0
+    static let bleAnnounceMinInterval: TimeInterval = 1.0
+
+    // BLE discovery/quality thresholds
+    static let bleDynamicRSSIThresholdDefault: Int = -90
+    static let bleConnectionCandidatesMax: Int = 100
+    static let blePendingWriteBufferCapBytes: Int = 1_000_000
+    static let blePendingNotificationsCapCount: Int = 20
+
+    // Nostr
+    static let nostrReadAckInterval: TimeInterval = 0.35 // ~3 per second
+
+    // UI thresholds
+    static let uiLateInsertThreshold: TimeInterval = 15.0
+    static let uiProcessedNostrEventsCap: Int = 2000
+    static let uiChannelInactivityThresholdSeconds: TimeInterval = 9 * 60
+    
+    // UI rate limiters (token buckets)
+    static let uiSenderRateBucketCapacity: Double = 5
+    static let uiSenderRateBucketRefillPerSec: Double = 1.0
+    static let uiContentRateBucketCapacity: Double = 3
+    static let uiContentRateBucketRefillPerSec: Double = 0.5
+
+    // UI sleeps/delays
+    static let uiStartupInitialDelaySeconds: TimeInterval = 1.0
+    static let uiStartupShortSleepNs: UInt64 = 200_000_000
+    static let uiStartupPhaseDurationSeconds: TimeInterval = 2.0
+    static let uiAsyncShortSleepNs: UInt64 = 100_000_000
+    static let uiAsyncMediumSleepNs: UInt64 = 500_000_000
+    static let uiReadReceiptRetryShortSeconds: TimeInterval = 0.1
+    static let uiReadReceiptRetryLongSeconds: TimeInterval = 0.5
+    static let uiBatchDispatchStaggerSeconds: TimeInterval = 0.15
+    static let uiScrollThrottleSeconds: TimeInterval = 0.5
+    static let uiAnimationShortSeconds: TimeInterval = 0.15
+    static let uiAnimationMediumSeconds: TimeInterval = 0.2
+    static let uiAnimationSidebarSeconds: TimeInterval = 0.25
+    static let uiRecentCutoffFiveMinutesSeconds: TimeInterval = 5 * 60
+
+    // BLE maintenance & thresholds
+    static let bleMaintenanceInterval: TimeInterval = 10.0
+    static let bleMaintenanceLeewaySeconds: Int = 1
+    static let bleIsolationRelaxThresholdSeconds: TimeInterval = 60
+    static let bleRecentTimeoutWindowSeconds: TimeInterval = 60
+    static let bleRecentTimeoutCountThreshold: Int = 3
+    static let bleRSSIIsolatedBase: Int = -90
+    static let bleRSSIIsolatedRelaxed: Int = -92
+    static let bleRSSIConnectedThreshold: Int = -85
+    static let bleRSSIHighTimeoutThreshold: Int = -80
+    static let blePeerInactivityTimeoutSeconds: TimeInterval = 20.0
+    static let bleFragmentLifetimeSeconds: TimeInterval = 30.0
+    static let bleIngressRecordLifetimeSeconds: TimeInterval = 3.0
+    static let bleConnectTimeoutBackoffWindowSeconds: TimeInterval = 120.0
+    static let bleRecentPacketWindowSeconds: TimeInterval = 30.0
+    static let bleRecentPacketWindowMaxCount: Int = 100
+    static let bleThreadSleepWriteShortDelaySeconds: TimeInterval = 0.05
+    static let bleExpectedWritePerFragmentMs: Int = 8
+    static let bleExpectedWriteMaxMs: Int = 2000
+    static let bleFragmentSpacingMs: Int = 6
+    static let bleAnnounceIntervalSeconds: TimeInterval = 10.0
+    static let bleDutyOnDurationDense: TimeInterval = 3.0
+    static let bleDutyOffDurationDense: TimeInterval = 15.0
+    static let bleConnectedAnnounceBaseSecondsDense: TimeInterval = 90.0
+    static let bleConnectedAnnounceBaseSecondsSparse: TimeInterval = 45.0
+    static let bleConnectedAnnounceJitterDense: TimeInterval = 20.0
+    static let bleConnectedAnnounceJitterSparse: TimeInterval = 7.5
+
+    // Location
+    static let locationDistanceFilterMeters: Double = 1000
+    static let locationLiveRefreshInterval: TimeInterval = 5.0
+
+    // Nostr geohash
+    static let nostrGeohashInitialLookbackSeconds: TimeInterval = 3600
+    static let nostrGeohashInitialLimit: Int = 200
+    static let nostrGeoRelayCount: Int = 5
+    static let nostrGeohashSampleLookbackSeconds: TimeInterval = 300
+    static let nostrGeohashSampleLimit: Int = 100
+    static let nostrDMSubscribeLookbackSeconds: TimeInterval = 86400
+
+    // Nostr helpers
+    static let nostrShortKeyDisplayLength: Int = 8
+    static let nostrConvKeyPrefixLength: Int = 16
+
+    // Compression
+    static let compressionThresholdBytes: Int = 100
+
+    // Message deduplication
+    static let messageDedupMaxAgeSeconds: TimeInterval = 300
+    static let messageDedupMaxCount: Int = 1000
+
+    // Verification QR
+    static let verificationQRMaxAgeSeconds: TimeInterval = 5 * 60
+
+    // Nostr relay backoff
+    static let nostrRelayInitialBackoffSeconds: TimeInterval = 1.0
+    static let nostrRelayMaxBackoffSeconds: TimeInterval = 300.0
+    static let nostrRelayBackoffMultiplier: Double = 2.0
+    static let nostrRelayMaxReconnectAttempts: Int = 10
+    static let nostrRelayDefaultFetchLimit: Int = 100
+
+    // Geo relay directory
+    static let geoRelayFetchIntervalSeconds: TimeInterval = 60 * 60 * 24
+
+    // BLE operational delays
+    static let bleInitialAnnounceDelaySeconds: TimeInterval = 2.0
+    static let bleConnectTimeoutSeconds: TimeInterval = 8.0
+    static let bleRestartScanDelaySeconds: TimeInterval = 0.1
+    static let blePostSubscribeAnnounceDelaySeconds: TimeInterval = 0.1
+    static let blePostAnnounceDelaySeconds: TimeInterval = 0.4
+    static let bleForceAnnounceMinIntervalSeconds: TimeInterval = 0.2
+
+    // Content hashing / formatting
+    static let contentKeyPrefixLength: Int = 256
+    static let uiLongMessageLengthThreshold: Int = 2000
+    static let uiVeryLongTokenThreshold: Int = 512
+    static let uiLongMessageLineLimit: Int = 30
+    static let uiFingerprintSampleCount: Int = 3
+    
+    // UI swipe/gesture thresholds
+    static let uiBackSwipeTranslationLarge: CGFloat = 50
+    static let uiBackSwipeTranslationSmall: CGFloat = 30
+    static let uiBackSwipeVelocityThreshold: CGFloat = 300
+    
+    // UI color tuning
+    static let uiColorHueAvoidanceDelta: Double = 0.05
+    static let uiColorHueOffset: Double = 0.12
+
+    // UI windowing (infinite scroll)
+    static let uiWindowInitialCountPublic: Int = 300
+    static let uiWindowInitialCountPrivate: Int = 300
+    static let uiWindowStepCount: Int = 200
+
+    // Share extension
+    static let uiShareExtensionDismissDelaySeconds: TimeInterval = 0.3
+    static let uiShareAcceptWindowSeconds: TimeInterval = 30.0
+    static let uiMigrationCutoffSeconds: TimeInterval = 24 * 60 * 60
+}

bitchat/Services/VerificationService.swift

@@ -102,7 +102,7 @@ final class VerificationService {
     }
 
     /// Verify a scanned QR and return the parsed payload if valid (signature + freshness checks)
-    func verifyScannedQR(_ urlString: String, maxAge: TimeInterval = 5 * 60) -> VerificationQR? {
+    func verifyScannedQR(_ urlString: String, maxAge: TimeInterval = TransportConfig.verificationQRMaxAgeSeconds) -> VerificationQR? {
         guard let url = URL(string: urlString), let qr = VerificationQR.fromURL(url) else { return nil }
         // Freshness
         let now = Date().timeIntervalSince1970

bitchat/Utils/CompressionUtil.swift

@@ -11,7 +11,7 @@ import Compression
 
 struct CompressionUtil {
     // Compression threshold - don't compress if data is smaller than this
-    static let compressionThreshold = 100 // bytes
+    static let compressionThreshold = TransportConfig.compressionThresholdBytes // bytes
     
     // Compress data using zlib algorithm (most compatible)
     static func compress(_ data: Data) -> Data? {

bitchat/Utils/InputValidator.swift

@@ -18,14 +18,18 @@ struct InputValidator {
     
     /// Validates a peer ID from any source (short 16-hex, full 64-hex, or internal alnum/-/_ up to 64)
     static func validatePeerID(_ peerID: String) -> Bool {
-        // Accept short routing IDs (16-hex)
+        // Accept short routing IDs (exact 16-hex)
         if PeerIDResolver.isShortID(peerID) { return true }
-        // Accept full Noise key hex (64-hex)
+        // If length equals short-hex length but isn't valid hex, reject
+        if peerID.count == Limits.hexPeerIDLength { return false }
+        // Accept full Noise key hex (exact 64-hex)
         if PeerIDResolver.isNoiseKeyHex(peerID) { return true }
-        // Internal format: alphanumeric + dash/underscore up to 64
+        // If length equals full key length but isn't valid hex, reject
+        if peerID.count == Limits.maxPeerIDLength { return false }
+        // Internal format: alphanumeric + dash/underscore up to 63 (not 16 or 64)
         let validCharset = CharacterSet.alphanumerics.union(CharacterSet(charactersIn: "-_"))
         return !peerID.isEmpty &&
-               peerID.count <= Limits.maxPeerIDLength &&
+               peerID.count < Limits.maxPeerIDLength &&
                peerID.rangeOfCharacter(from: validCharset.inverted) == nil
     }
     

bitchat/Utils/MessageDeduplicator.swift

@@ -11,8 +11,8 @@ final class MessageDeduplicator {
     private var entries: [Entry] = []
     private var lookup = Set<String>()
     private let lock = NSLock()
-    private let maxAge: TimeInterval = 300  // 5 minutes
-    private let maxCount = 1000
+    private let maxAge: TimeInterval = TransportConfig.messageDedupMaxAgeSeconds  // 5 minutes
+    private let maxCount = TransportConfig.messageDedupMaxCount
 
     /// Check if message is duplicate and add if not
     func isDuplicate(_ messageID: String) -> Bool {
@@ -84,4 +84,3 @@ final class MessageDeduplicator {
         }
     }
 }
-

bitchat/Utils/PeerDisplayNameResolver.swift

@@ -0,0 +1,29 @@
+import Foundation
+
+/// Resolves a stable display name for peers, adding a short suffix when collisions exist.
+struct PeerDisplayNameResolver {
+    /// Computes display names with a `#xxxx` suffix for connected peers when nickname collisions occur.
+    /// - Parameters:
+    ///   - peers: Array of tuples (id, nickname, isConnected).
+    ///   - selfNickname: The local user's current nickname, included in collision counts to suffix remotes matching it.
+    /// - Returns: Map of peerID -> displayName.
+    static func resolve(_ peers: [(id: String, nickname: String, isConnected: Bool)], selfNickname: String) -> [String: String] {
+        // Count collisions among connected peers and include our own nickname
+        var counts: [String: Int] = [:]
+        for p in peers where p.isConnected {
+            counts[p.nickname, default: 0] += 1
+        }
+        counts[selfNickname, default: 0] += 1
+
+        var result: [String: String] = [:]
+        for p in peers {
+            var name = p.nickname
+            if p.isConnected, (counts[p.nickname] ?? 0) > 1 {
+                name += "#" + String(p.id.prefix(4))
+            }
+            result[p.id] = name
+        }
+        return result
+    }
+}
+

bitchat/ViewModels/ChatViewModel.swift

@@ -145,10 +145,10 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
 
     private var rateBucketsBySender: [String: TokenBucket] = [:]
     private var rateBucketsByContent: [String: TokenBucket] = [:]
-    private let senderBucketCapacity: Double = 5
-    private let senderBucketRefill: Double = 1 // tokens per second
-    private let contentBucketCapacity: Double = 3
-    private let contentBucketRefill: Double = 0.5 // tokens per second
+    private let senderBucketCapacity: Double = TransportConfig.uiSenderRateBucketCapacity
+    private let senderBucketRefill: Double = TransportConfig.uiSenderRateBucketRefillPerSec // tokens per second
+    private let contentBucketCapacity: Double = TransportConfig.uiContentRateBucketCapacity
+    private let contentBucketRefill: Double = TransportConfig.uiContentRateBucketRefillPerSec // tokens per second
 
     @MainActor
     private func normalizedSenderKey(for message: BitchatMessage) -> String {
@@ -192,7 +192,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         if last < ns.length { simplified += ns.substring(with: NSRange(location: last, length: ns.length - last)) }
         let trimmed = simplified.trimmingCharacters(in: .whitespacesAndNewlines)
         let collapsed = trimmed.replacingOccurrences(of: "\\s+", with: " ", options: .regularExpression)
-        let prefix = String(collapsed.prefix(256))
+        let prefix = String(collapsed.prefix(TransportConfig.contentKeyPrefixLength))
         // Fast djb2 hash
         let h = djb2(prefix)
         return String(format: "h:%016llx", h)
@@ -201,7 +201,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
     // Persistent recent content map (LRU) to speed near-duplicate checks
     private var contentLRUMap: [String: Date] = [:]
     private var contentLRUOrder: [String] = []
-    private let contentLRUCap = 2000
+    private let contentLRUCap = TransportConfig.contentLRUCap
     private func recordContentKey(_ key: String, timestamp: Date) {
         if contentLRUMap[key] == nil { contentLRUOrder.append(key) }
         contentLRUMap[key] = timestamp
@@ -219,13 +219,13 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
     
     @Published var messages: [BitchatMessage] = []
     @Published var currentColorScheme: ColorScheme = .light
-    private let maxMessages = 1337 // Maximum messages before oldest are removed
+    private let maxMessages = TransportConfig.meshTimelineCap // Maximum messages before oldest are removed
     @Published var isConnected = false
     private var hasNotifiedNetworkAvailable = false
     private var recentlySeenPeers: Set<String> = []
     private var lastNetworkNotificationTime = Date.distantPast
     private var networkResetTimer: Timer? = nil
-    private let networkResetGraceSeconds: TimeInterval = 600 // 10 minutes; avoid refiring on short drops/reconnects
+    private let networkResetGraceSeconds: TimeInterval = TransportConfig.networkResetGraceSeconds // avoid refiring on short drops/reconnects
     @Published var nickname: String = "" {
         didSet {
             // Trim whitespace whenever nickname is set
@@ -297,7 +297,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         }
     }
     
-    // Missing properties that were removed during refactoring
+    //
     private var peerIDToPublicKeyFingerprint: [String: String] = [:]
     private var selectedPrivateChatFingerprint: String? = nil
     // Map stable short peer IDs (16-hex) to full Noise public key hex (64-hex) for session continuity
@@ -349,17 +349,15 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
     // PeerManager replaced by UnifiedPeerService
     private var processedNostrEvents = Set<String>()  // Simple deduplication
     private var processedNostrEventOrder: [String] = []
-    private let maxProcessedNostrEvents = 2000
+    private let maxProcessedNostrEvents = TransportConfig.uiProcessedNostrEventsCap
     private let userDefaults = UserDefaults.standard
     private let nicknameKey = "bitchat.nickname"
-    // Location channel state
-    #if os(iOS)
+    // Location channel state (macOS supports manual geohash selection)
     @Published private var activeChannel: ChannelID = .mesh
     private var geoSubscriptionID: String? = nil
     private var geoDmSubscriptionID: String? = nil
     private var currentGeohash: String? = nil
     private var geoNicknames: [String: String] = [:] // pubkeyHex(lowercased) -> nickname
-    #endif
     
     // MARK: - Caches
     
@@ -388,15 +386,14 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
     // Messages are naturally ephemeral - no persistent storage
     // Persist mesh public timeline across channel switches
     private var meshTimeline: [BitchatMessage] = []
-    private let meshTimelineCap = 1337
-    #if os(iOS)
+    private let meshTimelineCap = TransportConfig.meshTimelineCap
     // Persist per-geohash public timelines across switches
     private var geoTimelines: [String: [BitchatMessage]] = [:] // geohash -> messages
-    private let geoTimelineCap = 1337
+    private let geoTimelineCap = TransportConfig.geoTimelineCap
     // Channel activity tracking for background nudges
     private var lastPublicActivityAt: [String: Date] = [:]   // channelKey -> last activity time
     private var lastPublicActivityNotifyAt: [String: Date] = [:]
-    private let channelInactivityThreshold: TimeInterval = 9 * 60
+    private let channelInactivityThreshold: TimeInterval = TransportConfig.uiChannelInactivityThresholdSeconds
     // Geohash participants (per geohash: pubkey -> lastSeen)
     private var geoParticipants: [String: [String: Date]] = [:]
     @Published private(set) var geohashPeople: [GeoPerson] = []
@@ -405,7 +402,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
     @Published private(set) var teleportedGeo: Set<String> = []  // lowercased pubkey hex
     // Sampling subscriptions for multiple geohashes (when channel sheet is open)
     private var geoSamplingSubs: [String: String] = [:] // subID -> geohash
-    #endif
     
     // MARK: - Message Delivery Tracking
     
@@ -432,11 +428,11 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
     // Buffer incoming public messages and flush in small batches to reduce UI invalidations
     private var publicBuffer: [BitchatMessage] = []
     private var publicBufferTimer: Timer? = nil
-    private let basePublicFlushInterval: TimeInterval = 0.08 // ~12.5 fps batching
-    private var dynamicPublicFlushInterval: TimeInterval = 0.08
+    private let basePublicFlushInterval: TimeInterval = TransportConfig.basePublicFlushInterval
+    private var dynamicPublicFlushInterval: TimeInterval = TransportConfig.basePublicFlushInterval
     private var recentBatchSizes: [Int] = []
     @Published private(set) var isBatchingPublic: Bool = false
-    private let lateInsertThreshold: TimeInterval = 15.0
+    private let lateInsertThreshold: TimeInterval = TransportConfig.uiLateInsertThreshold
     
     // Track sent read receipts to avoid duplicates (persisted across launches)
     // Note: Persistence happens automatically in didSet, no lifecycle observers needed
@@ -445,21 +441,9 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             // Only persist if there are changes
             guard oldValue != sentReadReceipts else { return }
             
-            // Persist to UserDefaults whenever it changes
+            // Persist to UserDefaults whenever it changes (no manual synchronize/verify re-read)
             if let data = try? JSONEncoder().encode(Array(sentReadReceipts)) {
                 UserDefaults.standard.set(data, forKey: "sentReadReceipts")
-                // Force synchronization for immediate persistence (ensures data is written to disk)
-                UserDefaults.standard.synchronize()
-                
-                // Verify persistence by re-reading
-                if let verifyData = UserDefaults.standard.data(forKey: "sentReadReceipts"),
-                   let _ = try? JSONDecoder().decode([String].self, from: verifyData) {
-                    // Only log errors, not successful persistence
-                    // Successfully persisted
-                } else {
-                    SecureLogger.log("⚠️ Failed to verify persistence of read receipts",
-                                    category: SecureLogger.session, level: .error)
-                }
             } else {
                 SecureLogger.log("❌ Failed to encode read receipts for persistence",
                                 category: SecureLogger.session, level: .error)
@@ -522,7 +506,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         // Log startup info
         
         // Log fingerprint after a delay to ensure encryption service is ready
-        DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) { [weak self] in
+        DispatchQueue.main.asyncAfter(deadline: .now() + TransportConfig.uiStartupInitialDelaySeconds) { [weak self] in
             if let self = self {
                 _ = self.getMyFingerprint()
             }
@@ -542,7 +526,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             
             // Small delay to ensure read receipts are fully loaded
             // This prevents race conditions where messages arrive before initialization completes
-            try? await Task.sleep(nanoseconds: 200_000_000) // 0.2 seconds
+            try? await Task.sleep(nanoseconds: TransportConfig.uiStartupShortSleepNs) // 0.2 seconds
             
             // Set up Nostr message handling directly
             setupNostrMessageHandling()
@@ -555,7 +539,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             // 1. Skip cleanup of read receipts
             // 2. Only block OLD messages from being marked as unread
             Task { @MainActor in
-                try? await Task.sleep(nanoseconds: 2_000_000_000) // 2 seconds
+                try? await Task.sleep(nanoseconds: UInt64(TransportConfig.uiStartupPhaseDurationSeconds * 1_000_000_000)) // 2 seconds
                 self.isStartupPhase = false
             }
             
@@ -592,8 +576,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             
             self.cancellables.insert(cancellable)
 
-            // Resubscribe geohash on relay reconnect (iOS only)
-            #if os(iOS)
+            // Resubscribe geohash on relay reconnect
             if let relayMgr = self.nostrRelayManager {
                 relayMgr.$isConnected
                     .receive(on: DispatchQueue.main)
@@ -607,13 +590,11 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                     }
                     .store(in: &self.cancellables)
             }
-            #endif
         }
 
         // Set up Noise encryption callbacks
         setupNoiseCallbacks()
 
-        #if os(iOS)
         // Observe location channel selection
         LocationChannelManager.shared.$selectedChannel
             .receive(on: DispatchQueue.main)
@@ -628,7 +609,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         Task { @MainActor in
             self.switchLocationChannel(to: LocationChannelManager.shared.selectedChannel)
         }
-        #endif
         
         // Request notification permission
         NotificationService.shared.requestAuthorization()
@@ -711,11 +691,9 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
     // MARK: - Deinitialization
     
     deinit {
-        // Force immediate save
-        userDefaults.synchronize()
+        // No need to force UserDefaults synchronization
     }
-
-    #if os(iOS)
+    
     // Resubscribe to the active geohash channel without clearing timeline
     @MainActor
     private func resubscribeCurrentGeohash() {
@@ -729,8 +707,15 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         startGeoParticipantsTimer()
         // Unsubscribe + resubscribe
         NostrRelayManager.shared.unsubscribe(id: subID)
-        let filter = NostrFilter.geohashEphemeral(ch.geohash, since: Date().addingTimeInterval(-3600), limit: 200)
-        let subRelays = GeoRelayDirectory.shared.closestRelays(toGeohash: ch.geohash, count: 5)
+        let filter = NostrFilter.geohashEphemeral(
+            ch.geohash,
+            since: Date().addingTimeInterval(-TransportConfig.nostrGeohashInitialLookbackSeconds),
+            limit: TransportConfig.nostrGeohashInitialLimit
+        )
+        let subRelays = GeoRelayDirectory.shared.closestRelays(
+            toGeohash: ch.geohash,
+            count: TransportConfig.nostrGeoRelayCount
+        )
         NostrRelayManager.shared.subscribe(filter: filter, id: subID, relayUrls: subRelays) { [weak self] event in
             guard let self = self else { return }
             guard event.kind == NostrProtocol.EventKind.ephemeralEvent.rawValue else { return }
@@ -748,9 +733,9 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                 self.geoNicknames[event.pubkey.lowercased()] = nick
             }
             // Store mapping for geohash sender IDs used in messages (ensures consistent colors)
-            let key16 = "nostr_" + String(event.pubkey.prefix(16))
+            let key16 = "nostr_" + String(event.pubkey.prefix(TransportConfig.nostrConvKeyPrefixLength))
             self.nostrKeyMapping[key16] = event.pubkey
-            let key8 = "nostr:" + String(event.pubkey.prefix(8))
+            let key8 = "nostr:" + String(event.pubkey.prefix(TransportConfig.nostrShortKeyDisplayLength))
             self.nostrKeyMapping[key8] = event.pubkey
 
             // Update participants last-seen for this pubkey
@@ -777,7 +762,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                 originalSender: nil,
                 isPrivate: false,
                 recipientNickname: nil,
-                senderPeerID: "nostr:\(event.pubkey.prefix(8))",
+                senderPeerID: "nostr:\(event.pubkey.prefix(TransportConfig.nostrShortKeyDisplayLength))",
                 mentions: mentions.isEmpty ? nil : mentions
             )
             Task { @MainActor in
@@ -792,7 +777,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             let id = try NostrIdentityBridge.deriveIdentity(forGeohash: ch.geohash)
             let dmSub = "geo-dm-\(ch.geohash)"
             geoDmSubscriptionID = dmSub
-            let dmFilter = NostrFilter.giftWrapsFor(pubkey: id.publicKeyHex, since: Date().addingTimeInterval(-86400))
+            let dmFilter = NostrFilter.giftWrapsFor(pubkey: id.publicKeyHex, since: Date().addingTimeInterval(-TransportConfig.nostrDMSubscribeLookbackSeconds))
             NostrRelayManager.shared.subscribe(filter: dmFilter, id: dmSub) { [weak self] giftWrap in
                 guard let self = self else { return }
                 if self.processedNostrEvents.contains(giftWrap.id) { return }
@@ -804,7 +789,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                 guard packet.type == MessageType.noiseEncrypted.rawValue else { return }
                 guard let noisePayload = NoisePayload.decode(packet.payload) else { return }
                 let messageTimestamp = Date(timeIntervalSince1970: TimeInterval(rumorTs))
-                let convKey = "nostr_" + String(senderPubkey.prefix(16))
+                let convKey = "nostr_" + String(senderPubkey.prefix(TransportConfig.nostrConvKeyPrefixLength))
                 self.nostrKeyMapping[convKey] = senderPubkey
                 switch noisePayload.type {
                 case .privateMessage:
@@ -897,7 +882,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             }
         } catch { }
     }
-    #endif
 
     // MARK: - Nickname Management
     
@@ -913,7 +897,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
     
     func saveNickname() {
         userDefaults.set(nickname, forKey: nicknameKey)
-        userDefaults.synchronize() // Force immediate save
+        // Persist nickname; no need to force synchronize
         
         // Send announce with new nickname to all peers
         meshService.sendBroadcastAnnounce()
@@ -1105,7 +1089,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
            chatFingerprint == fingerprintStr {
             // Send read receipts for any unread messages from this peer
             // Use a small delay to ensure the connection is fully established
-            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
+        DispatchQueue.main.asyncAfter(deadline: .now() + TransportConfig.uiReadReceiptRetryLongSeconds) { [weak self] in
                 self?.markPrivateMessagesAsRead(from: peerID)
             }
         }
@@ -1225,19 +1209,14 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             let mentions = parseMentions(from: content)
             
             // Add message to local display
-            #if os(iOS)
             var displaySender = nickname
             var localSenderPeerID = meshService.myPeerID
             if case .location(let ch) = activeChannel,
                let myGeoIdentity = try? NostrIdentityBridge.deriveIdentity(forGeohash: ch.geohash) {
                 let suffix = String(myGeoIdentity.publicKeyHex.suffix(4))
                 displaySender = nickname + "#" + suffix
-                localSenderPeerID = "nostr:\(myGeoIdentity.publicKeyHex.prefix(8))"
+                localSenderPeerID = "nostr:\(myGeoIdentity.publicKeyHex.prefix(TransportConfig.nostrShortKeyDisplayLength))"
             }
-            #else
-            let displaySender = nickname
-            let localSenderPeerID = meshService.myPeerID
-            #endif
 
             let message = BitchatMessage(
                 sender: displaySender,
@@ -1257,7 +1236,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             let ckey = normalizedContentKey(message.content)
             recordContentKey(ckey, timestamp: message.timestamp)
             // Persist to channel-specific timelines
-            #if os(iOS)
             switch activeChannel {
             case .mesh:
                 meshTimeline.append(message)
@@ -1268,26 +1246,19 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                 if arr.count > geoTimelineCap { arr = Array(arr.suffix(geoTimelineCap)) }
                 geoTimelines[ch.geohash] = arr
             }
-            #else
-            meshTimeline.append(message)
-            trimMeshTimelineIfNeeded()
-            #endif
             trimMessagesIfNeeded()
             
             // Force immediate UI update for user's own messages
             objectWillChange.send()
 
             // Update channel activity time on send
-            #if os(iOS)
             switch activeChannel {
             case .mesh:
                 lastPublicActivityAt["mesh"] = Date()
             case .location(let ch):
                 lastPublicActivityAt["geo:\(ch.geohash)"] = Date()
             }
-            #endif
             
-            #if os(iOS)
             if case .location(let ch) = activeChannel {
                 // Send to geohash channel via Nostr ephemeral
                 Task { @MainActor in
@@ -1300,7 +1271,10 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                             nickname: self.nickname,
                             teleported: LocationChannelManager.shared.teleported
                         )
-                        let targetRelays = GeoRelayDirectory.shared.closestRelays(toGeohash: ch.geohash, count: 5)
+                        let targetRelays = GeoRelayDirectory.shared.closestRelays(
+                            toGeohash: ch.geohash,
+                            count: TransportConfig.nostrGeoRelayCount
+                        )
                         if targetRelays.isEmpty {
                             SecureLogger.log("Geo: no geohash relays available for \(ch.geohash); not sending", category: SecureLogger.session, level: .warning)
                         } else {
@@ -1326,14 +1300,10 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                 // Send via mesh with mentions
                 meshService.sendMessage(content, mentions: mentions)
             }
-            #else
-            // Send via mesh with mentions (non-iOS)
-            meshService.sendMessage(content, mentions: mentions)
-            #endif
+            
         }
     }
 
-    #if os(iOS)
     @MainActor
     private func switchLocationChannel(to channel: ChannelID) {
         // Flush pending public buffer to avoid cross-channel bleed
@@ -1376,19 +1346,21 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         // Ensure self appears immediately in the people list; mark teleported state if applicable
         if let id = try? NostrIdentityBridge.deriveIdentity(forGeohash: ch.geohash) {
             self.recordGeoParticipant(pubkeyHex: id.publicKeyHex)
-            #if os(iOS)
             if LocationChannelManager.shared.teleported {
                 let key = id.publicKeyHex.lowercased()
                 teleportedGeo = teleportedGeo.union([key])
                 SecureLogger.log("GeoTeleport: channel switch mark self teleported key=\(key.prefix(8))… total=\(teleportedGeo.count)",
                                 category: SecureLogger.session, level: .info)
             }
-            #endif
         }
         let subID = "geo-\(ch.geohash)"
         geoSubscriptionID = subID
         startGeoParticipantsTimer()
-        let filter = NostrFilter.geohashEphemeral(ch.geohash, since: Date().addingTimeInterval(-3600), limit: 200)
+        let filter = NostrFilter.geohashEphemeral(
+            ch.geohash,
+            since: Date().addingTimeInterval(-TransportConfig.nostrGeohashInitialLookbackSeconds),
+            limit: TransportConfig.nostrGeohashInitialLimit
+        )
         let subRelays = GeoRelayDirectory.shared.closestRelays(toGeohash: ch.geohash, count: 5)
         NostrRelayManager.shared.subscribe(filter: filter, id: subID, relayUrls: subRelays) { [weak self] event in
             guard let self = self else { return }
@@ -1430,9 +1402,9 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                 return
             }
             // Store mapping for geohash DM initiation
-            let key16 = "nostr_" + String(event.pubkey.prefix(16))
+            let key16 = "nostr_" + String(event.pubkey.prefix(TransportConfig.nostrConvKeyPrefixLength))
             self.nostrKeyMapping[key16] = event.pubkey
-            let key8 = "nostr:" + String(event.pubkey.prefix(8))
+            let key8 = "nostr:" + String(event.pubkey.prefix(TransportConfig.nostrShortKeyDisplayLength))
             self.nostrKeyMapping[key8] = event.pubkey
             // Update participants last-seen for this pubkey
             self.recordGeoParticipant(pubkeyHex: event.pubkey)
@@ -1455,7 +1427,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                 originalSender: nil,
                 isPrivate: false,
                 recipientNickname: nil,
-                senderPeerID: "nostr:\(event.pubkey.prefix(8))",
+                senderPeerID: "nostr:\(event.pubkey.prefix(TransportConfig.nostrShortKeyDisplayLength))",
                 mentions: mentions.isEmpty ? nil : mentions
             )
             Task { @MainActor in
@@ -1473,7 +1445,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             // pared back logging: subscribe debug only
             SecureLogger.log("GeoDM: subscribing DMs pub=\(id.publicKeyHex.prefix(8))… sub=\(dmSub)",
                             category: SecureLogger.session, level: .debug)
-            let dmFilter = NostrFilter.giftWrapsFor(pubkey: id.publicKeyHex, since: Date().addingTimeInterval(-86400))
+            let dmFilter = NostrFilter.giftWrapsFor(pubkey: id.publicKeyHex, since: Date().addingTimeInterval(-TransportConfig.nostrDMSubscribeLookbackSeconds))
             NostrRelayManager.shared.subscribe(filter: dmFilter, id: dmSub) { [weak self] giftWrap in
                 guard let self = self else { return }
                 // Dedup basic
@@ -1590,11 +1562,10 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         } catch {
             // ignore
         }
-        // Presence announcement removed; we will tag actual chat events instead
+        //
     }
 
-    // MARK: - Geohash Participants (iOS)
-    #if os(iOS)
+    // MARK: - Geohash Participants
     struct GeoPerson: Identifiable, Equatable {
         let id: String        // pubkey hex (lowercased)
         let displayName: String
@@ -1623,7 +1594,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
 
     private func refreshGeohashPeople() {
         guard let gh = currentGeohash else { geohashPeople = []; return }
-        let cutoff = Date().addingTimeInterval(-5 * 60)
+        let cutoff = Date().addingTimeInterval(-TransportConfig.uiRecentCutoffFiveMinutesSeconds)
         var map = geoParticipants[gh] ?? [:]
         // Prune expired entries
         map = map.filter { $0.value >= cutoff }
@@ -1652,15 +1623,13 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         geoParticipantsTimer?.invalidate()
         geoParticipantsTimer = nil
     }
-    #endif
-
-    // MARK: - Public helpers (iOS)
-    #if os(iOS)
+    
+    // MARK: - Public helpers
     /// Return the current, pruned, sorted people list for the active geohash without mutating state.
     @MainActor
     func visibleGeohashPeople() -> [GeoPerson] {
         guard let gh = currentGeohash else { return [] }
-        let cutoff = Date().addingTimeInterval(-5 * 60)
+        let cutoff = Date().addingTimeInterval(-TransportConfig.uiRecentCutoffFiveMinutesSeconds)
         let map = (geoParticipants[gh] ?? [:])
             .filter { $0.value >= cutoff }
             .filter { !SecureIdentityStateManager.shared.isNostrBlocked(pubkeyHexLowercased: $0.key) }
@@ -1672,7 +1641,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
     /// Returns the current participant count for a specific geohash, using the 5-minute activity window.
     @MainActor
     func geohashParticipantCount(for geohash: String) -> Int {
-        let cutoff = Date().addingTimeInterval(-5 * 60)
+        let cutoff = Date().addingTimeInterval(-TransportConfig.uiRecentCutoffFiveMinutesSeconds)
         let map = geoParticipants[geohash] ?? [:]
         return map.values.filter { $0 >= cutoff }.count
     }
@@ -1720,7 +1689,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         }
         
         // Remove geohash DM conversation if exists
-        let convKey = "nostr_" + String(hex.prefix(16))
+        let convKey = "nostr_" + String(hex.prefix(TransportConfig.nostrConvKeyPrefixLength))
         if privateChats[convKey] != nil {
             privateChats.removeValue(forKey: convKey)
             unreadPrivateMessages.remove(convKey)
@@ -1746,7 +1715,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         let toAdd = desired.subtracting(current)
         let toRemove = current.subtracting(desired)
 
-        // Unsubscribe removed
+        //
         for (subID, gh) in geoSamplingSubs where toRemove.contains(gh) {
             NostrRelayManager.shared.unsubscribe(id: subID)
             geoSamplingSubs.removeValue(forKey: subID)
@@ -1756,7 +1725,11 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         for gh in toAdd {
             let subID = "geo-sample-\(gh)"
             geoSamplingSubs[subID] = gh
-            let filter = NostrFilter.geohashEphemeral(gh, since: Date().addingTimeInterval(-300), limit: 100)
+            let filter = NostrFilter.geohashEphemeral(
+                gh,
+                since: Date().addingTimeInterval(-TransportConfig.nostrGeohashSampleLookbackSeconds),
+                limit: TransportConfig.nostrGeohashSampleLimit
+            )
             let subRelays = GeoRelayDirectory.shared.closestRelays(toGeohash: gh, count: 5)
             NostrRelayManager.shared.subscribe(filter: filter, id: subID, relayUrls: subRelays) { [weak self] event in
                 guard let self = self else { return }
@@ -1773,7 +1746,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         for subID in geoSamplingSubs.keys { NostrRelayManager.shared.unsubscribe(id: subID) }
         geoSamplingSubs.removeAll()
     }
-    #endif
 
     private func displayNameForNostrPubkey(_ pubkeyHex: String) -> String {
         let suffix = String(pubkeyHex.suffix(4))
@@ -1793,16 +1765,12 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
 
     // Helper: display name for current active channel (for notifications)
     private func activeChannelDisplayName() -> String {
-        #if os(iOS)
         switch activeChannel {
         case .mesh:
             return "#mesh"
         case .location(let ch):
             return "#\(ch.geohash)"
         }
-        #else
-        return "#mesh"
-        #endif
     }
 
     // Dedup helper with small memory cap
@@ -1819,7 +1787,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             }
         }
     }
-    #endif
     
     /// Sends an encrypted private message to a specific peer.
     /// - Parameters:
@@ -1831,7 +1798,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         guard !content.isEmpty else { return }
         
         // Geohash DM routing: conversation keys start with "nostr_"
-        #if os(iOS)
         if peerID.hasPrefix("nostr_") {
             guard case .location(let ch) = activeChannel else {
                 addSystemMessage("cannot send: not in a location channel")
@@ -1897,7 +1863,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             }
             return
         }
-        #endif
 
         // Check if blocked
         if unifiedPeerService.isBlocked(peerID) {
@@ -1964,11 +1929,10 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         }
     }
 
-    #if os(iOS)
     // MARK: - Geohash DMs initiation
     @MainActor
     func startGeohashDM(withPubkeyHex hex: String) {
-        let convKey = "nostr_" + String(hex.prefix(16))
+        let convKey = "nostr_" + String(hex.prefix(TransportConfig.nostrConvKeyPrefixLength))
         nostrKeyMapping[convKey] = hex
         selectedPrivateChatPeer = convKey
     }
@@ -1990,7 +1954,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         }
         return "anon#\(suffix)"
     }
-    #endif
     /// Add a local system message to a private chat (no network send)
     @MainActor
     func addLocalPrivateSystemMessage(_ content: String, to peerID: String) {
@@ -2439,14 +2402,12 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             // Try immediately
             self.markPrivateMessagesAsRead(from: peerID)
             // And again with a delay
-            DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+            DispatchQueue.main.asyncAfter(deadline: .now() + TransportConfig.uiAnimationMediumSeconds) {
                 self.markPrivateMessagesAsRead(from: peerID)
             }
         }
         // Also resubscribe the current geohash channel if active
-        #if os(iOS)
         resubscribeCurrentGeohash()
-        #endif
     }
     
     @MainActor
@@ -2491,7 +2452,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             
         } else {
             // In public chat - send to active public channel
-            #if os(iOS)
             switch activeChannel {
             case .mesh:
                 meshService.sendMessage(screenshotMessage, mentions: [])
@@ -2508,12 +2468,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                         )
                         let targetRelays = GeoRelayDirectory.shared.closestRelays(toGeohash: ch.geohash, count: 5)
                         if targetRelays.isEmpty {
-                    let targetRelays = GeoRelayDirectory.shared.closestRelays(toGeohash: ch.geohash, count: 5)
-                    if targetRelays.isEmpty {
-                        SecureLogger.log("Geo: no geohash relays available for \(ch.geohash); not sending", category: SecureLogger.session, level: .warning)
-                    } else {
-                        NostrRelayManager.shared.sendEvent(event, to: targetRelays)
-                    }
+                            SecureLogger.log("Geo: no geohash relays available for \(ch.geohash); not sending", category: SecureLogger.session, level: .warning)
                         } else {
                             NostrRelayManager.shared.sendEvent(event, to: targetRelays)
                         }
@@ -2525,9 +2480,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                     }
                 }
             }
-            #else
-            meshService.sendMessage(screenshotMessage, mentions: [])
-            #endif
+            
 
             // Show local notification immediately as system message
             let localNotification = BitchatMessage(
@@ -2542,7 +2495,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
     }
     
     @objc private func appWillResignActive() {
-        userDefaults.synchronize()
+        // No-op; avoid forcing synchronize on resign
     }
     
     @objc func applicationWillTerminate() {
@@ -2555,15 +2508,14 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         // Verify identity key is still there
         _ = KeychainManager.shared.verifyIdentityKeyExists()
         
-        userDefaults.synchronize()
+        // No need to force synchronize here
         
         // Verify identity key after save
         _ = KeychainManager.shared.verifyIdentityKeyExists()
     }
     
     @objc private func appWillTerminate() {
-        
-        userDefaults.synchronize()
+        // No need to force synchronize here
     }
     
     @MainActor
@@ -2607,7 +2559,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         privateChatManager.markAsRead(from: peerID)
         
         // Handle GeoDM (nostr_*) read receipts directly via per-geohash identity
-        #if os(iOS)
         if peerID.hasPrefix("nostr_"),
            let recipientHex = nostrKeyMapping[peerID],
            case .location(let ch) = LocationChannelManager.shared.selectedChannel,
@@ -2625,7 +2576,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             }
             return
         }
-        #endif
 
         // Get the peer's Noise key to check for Nostr messages
         var noiseKeyHex: String? = nil
@@ -2722,7 +2672,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
     
     @MainActor
     func getPeerIDForNickname(_ nickname: String) -> String? {
-        #if os(iOS)
         // When in a geohash channel, allow resolving by geohash participant nickname
         switch LocationChannelManager.shared.selectedChannel {
         case .location:
@@ -2732,13 +2681,14 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             }().lowercased()
             // Try exact match against cached geoNicknames (pubkey -> nickname)
             if let pub = geoNicknames.first(where: { (_, nick) in nick.lowercased() == base })?.key {
-                let convKey = "nostr_" + String(pub.prefix(16))
+                let convKey = "nostr_" + String(pub.prefix(TransportConfig.nostrConvKeyPrefixLength))
                 nostrKeyMapping[convKey] = pub
                 return convKey
             }
-        default: break
+        default:
+            break
         }
-        #endif
+        // Fallback to mesh nickname resolution
         return unifiedPeerService.getPeerID(for: nickname)
     }
     
@@ -2810,14 +2760,13 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         // This will force creation of a new identity (new fingerprint) on next launch
         meshService.emergencyDisconnectAll()
         
-        // Force immediate UserDefaults synchronization
-        userDefaults.synchronize()
+        // No need to force UserDefaults synchronization
         
         // Reinitialize Nostr with new identity
         // This will generate new Nostr keys derived from new Noise keys
         Task { @MainActor in
             // Small delay to ensure cleanup completes
-            try? await Task.sleep(nanoseconds: 100_000_000) // 0.1 seconds
+            try? await Task.sleep(nanoseconds: TransportConfig.uiAsyncShortSleepNs) // 0.1 seconds
             
             // Reinitialize Nostr relay manager with new identity
             nostrRelayManager = NostrRelayManager()
@@ -2846,7 +2795,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
     func updateAutocomplete(for text: String, cursorPosition: Int) {
         // Build candidate list based on active channel
         let peerCandidates: [String] = {
-            #if os(iOS)
             switch activeChannel {
             case .mesh:
                 let values = meshService.getPeerNicknames().values
@@ -2865,10 +2813,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                 }
                 return Array(tokens)
             }
-            #else
-            let values = meshService.getPeerNicknames().values
-            return Array(values.filter { $0 != meshService.myNickname })
-            #endif
         }()
 
         let (suggestions, range) = autocompleteService.getSuggestions(
@@ -2989,13 +2933,12 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         // Determine if this message was sent by self (mesh, geo, or DM)
         let isSelf: Bool = {
             if let spid = message.senderPeerID {
-                #if os(iOS)
+                // In geohash channels, compare against our per-geohash nostr short ID
                 if case .location(let ch) = activeChannel, spid.hasPrefix("nostr:") {
                     if let myGeo = try? NostrIdentityBridge.deriveIdentity(forGeohash: ch.geohash) {
-                        return spid == "nostr:\(myGeo.publicKeyHex.prefix(8))"
+                        return spid == "nostr:\(myGeo.publicKeyHex.prefix(TransportConfig.nostrShortKeyDisplayLength))"
                     }
                 }
-                #endif
                 return spid == meshService.myPeerID
             }
             // Fallback by nickname
@@ -3146,11 +3089,9 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                         let (mBase, mSuffix) = splitSuffix(from: matchText.replacingOccurrences(of: "@", with: ""))
                         // Determine if this mention targets me (resolves with optional suffix per active channel)
                         let mySuffix: String? = {
-                            #if os(iOS)
                             if case .location(let ch) = activeChannel, let id = try? NostrIdentityBridge.deriveIdentity(forGeohash: ch.geohash) {
                                 return String(id.publicKeyHex.suffix(4))
                             }
-                            #endif
                             return String(meshService.myPeerID.prefix(4))
                         }()
                         let isMentionToMe: Bool = {
@@ -3183,12 +3124,28 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                             let token = String(matchText.dropFirst()).lowercased()
                             let allowed = Set("0123456789bcdefghjkmnpqrstuvwxyz")
                             let isGeohash = (2...12).contains(token.count) && token.allSatisfy { allowed.contains($0) }
+                            // Do not link if this hashtag is directly attached to an @mention (e.g., @name#geohash)
+                            let attachedToMention: Bool = {
+                                // nsRange is the Range<String.Index> for this match within content
+                                // Walk left until whitespace/newline; if we encounter '@' first, treat as part of mention
+                                if nsRange.lowerBound > content.startIndex {
+                                    var i = content.index(before: nsRange.lowerBound)
+                                    while true {
+                                        let ch = content[i]
+                                        if ch.isWhitespace || ch.isNewline { break }
+                                        if ch == "@" { return true }
+                                        if i == content.startIndex { break }
+                                        i = content.index(before: i)
+                                    }
+                                }
+                                return false
+                            }()
                             var tagStyle = AttributeContainer()
                             tagStyle.font = isSelf
                                 ? .system(size: 14, weight: .bold, design: .monospaced)
                                 : .system(size: 14, design: .monospaced)
                             tagStyle.foregroundColor = baseColor
-                            if isGeohash, let url = URL(string: "bitchat://geohash/\(token)") {
+                            if isGeohash && !attachedToMention, let url = URL(string: "bitchat://geohash/\(token)") {
                                 tagStyle.link = url
                                 tagStyle.underlineStyle = .single
                             }
@@ -3530,7 +3487,9 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         var hue = Double(djb2(seed) % 360) / 360.0
         // Avoid orange (~30°) reserved for self
         let orange = 30.0 / 360.0
-        if abs(hue - orange) < 0.05 { hue = fmod(hue + 0.12, 1.0) }
+        if abs(hue - orange) < TransportConfig.uiColorHueAvoidanceDelta {
+            hue = fmod(hue + TransportConfig.uiColorHueOffset, 1.0)
+        }
         let saturation: Double = isDark ? 0.80 : 0.70
         let brightness: Double = isDark ? 0.75 : 0.45
         let c = Color(hue: hue, saturation: saturation, brightness: brightness)
@@ -3586,7 +3545,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
     // Clear the current public channel's timeline (visible + persistent buffer)
     @MainActor
     func clearCurrentPublicTimeline() {
-        #if os(iOS)
         switch activeChannel {
         case .mesh:
             messages.removeAll()
@@ -3595,10 +3553,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             messages.removeAll()
             geoTimelines[ch.geohash] = []
         }
-        #else
-        messages.removeAll()
-        meshTimeline.removeAll()
-        #endif
     }
     
     private func trimPrivateChatMessagesIfNeeded(for peerID: String) {
@@ -3663,26 +3617,8 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         return unifiedPeerService.getFingerprint(for: peerID)
     }
     
-    private func getFingerprint_old(for peerID: String) -> String? {
-        // Remove debug logging to prevent console spam during view updates
-        
-        // First try to get fingerprint from mesh service's peer ID rotation mapping
-        if let fingerprint = meshService.getFingerprint(for: peerID) {
-            return fingerprint
-        }
-        
-        // Check noise service (direct Noise session fingerprint)
-        if let fingerprint = meshService.getNoiseService().getPeerFingerprint(peerID) {
-            return fingerprint
-        }
-        
-        // Last resort: check local mapping
-        if let fingerprint = peerIDToPublicKeyFingerprint[peerID] {
-            return fingerprint
-        }
-        
-        return nil
-    }
+    //
+
     
     // Helper to resolve nickname for a peer ID through various sources
     @MainActor
@@ -3763,7 +3699,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         // Load verified fingerprints directly from secure storage
         verifiedFingerprints = SecureIdentityStateManager.shared.getVerifiedFingerprints()
         // Log snapshot for debugging persistence
-        let sample = Array(verifiedFingerprints.prefix(3)).map { $0.prefix(8) }.joined(separator: ", ")
+        let sample = Array(verifiedFingerprints.prefix(TransportConfig.uiFingerprintSampleCount)).map { $0.prefix(8) }.joined(separator: ", ")
         SecureLogger.log("🔐 Verified loaded: \(verifiedFingerprints.count) [\(sample)]", category: SecureLogger.security, level: .info)
         // Also log any offline favorites and whether we consider them verified
         let offlineFavorites = unifiedPeerService.favorites.filter { !$0.isConnected }
@@ -4061,7 +3997,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                let favoriteStatus = FavoritesPersistenceService.shared.getFavoriteStatus(for: peer.noisePublicKey),
                favoriteStatus.isFavorite {
                 // Resend favorite notification with our Nostr key after a short delay
-                try? await Task.sleep(nanoseconds: 500_000_000) // 0.5 seconds
+                try? await Task.sleep(nanoseconds: TransportConfig.uiAsyncMediumSleepNs) // 0.5 seconds
                 meshService.sendFavoriteNotification(to: peerID, isFavorite: true)
                 SecureLogger.log("📤 Resent favorite notification to reconnected peer \(peerID)", 
                                 category: SecureLogger.session, level: .debug)
@@ -4080,7 +4016,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             messageRouter.flushOutbox(for: peerID)
         }
         
-        // Connection messages removed to reduce chat noise
+        //
     }
     
     func didDisconnectFromPeer(_ peerID: String) {
@@ -4147,7 +4083,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             }
         }
         
-        // Disconnection messages removed to reduce chat noise
+        //
     }
     
     func didUpdatePeerList(_ peers: [String]) {
@@ -4431,7 +4367,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
     // Used for emotes where we want a local system-style confirmation instead.
     @MainActor
     func sendPublicRaw(_ content: String) {
-        #if os(iOS)
         if case .location(let ch) = activeChannel {
             Task { @MainActor in
                 do {
@@ -4455,14 +4390,13 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             }
             return
         }
-        #endif
         // Default: send over mesh
         meshService.sendMessage(content, mentions: [])
     }
     
     // MARK: - Simplified Nostr Integration (Inlined from MessageRouter)
     
-    // Removed inlined Nostr send helpers in favor of MessageRouter
+    //
     
     @MainActor
     private func setupNostrMessageHandling() {
@@ -4477,7 +4411,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         // Subscribe to Nostr messages
         let filter = NostrFilter.giftWrapsFor(
             pubkey: currentIdentity.publicKeyHex,
-            since: Date().addingTimeInterval(-86400)  // Last 24 hours
+            since: Date().addingTimeInterval(-TransportConfig.nostrDMSubscribeLookbackSeconds)  // Last 24 hours
         )
         
         nostrRelayManager?.subscribe(filter: filter, id: "chat-messages") { [weak self] event in
@@ -4548,7 +4482,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             let messageTimestamp = Date(timeIntervalSince1970: TimeInterval(rumorTimestamp))
             let senderNickname = (actualSenderNoiseKey != nil) ? (FavoritesPersistenceService.shared.getFavoriteStatus(for: actualSenderNoiseKey!)?.peerNickname ?? "Unknown") : "Unknown"
             // Stable target ID if we know Noise key; otherwise temporary Nostr-based peer
-            let targetPeerID = actualSenderNoiseKey?.hexEncodedString() ?? ("nostr_" + senderPubkey.prefix(16))
+            let targetPeerID = actualSenderNoiseKey?.hexEncodedString() ?? ("nostr_" + senderPubkey.prefix(TransportConfig.nostrConvKeyPrefixLength))
 
             switch noisePayload.type {
             case .privateMessage:
@@ -4793,7 +4727,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         return Data(base64Encoded: str)
     }
     
-    // Removed local TLV decoder; using PrivateMessagePacket.decode from Protocols
+    //
     
     @MainActor
     private func handleFavoriteNotificationFromMesh(_ content: String, from peerID: String, senderNickname: String) {
@@ -4871,7 +4805,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         
         // For now, create a temporary peer ID based on Nostr pubkey
         // This allows the message to be displayed even without Noise key mapping
-        let tempPeerID = "nostr_" + senderPubkey.prefix(16)
+        let tempPeerID = "nostr_" + senderPubkey.prefix(TransportConfig.nostrConvKeyPrefixLength)
         
         // Check if we're viewing this unknown sender's chat
         let isViewingThisChat = selectedPrivateChatPeer == tempPeerID
@@ -5058,12 +4992,10 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
     // MARK: - Geohash Nickname Resolution (for /block in geohash)
     @MainActor
     func nostrPubkeyForDisplayName(_ name: String) -> String? {
-        // Look up current visible geohash participants for an exact displayName match (iOS only)
-        #if os(iOS)
+        // Look up current visible geohash participants for an exact displayName match
         for p in visibleGeohashPeople() {
             if p.displayName == name { return p.id }
         }
-        #endif
         return nil
     }
     
@@ -5101,7 +5033,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             var oldPeerIDsToRemove: [String] = []
             
             // Only migrate messages from the last 24 hours to prevent old messages from flooding
-            let cutoffTime = Date().addingTimeInterval(-24 * 60 * 60)
+            let cutoffTime = Date().addingTimeInterval(-TransportConfig.uiMigrationCutoffSeconds)
             
             for (oldPeerID, messages) in privateChats {
                 if oldPeerID != peerID {
@@ -5325,7 +5257,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             }
             
             // Mark other messages as read
-            DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { [weak self] in
+            DispatchQueue.main.asyncAfter(deadline: .now() + TransportConfig.uiReadReceiptRetryShortSeconds) { [weak self] in
                 self?.markPrivateMessagesAsRead(from: peerID)
             }
         }
@@ -5365,8 +5297,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             trimMeshTimelineIfNeeded()
         }
 
-        // Persist geochat messages to per-geohash timeline (iOS-only)
-        #if os(iOS)
+        // Persist geochat messages to per-geohash timeline
         if isGeo && finalMessage.sender != "system" {
             if let gh = currentGeohash {
                 var arr = geoTimelines[gh] ?? []
@@ -5375,20 +5306,14 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                 geoTimelines[gh] = arr
             }
         }
-        #endif
 
         // Only add message to current timeline if it matches active channel or is system
         let isSystem = finalMessage.sender == "system"
         let channelMatches: Bool = {
-            #if os(iOS)
             switch activeChannel {
             case .mesh: return !isGeo || isSystem
             case .location: return isGeo || isSystem
             }
-            #else
-            // On non-iOS builds, we don't have location channels; accept all
-            return true
-            #endif
         }()
 
         guard channelMatches else { return }
@@ -5568,7 +5493,7 @@ private func checkForMentions(_ message: BitchatMessage) {
             impactFeedback.prepare()
             
             for i in 0..<8 {
-                DispatchQueue.main.asyncAfter(deadline: .now() + Double(i) * 0.15) {
+                DispatchQueue.main.asyncAfter(deadline: .now() + Double(i) * TransportConfig.uiBatchDispatchStaggerSeconds) {
                     impactFeedback.impactOccurred()
                 }
             }

bitchat/Views/ContentView.swift

@@ -13,19 +13,9 @@ import UIKit
 
 // MARK: - Supporting Types
 
-// Pre-computed peer data for performance
-struct PeerDisplayData: Identifiable {
-    let id: String
-    let displayName: String
-    let isFavorite: Bool
-    let isMe: Bool
-    let hasUnreadMessages: Bool
-    let encryptionStatus: EncryptionStatus
-    let connectionState: BitchatPeer.ConnectionState
-    let isMutualFavorite: Bool
-}
+//
 
-// (Link previews removed; URLs are now clickable inline)
+//
 
 // MARK: - Main Content View
 
@@ -33,9 +23,7 @@ struct ContentView: View {
     // MARK: - Properties
     
     @EnvironmentObject var viewModel: ChatViewModel
-    #if os(iOS)
     @ObservedObject private var locationManager = LocationChannelManager.shared
-    #endif
     @State private var messageText = ""
     @State private var textFieldSelection: NSRange? = nil
     @FocusState private var isTextFieldFocused: Bool
@@ -112,14 +100,14 @@ struct ContentView: View {
                                 .onEnded { value in
                                     let translation = value.translation.width.isNaN ? 0 : value.translation.width
                                     let velocity = value.velocity.width.isNaN ? 0 : value.velocity.width
-                                    if translation > 50 || (translation > 30 && velocity > 300) {
-                                        withAnimation(.easeOut(duration: 0.2)) {
+                                    if translation > TransportConfig.uiBackSwipeTranslationLarge || (translation > TransportConfig.uiBackSwipeTranslationSmall && velocity > TransportConfig.uiBackSwipeVelocityThreshold) {
+                                        withAnimation(.easeOut(duration: TransportConfig.uiAnimationMediumSeconds)) {
                                             showPrivateChat = false
                                             backSwipeOffset = 0
                                             viewModel.endPrivateChat()
                                         }
                                     } else {
-                                        withAnimation(.easeOut(duration: 0.15)) {
+                                        withAnimation(.easeOut(duration: TransportConfig.uiAnimationShortSeconds)) {
                                             backSwipeOffset = 0
                                         }
                                     }
@@ -133,7 +121,7 @@ struct ContentView: View {
                     Color.clear
                         .contentShape(Rectangle())
                         .onTapGesture {
-                            withAnimation(.easeInOut(duration: 0.2)) {
+            withAnimation(.easeInOut(duration: TransportConfig.uiAnimationMediumSeconds)) {
                                 showSidebar = false
                                 sidebarDragOffset = 0
                             }
@@ -163,14 +151,14 @@ struct ContentView: View {
                     let width = geometry.size.width.isNaN ? 0 : max(0, geometry.size.width)
                     return showSidebar ? -dragOffset : width - dragOffset
                 }())
-                .animation(.easeInOut(duration: 0.25), value: showSidebar)
+                .animation(.easeInOut(duration: TransportConfig.uiAnimationSidebarSeconds), value: showSidebar)
             }
         }
         #if os(macOS)
         .frame(minWidth: 600, minHeight: 400)
         #endif
         .onChange(of: viewModel.selectedPrivateChatPeer) { newValue in
-            withAnimation(.easeInOut(duration: 0.2)) {
+            withAnimation(.easeInOut(duration: TransportConfig.uiAnimationMediumSeconds)) {
                 showPrivateChat = newValue != nil
             }
         }
@@ -200,7 +188,6 @@ struct ContentView: View {
 
             Button("direct message") {
                 if let peerID = selectedMessageSenderID {
-                    #if os(iOS)
                     if peerID.hasPrefix("nostr:") {
                         if let full = viewModel.fullNostrHex(forSenderPeerID: peerID) {
                             viewModel.startGeohashDM(withPubkeyHex: full)
@@ -208,10 +195,7 @@ struct ContentView: View {
                     } else {
                         viewModel.startPrivateChat(with: peerID)
                     }
-                    #else
-                    viewModel.startPrivateChat(with: peerID)
-                    #endif
-                    withAnimation(.easeInOut(duration: 0.2)) {
+                    withAnimation(.easeInOut(duration: TransportConfig.uiAnimationMediumSeconds)) {
                         showSidebar = false
                         sidebarDragOffset = 0
                     }
@@ -232,7 +216,6 @@ struct ContentView: View {
             
             Button("BLOCK", role: .destructive) {
                 // Prefer direct geohash block when we have a Nostr sender ID
-                #if os(iOS)
                 if let peerID = selectedMessageSenderID, peerID.hasPrefix("nostr:"),
                    let full = viewModel.fullNostrHex(forSenderPeerID: peerID),
                    let sender = selectedMessageSender {
@@ -240,9 +223,6 @@ struct ContentView: View {
                 } else if let sender = selectedMessageSender {
                     viewModel.sendMessage("/block \(sender)")
                 }
-                #else
-                if let sender = selectedMessageSender { viewModel.sendMessage("/block \(sender)") }
-                #endif
             }
             
             Button("cancel", role: .cancel) {}
@@ -284,13 +264,12 @@ struct ContentView: View {
                     
                     // Implement windowing with adjustable window count per chat
                     let currentWindowCount: Int = {
-                        if let peer = privatePeer { return windowCountPrivate[peer] ?? 300 }
+                        if let peer = privatePeer { return windowCountPrivate[peer] ?? TransportConfig.uiWindowInitialCountPrivate }
                         return windowCountPublic
                     }()
                     let windowedMessages = messages.suffix(currentWindowCount)
 
                     // Build stable UI IDs with a context key to avoid ID collisions when switching channels
-                    #if os(iOS)
                     let contextKey: String = {
                         if let peer = privatePeer { return "dm:\(peer)" }
                         switch locationManager.selectedChannel {
@@ -298,12 +277,6 @@ struct ContentView: View {
                         case .location(let ch): return "geo:\(ch.geohash)"
                         }
                     }()
-                    #else
-                    let contextKey: String = {
-                        if let peer = privatePeer { return "dm:\(peer)" }
-                        return "mesh"
-                    }()
-                    #endif
                     let items = windowedMessages.map { (uiID: "\(contextKey)|\($0.id)", message: $0) }
                     
                     ForEach(items, id: \.uiID) { item in
@@ -323,11 +296,11 @@ struct ContentView: View {
                                     let cashuTokens = message.content.extractCashuTokens()
                                     let lightningLinks = message.content.extractLightningLinks()
                                     HStack(alignment: .top, spacing: 0) {
-                                        let isLong = (message.content.count > 2000 || message.content.hasVeryLongToken(threshold: 512)) && cashuTokens.isEmpty
+                                        let isLong = (message.content.count > TransportConfig.uiLongMessageLengthThreshold || message.content.hasVeryLongToken(threshold: TransportConfig.uiVeryLongTokenThreshold)) && cashuTokens.isEmpty
                                         let isExpanded = expandedMessageIDs.contains(message.id)
                                         Text(viewModel.formatMessageAsText(message, colorScheme: colorScheme))
                                             .fixedSize(horizontal: false, vertical: true)
-                                            .lineLimit(isLong && !isExpanded ? 30 : nil)
+                                            .lineLimit(isLong && !isExpanded ? TransportConfig.uiLongMessageLineLimit : nil)
                                             .frame(maxWidth: .infinity, alignment: .leading)
                                         
                                         // Delivery status indicator for private messages
@@ -339,7 +312,7 @@ struct ContentView: View {
                                     }
                                     
                                     // Expand/Collapse for very long messages
-                                    if (message.content.count > 2000 || message.content.hasVeryLongToken(threshold: 512)) && cashuTokens.isEmpty {
+                                    if (message.content.count > TransportConfig.uiLongMessageLengthThreshold || message.content.hasVeryLongToken(threshold: TransportConfig.uiVeryLongTokenThreshold)) && cashuTokens.isEmpty {
                                         let isExpanded = expandedMessageIDs.contains(message.id)
                                         Button(isExpanded ? "show less" : "show more") {
                                             if isExpanded { expandedMessageIDs.remove(message.id) }
@@ -398,8 +371,7 @@ struct ContentView: View {
                             }
                             // Infinite scroll up: when top row appears, increase window and preserve anchor
                             if message.id == windowedMessages.first?.id, messages.count > windowedMessages.count {
-                                let step = 200
-                                #if os(iOS)
+                                let step = TransportConfig.uiWindowStepCount
                                 let contextKey: String = {
                                     if let peer = privatePeer { return "dm:\(peer)" }
                                     switch locationManager.selectedChannel {
@@ -407,15 +379,9 @@ struct ContentView: View {
                                     case .location(let ch): return "geo:\(ch.geohash)"
                                     }
                                 }()
-                                #else
-                                let contextKey: String = {
-                                    if let peer = privatePeer { return "dm:\(peer)" }
-                                    return "mesh"
-                                }()
-                                #endif
                                 let preserveID = "\(contextKey)|\(message.id)"
                                 if let peer = privatePeer {
-                                    let current = windowCountPrivate[peer] ?? 300
+                                    let current = windowCountPrivate[peer] ?? TransportConfig.uiWindowInitialCountPrivate
                                     let newCount = min(messages.count, current + step)
                                     if newCount != current {
                                         windowCountPrivate[peer] = newCount
@@ -481,7 +447,6 @@ struct ContentView: View {
                 let gh = url.path.trimmingCharacters(in: CharacterSet(charactersIn: "/")).lowercased()
                 let allowed = Set("0123456789bcdefghjkmnpqrstuvwxyz")
                 guard (2...12).contains(gh.count), gh.allSatisfy({ allowed.contains($0) }) else { return }
-                #if os(iOS)
                 func levelForLength(_ len: Int) -> GeohashChannelLevel {
                     switch len {
                     case 0...2: return .region
@@ -496,7 +461,6 @@ struct ContentView: View {
                 let ch = GeohashChannel(level: level, geohash: gh)
                 LocationChannelManager.shared.markTeleported(for: gh, true)
                 LocationChannelManager.shared.select(ChannelID.location(ch))
-                #endif
             }
             .onTapGesture(count: 3) {
                 // Triple-tap to clear current chat
@@ -509,16 +473,12 @@ struct ContentView: View {
                        let last = viewModel.getPrivateChatMessages(for: peer).suffix(300).last?.id {
                         return "dm:\(peer)|\(last)"
                     }
-                    #if os(iOS)
                     let contextKey: String = {
                         switch locationManager.selectedChannel {
                         case .mesh: return "mesh"
                         case .location(let ch): return "geo:\(ch.geohash)"
                         }
                     }()
-                    #else
-                    let contextKey: String = "mesh"
-                    #endif
                     if let last = viewModel.messages.suffix(300).last?.id { return "\(contextKey)|\(last)" }
                     return nil
                 }()
@@ -533,16 +493,12 @@ struct ContentView: View {
                            let last = viewModel.getPrivateChatMessages(for: peer).suffix(300).last?.id {
                             return "dm:\(peer)|\(last)"
                         }
-                        #if os(iOS)
                         let contextKey: String = {
                             switch locationManager.selectedChannel {
                             case .mesh: return "mesh"
                             case .location(let ch): return "geo:\(ch.geohash)"
                             }
                         }()
-                        #else
-                        let contextKey: String = "mesh"
-                        #endif
                         if let last = viewModel.messages.suffix(300).last?.id { return "\(contextKey)|\(last)" }
                         return nil
                     }()
@@ -556,16 +512,12 @@ struct ContentView: View {
                        let last = viewModel.getPrivateChatMessages(for: peer).suffix(300).last?.id {
                         return "dm:\(peer)|\(last)"
                     }
-                    #if os(iOS)
                     let contextKey: String = {
                         switch locationManager.selectedChannel {
                         case .mesh: return "mesh"
                         case .location(let ch): return "geo:\(ch.geohash)"
                         }
                     }()
-                    #else
-                    let contextKey: String = "mesh"
-                    #endif
                     if let last = viewModel.messages.suffix(300).last?.id { return "\(contextKey)|\(last)" }
                     return nil
                 }()
@@ -588,19 +540,15 @@ struct ContentView: View {
                     }
                     // Throttle scroll animations to prevent excessive UI updates
                     let now = Date()
-                    if now.timeIntervalSince(lastScrollTime) > 0.5 {
+                    if now.timeIntervalSince(lastScrollTime) > TransportConfig.uiScrollThrottleSeconds {
                         // Immediate scroll if enough time has passed
                         lastScrollTime = now
-                        #if os(iOS)
                         let contextKey: String = {
                             switch locationManager.selectedChannel {
                             case .mesh: return "mesh"
                             case .location(let ch): return "geo:\(ch.geohash)"
                             }
                         }()
-                        #else
-                        let contextKey: String = "mesh"
-                        #endif
                         let count = windowCountPublic
                         let target = viewModel.messages.suffix(count).last.map { "\(contextKey)|\($0.id)" }
                         DispatchQueue.main.async {
@@ -609,18 +557,14 @@ struct ContentView: View {
                     } else {
                         // Schedule a delayed scroll
                         scrollThrottleTimer?.invalidate()
-                        scrollThrottleTimer = Timer.scheduledTimer(withTimeInterval: 0.5, repeats: false) { _ in
+                        scrollThrottleTimer = Timer.scheduledTimer(withTimeInterval: TransportConfig.uiScrollThrottleSeconds, repeats: false) { _ in
                             lastScrollTime = Date()
-                            #if os(iOS)
-                            let contextKey: String = {
-                                switch locationManager.selectedChannel {
-                                case .mesh: return "mesh"
-                                case .location(let ch): return "geo:\(ch.geohash)"
-                                }
-                            }()
-                            #else
-                            let contextKey: String = "mesh"
-                            #endif
+                        let contextKey: String = {
+                            switch locationManager.selectedChannel {
+                            case .mesh: return "mesh"
+                            case .location(let ch): return "geo:\(ch.geohash)"
+                            }
+                        }()
                             let count = windowCountPublic
                             let target = viewModel.messages.suffix(count).last.map { "\(contextKey)|\($0.id)" }
                             DispatchQueue.main.async {
@@ -645,7 +589,7 @@ struct ContentView: View {
                     }
                     // Same throttling for private chats
                     let now = Date()
-                    if now.timeIntervalSince(lastScrollTime) > 0.5 {
+                    if now.timeIntervalSince(lastScrollTime) > TransportConfig.uiScrollThrottleSeconds {
                         lastScrollTime = now
                         let contextKey = "dm:\(peerID)"
                         let count = windowCountPrivate[peerID] ?? 300
@@ -655,7 +599,7 @@ struct ContentView: View {
                         }
                     } else {
                         scrollThrottleTimer?.invalidate()
-                        scrollThrottleTimer = Timer.scheduledTimer(withTimeInterval: 0.5, repeats: false) { _ in
+                        scrollThrottleTimer = Timer.scheduledTimer(withTimeInterval: TransportConfig.uiScrollThrottleSeconds, repeats: false) { _ in
                             lastScrollTime = Date()
                             let contextKey = "dm:\(peerID)"
                             let count = windowCountPrivate[peerID] ?? 300
@@ -667,7 +611,6 @@ struct ContentView: View {
                     }
                 }
             }
-            #if os(iOS)
             .onChange(of: locationManager.selectedChannel) { newChannel in
                 // When switching to a new geohash channel, scroll to the bottom
                 guard privatePeer == nil else { return }
@@ -676,7 +619,7 @@ struct ContentView: View {
                     break
                 case .location(let ch):
                     // Reset window size
-                    windowCountPublic = 300
+                    windowCountPublic = TransportConfig.uiWindowInitialCountPublic
                     let contextKey = "geo:\(ch.geohash)"
                     let last = viewModel.messages.suffix(windowCountPublic).last?.id
                     let target = last.map { "\(contextKey)|\($0)" }
@@ -686,18 +629,17 @@ struct ContentView: View {
                     }
                 }
             }
-            #endif
             .onAppear {
                 // Also check when view appears
                 if let peerID = privatePeer {
                     // Try multiple times to ensure read receipts are sent
                     viewModel.markPrivateMessagesAsRead(from: peerID)
                     
-                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
+                    DispatchQueue.main.asyncAfter(deadline: .now() + TransportConfig.uiReadReceiptRetryShortSeconds) {
                         viewModel.markPrivateMessagesAsRead(from: peerID)
                     }
                     
-                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                    DispatchQueue.main.asyncAfter(deadline: .now() + TransportConfig.uiReadReceiptRetryLongSeconds) {
                         viewModel.markPrivateMessagesAsRead(from: peerID)
                     }
                 }
@@ -756,18 +698,22 @@ struct ContentView: View {
             if showCommandSuggestions && !commandSuggestions.isEmpty {
                 VStack(alignment: .leading, spacing: 0) {
                     // Define commands with aliases and syntax
-                    let commandInfo: [(commands: [String], syntax: String?, description: String)] = [
+                    let baseInfo: [(commands: [String], syntax: String?, description: String)] = [
                         (["/block"], "[nickname]", "block or list blocked peers"),
                         (["/clear"], nil, "clear chat messages"),
-                        (["/fav"], "<nickname>", "add to favorites"),
-                        (["/help"], nil, "show this help"),
                         (["/hug"], "<nickname>", "send someone a warm hug"),
                         (["/m", "/msg"], "<nickname> [message]", "send private message"),
                         (["/slap"], "<nickname>", "slap someone with a trout"),
                         (["/unblock"], "<nickname>", "unblock a peer"),
-                        (["/unfav"], "<nickname>", "remove from favorites"),
                         (["/w"], nil, "see who's online")
                     ]
+                    let isGeoPublic: Bool = { if case .location = locationManager.selectedChannel { return true }; return false }()
+                    let isGeoDM: Bool = (viewModel.selectedPrivateChatPeer?.hasPrefix("nostr_") == true)
+                    let favInfo: [(commands: [String], syntax: String?, description: String)] = [
+                        (["/fav"], "<nickname>", "add to favorites"),
+                        (["/unfav"], "<nickname>", "remove from favorites")
+                    ]
+                    let commandInfo = baseInfo + ((isGeoPublic || isGeoDM) ? [] : favInfo)
                     
                     // Build the display
                     let allCommands = commandInfo
@@ -842,18 +788,25 @@ struct ContentView: View {
                     // Check for command autocomplete (instant, no debounce needed)
                     if newValue.hasPrefix("/") && newValue.count >= 1 {
                         // Build context-aware command list
-                        let commandDescriptions = [
+                        let isGeoPublic: Bool = {
+                            if case .location = locationManager.selectedChannel { return true }
+                            return false
+                        }()
+                        let isGeoDM: Bool = (viewModel.selectedPrivateChatPeer?.hasPrefix("nostr_") == true)
+                        var commandDescriptions = [
                             ("/block", "block or list blocked peers"),
                             ("/clear", "clear chat messages"),
-                            ("/fav", "add to favorites"),
-                            ("/help", "show this help"),
                             ("/hug", "send someone a warm hug"),
                             ("/m", "send private message"),
                             ("/slap", "slap someone with a trout"),
                             ("/unblock", "unblock a peer"),
-                            ("/unfav", "remove from favorites"),
                             ("/w", "see who's online")
                         ]
+                        // Only show favorites commands when not in geohash context
+                        if !(isGeoPublic || isGeoDM) {
+                            commandDescriptions.append(("/fav", "add to favorites"))
+                            commandDescriptions.append(("/unfav", "remove from favorites"))
+                        }
                         
                         let input = newValue.lowercased()
                         
@@ -906,7 +859,7 @@ struct ContentView: View {
         }
         .onAppear {
             // Delay keyboard focus to avoid iOS constraint warnings
-            DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
+            DispatchQueue.main.asyncAfter(deadline: .now() + TransportConfig.uiReadReceiptRetryShortSeconds) {
                 isTextFieldFocused = true
             }
         }
@@ -935,8 +888,7 @@ struct ContentView: View {
                         .font(.system(size: 16, weight: .bold, design: .monospaced))
                         .foregroundColor(textColor)
                     Spacer()
-                    // Show QR only on mesh channel's peer list
-                    #if os(iOS)
+                    // Show QR in mesh on all platforms
                     if case .mesh = locationManager.selectedChannel {
                         Button(action: { showVerifySheet = true }) {
                             Image(systemName: "qrcode")
@@ -945,14 +897,6 @@ struct ContentView: View {
                         .buttonStyle(.plain)
                         .help("Verification: show my QR or scan a friend")
                     }
-                    #else
-                    Button(action: { showVerifySheet = true }) {
-                        Image(systemName: "qrcode")
-                            .font(.system(size: 14))
-                    }
-                    .buttonStyle(.plain)
-                    .help("Verification: show my QR or scan a friend")
-                    #endif
                 }
                 .frame(height: 44) // Match header height
                 .padding(.horizontal, 12)
@@ -965,53 +909,34 @@ struct ContentView: View {
                 VStack(alignment: .leading, spacing: 6) {
                     // People section
                     VStack(alignment: .leading, spacing: 4) {
-                        #if os(iOS)
-                        if case .location = locationManager.selectedChannel {
-                            GeohashPeopleList(viewModel: viewModel,
-                                              textColor: textColor,
-                                              secondaryTextColor: secondaryTextColor,
-                                              onTapPerson: {
-                                                  withAnimation(.easeInOut(duration: 0.2)) {
-                                                      showSidebar = false
-                                                      sidebarDragOffset = 0
-                                                  }
-                                              })
-                        } else {
-                            MeshPeerList(viewModel: viewModel,
-                                         textColor: textColor,
-                                         secondaryTextColor: secondaryTextColor,
-                                         onTapPeer: { peerID in
-                                             viewModel.startPrivateChat(with: peerID)
-                                             withAnimation(.easeInOut(duration: 0.2)) {
-                                                 showSidebar = false
-                                                 sidebarDragOffset = 0
-                                             }
-                                         },
-                                         onToggleFavorite: { peerID in
-                                             viewModel.toggleFavorite(peerID: peerID)
-                                         },
-                                         onShowFingerprint: { peerID in
-                                             viewModel.showFingerprint(for: peerID)
-                                         })
-                        }
-                        #else
-                        MeshPeerList(viewModel: viewModel,
-                                     textColor: textColor,
-                                     secondaryTextColor: secondaryTextColor,
-                                     onTapPeer: { peerID in
-                                         viewModel.startPrivateChat(with: peerID)
-                                         withAnimation(.easeInOut(duration: 0.2)) {
-                                             showSidebar = false
-                                             sidebarDragOffset = 0
-                                         }
-                                     },
-                                     onToggleFavorite: { peerID in
-                                         viewModel.toggleFavorite(peerID: peerID)
-                                     },
-                                     onShowFingerprint: { peerID in
-                                         viewModel.showFingerprint(for: peerID)
-                                     })
-                        #endif
+                if case .location = locationManager.selectedChannel {
+                    GeohashPeopleList(viewModel: viewModel,
+                                      textColor: textColor,
+                                      secondaryTextColor: secondaryTextColor,
+                                      onTapPerson: {
+                                          withAnimation(.easeInOut(duration: 0.2)) {
+                                              showSidebar = false
+                                              sidebarDragOffset = 0
+                                          }
+                                      })
+                } else {
+                    MeshPeerList(viewModel: viewModel,
+                                 textColor: textColor,
+                                 secondaryTextColor: secondaryTextColor,
+                                 onTapPeer: { peerID in
+                                     viewModel.startPrivateChat(with: peerID)
+                                     withAnimation(.easeInOut(duration: TransportConfig.uiAnimationMediumSeconds)) {
+                                         showSidebar = false
+                                         sidebarDragOffset = 0
+                                     }
+                                 },
+                                 onToggleFavorite: { peerID in
+                                     viewModel.toggleFavorite(peerID: peerID)
+                                 },
+                                 onShowFingerprint: { peerID in
+                                     viewModel.showFingerprint(for: peerID)
+                                 })
+                }
                     }
                 }
                 .id(viewModel.allPeers.map { "\($0.id)-\($0.isConnected)" }.joined())
@@ -1048,7 +973,7 @@ struct ContentView: View {
                 .onEnded { value in
                     let translation = value.translation.width.isNaN ? 0 : value.translation.width
                     let velocity = value.velocity.width.isNaN ? 0 : value.velocity.width
-                    withAnimation(.easeOut(duration: 0.2)) {
+                    withAnimation(.easeOut(duration: TransportConfig.uiAnimationMediumSeconds)) {
                         if !showSidebar {
                             if translation < -100 || (translation < -50 && velocity < -500) {
                                 showSidebar = true
@@ -1101,13 +1026,11 @@ struct ContentView: View {
         return (name, "")
     }
     
-    #if os(iOS)
-    // Compute channel-aware people count and color for toolbar
+    // Compute channel-aware people count and color for toolbar (cross-platform)
     private func channelPeopleCountAndColor() -> (Int, Color) {
         switch locationManager.selectedChannel {
         case .location:
             let n = viewModel.geohashPeople.count
-            // Use standard green (dark: system green; light: custom darker green)
             let standardGreen = (colorScheme == .dark) ? Color.green : Color(red: 0, green: 0.5, blue: 0)
             return (n, n > 0 ? standardGreen : Color.secondary)
         case .mesh:
@@ -1117,13 +1040,11 @@ struct ContentView: View {
                 if isMeshConnected { counts.mesh += 1; counts.others += 1 }
                 else if peer.isMutualFavorite { counts.others += 1 }
             }
-            // Darker, more neutral blue (less purple hue)
             let meshBlue = Color(hue: 0.60, saturation: 0.85, brightness: 0.82)
             let color: Color = counts.mesh > 0 ? meshBlue : Color.secondary
             return (counts.others, color)
         }
     }
-    #endif
 
     
     private var mainHeaderView: some View {
@@ -1170,7 +1091,6 @@ struct ContentView: View {
             
             // Channel badge + dynamic spacing + people counter
             // Precompute header count and color outside the ViewBuilder expressions
-            #if os(iOS)
             let cc = channelPeopleCountAndColor()
             let headerCountColor: Color = cc.1
             let headerOtherPeersCount: Int = {
@@ -1179,24 +1099,11 @@ struct ContentView: View {
                 }
                 return cc.0
             }()
-            #else
-            let peerCounts = viewModel.allPeers.reduce(into: (others: 0, mesh: 0)) { counts, peer in
-                guard peer.id != viewModel.meshService.myPeerID else { return }
-                let isMeshConnected = peer.isConnected
-                if isMeshConnected { counts.mesh += 1; counts.others += 1 }
-                else if peer.isMutualFavorite { counts.others += 1 }
-            }
-            let headerOtherPeersCount = peerCounts.others
-            // Darker, more neutral blue (less purple hue)
-            let meshBlue = Color(hue: 0.60, saturation: 0.85, brightness: 0.82)
-            let headerCountColor: Color = (peerCounts.mesh > 0) ? meshBlue : Color.secondary
-            #endif
 
             HStack(spacing: 10) {
                 // Unread icon immediately to the left of the channel badge (independent from channel button)
                 
-                // Unread indicator
-                #if os(iOS)
+                // Unread indicator (now shown on iOS and macOS)
                 if viewModel.hasAnyUnreadMessages {
                     Button(action: { viewModel.openMostRelevantPrivateChat() }) {
                         Image(systemName: "envelope.fill")
@@ -1231,7 +1138,6 @@ struct ContentView: View {
                         .accessibilityLabel("location channels")
                 }
                 .buttonStyle(.plain)
-                #endif
 
                 HStack(spacing: 4) {
                     // People icon with count
@@ -1247,7 +1153,7 @@ struct ContentView: View {
                 // QR moved to the PEOPLE header in the sidebar when on mesh channel
             }
             .onTapGesture {
-                withAnimation(.easeInOut(duration: 0.2)) {
+                withAnimation(.easeInOut(duration: TransportConfig.uiAnimationMediumSeconds)) {
                     showSidebar.toggle()
                     sidebarDragOffset = 0
                 }
@@ -1259,11 +1165,9 @@ struct ContentView: View {
         }
         .frame(height: 44)
         .padding(.horizontal, 12)
-        #if os(iOS)
         .sheet(isPresented: $showLocationChannelsSheet) {
             LocationChannelsSheet(isPresented: $showLocationChannelsSheet)
         }
-        #endif
         .background(backgroundColor.opacity(0.95))
     }
     
@@ -1299,13 +1203,11 @@ struct ContentView: View {
         let peer = viewModel.getPeer(byID: headerPeerID)
         let privatePeerNick: String = {
             if privatePeerID.hasPrefix("nostr_") {
-                #if os(iOS)
                 // Build geohash DM header: "#<ghash>/@name#abcd"
                 if case .location(let ch) = locationManager.selectedChannel {
                     let disp = viewModel.geohashDisplayName(for: privatePeerID)
                     return "#\(ch.geohash)/@\(disp)"
                 }
-                #endif
             }
             return peer?.displayName ?? 
                    viewModel.meshService.peerNickname(peerID: headerPeerID) ??
@@ -1392,7 +1294,7 @@ struct ContentView: View {
                     // Left and right buttons positioned with HStack
                     HStack {
                         Button(action: {
-                            withAnimation(.easeInOut(duration: 0.2)) {
+                            withAnimation(.easeInOut(duration: TransportConfig.uiAnimationMediumSeconds)) {
                                 showPrivateChat = false
                                 viewModel.endPrivateChat()
                             }
@@ -1470,23 +1372,7 @@ private struct PaymentChipView: View {
     }
 }
 
-// Helper view for rendering message content (plain, no hashtag/mention formatting)
-struct MessageContentView: View {
-    let message: BitchatMessage
-    let viewModel: ChatViewModel
-    let colorScheme: ColorScheme
-    let isMentioned: Bool
-    
-    var body: some View {
-        Text(message.content)
-            .font(.system(size: 14, design: .monospaced))
-            .fontWeight(isMentioned ? .bold : .regular)
-    }
-    
-    // MARK: - Helper Methods
-    
-    // buildTextSegments removed: content is rendered plain.
-}
+//
 
 // Delivery status indicator view
 struct DeliveryStatusView: View {

bitchat/Views/GeohashPeopleList.swift

@@ -1,6 +1,5 @@
 import SwiftUI
 
-#if os(iOS)
 struct GeohashPeopleList: View {
     @ObservedObject var viewModel: ChatViewModel
     let textColor: Color
@@ -29,16 +28,12 @@ struct GeohashPeopleList: View {
             let people = viewModel.visibleGeohashPeople()
             let currentIDs = people.map { $0.id }
 
-            #if os(iOS)
             let teleportedSet = Set(viewModel.teleportedGeo.map { $0.lowercased() })
             let isTeleportedID: (String) -> Bool = { id in
                 if teleportedSet.contains(id.lowercased()) { return true }
                 if let me = myHex, id == me, LocationChannelManager.shared.teleported { return true }
                 return false
             }
-            #else
-            let isTeleportedID: (String) -> Bool = { _ in false }
-            #endif
 
             let displayIDs = orderedIDs.filter { currentIDs.contains($0) } + currentIDs.filter { !orderedIDs.contains($0) }
             let nonTele = displayIDs.filter { !isTeleportedID($0) }
@@ -52,11 +47,7 @@ struct GeohashPeopleList: View {
                     let person = personByID[pid]!
                     HStack(spacing: 4) {
                         let isMe = (person.id == myHex)
-                        #if os(iOS)
                         let teleported = viewModel.teleportedGeo.contains(person.id.lowercased()) || (isMe && LocationChannelManager.shared.teleported)
-                        #else
-                        let teleported = false
-                        #endif
                         let icon = teleported ? "face.dashed" : "mappin.and.ellipse"
                         let assignedColor = viewModel.colorForNostrPubkey(person.id, isDark: colorScheme == .dark)
                         let rowColor: Color = isMe ? .orange : assignedColor
@@ -127,10 +118,8 @@ struct GeohashPeopleList: View {
         }
     }
 }
-#endif
 
 // Helper to split a trailing #abcd suffix
-#if os(iOS)
 private func splitSuffix(from name: String) -> (String, String) {
     guard name.count >= 5 else { return (name, "") }
     let suffix = String(name.suffix(5))
@@ -142,4 +131,3 @@ private func splitSuffix(from name: String) -> (String, String) {
     }
     return (name, "")
 }
-#endif

bitchat/Views/LocationChannelsSheet.swift

@@ -1,7 +1,10 @@
 import SwiftUI
-
+import CoreLocation
 #if os(iOS)
 import UIKit
+#else
+import AppKit
+#endif
 struct LocationChannelsSheet: View {
     @Binding var isPresented: Bool
     @ObservedObject private var manager = LocationChannelManager.shared
@@ -37,11 +40,7 @@ struct LocationChannelsSheet: View {
                             Text("location permission denied. enable in settings to use location channels.")
                                 .font(.system(size: 12, design: .monospaced))
                                 .foregroundColor(.secondary)
-                            Button("open settings") {
-                                if let url = URL(string: UIApplication.openSettingsURLString) {
-                                    UIApplication.shared.open(url)
-                                }
-                            }
+                            Button("open settings") { openSystemLocationSettings() }
                             .buttonStyle(.plain)
                         }
                     case LocationChannelManager.PermissionState.authorized:
@@ -54,6 +53,7 @@ struct LocationChannelsSheet: View {
             }
             .padding(.horizontal, 16)
             .padding(.vertical, 12)
+            #if os(iOS)
             .navigationBarTitleDisplayMode(.inline)
             .toolbar {
                 ToolbarItem(placement: .navigationBarTrailing) {
@@ -61,8 +61,21 @@ struct LocationChannelsSheet: View {
                         .font(.system(size: 14, design: .monospaced))
                 }
             }
+            #else
+            .toolbar {
+                ToolbarItem(placement: .automatic) {
+                    Button("close") { isPresented = false }
+                        .font(.system(size: 14, design: .monospaced))
+                }
+            }
+            #endif
         }
+        #if os(iOS)
         .presentationDetents([.large])
+        #endif
+        #if os(macOS)
+        .frame(minWidth: 420, minHeight: 520)
+        #endif
         .onAppear {
             // Refresh channels when opening
             if manager.permissionState == LocationChannelManager.PermissionState.authorized {
@@ -128,10 +141,12 @@ struct LocationChannelsSheet: View {
                         .font(.system(size: 14, design: .monospaced))
                         .foregroundColor(.secondary)
                     TextField("geohash", text: $customGeohash)
+                        #if os(iOS)
                         .textInputAutocapitalization(.never)
                         .autocorrectionDisabled(true)
-                        .font(.system(size: 14, design: .monospaced))
                         .keyboardType(.asciiCapable)
+                        #endif
+                        .font(.system(size: 14, design: .monospaced))
                         .onChange(of: customGeohash) { newValue in
                             // Allow only geohash base32 characters, strip '#', limit length
                             let allowed = Set("0123456789bcdefghjkmnpqrstuvwxyz")
@@ -183,9 +198,7 @@ struct LocationChannelsSheet: View {
             // Footer action inside the list
             if manager.permissionState == LocationChannelManager.PermissionState.authorized {
                 Button(action: {
-                    if let url = URL(string: UIApplication.openSettingsURLString) {
-                        UIApplication.shared.open(url)
-                    }
+                    openSystemLocationSettings()
                 }) {
                     Text("remove location access")
                         .font(.system(size: 12, design: .monospaced))
@@ -343,7 +356,7 @@ extension LocationChannelsSheet {
         }()
 
         let usesMetric: Bool = {
-            if #available(iOS 16.0, *) {
+            if #available(iOS 16.0, macOS 13.0, *) {
                 return Locale.current.measurementSystem == .metric
             } else {
                 return Locale.current.usesMetricSystem
@@ -366,7 +379,7 @@ extension LocationChannelsSheet {
 
     private func bluetoothRangeString() -> String {
         let usesMetric: Bool = {
-            if #available(iOS 16.0, *) {
+            if #available(iOS 16.0, macOS 13.0, *) {
                 return Locale.current.measurementSystem == .metric
             } else {
                 return Locale.current.usesMetricSystem
@@ -390,4 +403,17 @@ extension LocationChannelsSheet {
     }
 }
 
-#endif
+// MARK: - Open Settings helper
+private func openSystemLocationSettings() {
+    #if os(iOS)
+    if let url = URL(string: UIApplication.openSettingsURLString) {
+        UIApplication.shared.open(url)
+    }
+    #else
+    if let url = URL(string: "x-apple.systempreferences:com.apple.preference.security?Privacy_LocationServices") {
+        NSWorkspace.shared.open(url)
+    } else if let url = URL(string: "x-apple.systempreferences:com.apple.preference.security") {
+        NSWorkspace.shared.open(url)
+    }
+    #endif
+}

bitchat/bitchat-macOS.entitlements

@@ -10,7 +10,9 @@
 	</array>
 	<key>com.apple.security.device.bluetooth</key>
 	<true/>
+	<key>com.apple.security.personal-information.location</key>
+	<true/>
 	<key>com.apple.security.network.client</key>
 	<true/>
 </dict>
-</plist>
+</plist>

bitchatShareExtension/ShareViewController.swift

@@ -7,160 +7,160 @@
 //
 
 import UIKit
-import Social
 import UniformTypeIdentifiers
 
-class ShareViewController: SLComposeServiceViewController {
-    
+/// Modern share extension using UIKit + UTTypes.
+/// Avoids deprecated Social framework and SLComposeServiceViewController.
+final class ShareViewController: UIViewController {
+    private let statusLabel: UILabel = {
+        let l = UILabel()
+        l.translatesAutoresizingMaskIntoConstraints = false
+        l.font = .systemFont(ofSize: 15, weight: .semibold)
+        l.textAlignment = .center
+        l.numberOfLines = 0
+        l.textColor = .label
+        return l
+    }()
+
     override func viewDidLoad() {
         super.viewDidLoad()
-        // Set placeholder text
-        placeholder = "Share to bitchat..."
-        // Set character limit (optional)
-        charactersRemaining = 500
+        view.backgroundColor = .systemBackground
+        view.addSubview(statusLabel)
+        NSLayoutConstraint.activate([
+            statusLabel.centerXAnchor.constraint(equalTo: view.centerXAnchor),
+            statusLabel.centerYAnchor.constraint(equalTo: view.centerYAnchor),
+            statusLabel.leadingAnchor.constraint(greaterThanOrEqualTo: view.layoutMarginsGuide.leadingAnchor),
+            statusLabel.trailingAnchor.constraint(lessThanOrEqualTo: view.layoutMarginsGuide.trailingAnchor)
+        ])
+
+        processShare()
     }
-    
-    override func isContentValid() -> Bool {
-        // Validate that we have text content or attachments
-        if let text = contentText, !text.isEmpty {
-            return true
-        }
-        // Check if we have attachments
-        if let item = extensionContext?.inputItems.first as? NSExtensionItem,
-           let attachments = item.attachments,
-           !attachments.isEmpty {
-            return true
-        }
-        return false
-    }
-    
-    override func didSelectPost() {
-        guard let extensionItem = extensionContext?.inputItems.first as? NSExtensionItem else {
-            self.extensionContext?.completeRequest(returningItems: nil, completionHandler: nil)
+
+    // MARK: - Processing
+    private func processShare() {
+        guard let ctx = self.extensionContext,
+              let item = ctx.inputItems.first as? NSExtensionItem else {
+            finishWithMessage("Nothing to share")
             return
         }
-        
-        
-        // Get the page title from the compose view or extension item
-        let pageTitle = self.contentText ?? extensionItem.attributedContentText?.string ?? extensionItem.attributedTitle?.string
-        
-        var foundURL: URL? = nil
-        let group = DispatchGroup()
-        
-        // IMPORTANT: Check if the NSExtensionItem itself has a URL
-        // Safari often provides the URL as an attributedString with a link
-        if let attributedText = extensionItem.attributedContentText {
-            let text = attributedText.string
-            let detector = try? NSDataDetector(types: NSTextCheckingResult.CheckingType.link.rawValue)
-            let matches = detector?.matches(in: text, options: [], range: NSRange(location: 0, length: text.utf16.count))
-            if let firstMatch = matches?.first, let url = firstMatch.url {
-                foundURL = url
-            }
+
+        // Try content from attributed text first (Safari often passes URL here)
+        if let url = detectURL(in: item.attributedContentText?.string ?? "") {
+            saveAndFinish(url: url, title: item.attributedTitle?.string)
+            return
         }
-        
-        // Only check attachments if we haven't found a URL yet
-        if foundURL == nil {
-            for (_, itemProvider) in (extensionItem.attachments ?? []).enumerated() {
-                
-                // Try multiple URL type identifiers that Safari might use
-                let urlTypes = [
-                    UTType.url.identifier,
-                    "public.url",
-                    "public.file-url"
-                ]
-                
-                for urlType in urlTypes {
-                    if itemProvider.hasItemConformingToTypeIdentifier(urlType) {
-                        group.enter()
-                        itemProvider.loadItem(forTypeIdentifier: urlType, options: nil) { (item, error) in
-                            defer { group.leave() }
-                            
-                            if let url = item as? URL {
-                                foundURL = url
-                        } else if let data = item as? Data,
-                                  let urlString = String(data: data, encoding: .utf8),
-                                  let url = URL(string: urlString) {
-                            foundURL = url
-                        } else if let string = item as? String,
-                                  let url = URL(string: string) {
-                            foundURL = url
-                        }
-                    }
-                    break // Found a URL type, no need to check other types
-                }
+
+        // Scan attachments for URL/text
+        let providers = item.attachments ?? []
+        if providers.isEmpty {
+            // Fallback: use attributed title as plain text
+            if let title = item.attributedTitle?.string, !title.isEmpty {
+                saveAndFinish(text: title)
+            } else {
+                finishWithMessage("No shareable content")
             }
-            
-            // Also check for plain text that might be a URL
-            if foundURL == nil && itemProvider.hasItemConformingToTypeIdentifier(UTType.plainText.identifier) {
-                group.enter()
-                itemProvider.loadItem(forTypeIdentifier: UTType.plainText.identifier, options: nil) { (item, error) in
-                    defer { group.leave() }
-                    
-                    if let text = item as? String {
-                        // Check if the text is actually a URL
-                        if let url = URL(string: text),
-                           (url.scheme == "http" || url.scheme == "https") {
-                            foundURL = url
+            return
+        }
+
+        // Load URL or text asynchronously
+        loadFirstURL(from: providers) { [weak self] url in
+            guard let self = self else { return }
+            if let url = url {
+                self.saveAndFinish(url: url, title: item.attributedTitle?.string)
+            } else {
+                self.loadFirstPlainText(from: providers) { text in
+                    if let t = text, !t.isEmpty {
+                        // Treat as URL if parseable http(s), else plain text
+                        if let u = URL(string: t), ["http","https"].contains(u.scheme?.lowercased() ?? "") {
+                            self.saveAndFinish(url: u, title: item.attributedTitle?.string)
+                        } else {
+                            self.saveAndFinish(text: t)
                         }
+                    } else {
+                        self.finishWithMessage("No shareable content")
                     }
                 }
             }
         }
-        } // End of if foundURL == nil
-        
-        // Process after all checks complete
-        group.notify(queue: .main) { [weak self] in
-            if let url = foundURL {
-                // We have a URL! Create the JSON data
-                let urlData: [String: String] = [
-                    "url": url.absoluteString,
-                    "title": pageTitle ?? url.host ?? "Shared Link"
-                ]
-                
-                
-                if let jsonData = try? JSONSerialization.data(withJSONObject: urlData),
-                   let jsonString = String(data: jsonData, encoding: .utf8) {
-                    self?.saveToSharedDefaults(content: jsonString, type: "url")
+    }
+
+    private func detectURL(in text: String) -> URL? {
+        guard !text.isEmpty else { return nil }
+        let detector = try? NSDataDetector(types: NSTextCheckingResult.CheckingType.link.rawValue)
+        let range = NSRange(location: 0, length: (text as NSString).length)
+        let match = detector?.matches(in: text, options: [], range: range).first
+        return match?.url
+    }
+
+    private func loadFirstURL(from providers: [NSItemProvider], completion: @escaping (URL?) -> Void) {
+        let identifiers = [UTType.url.identifier, "public.url", "public.file-url"]
+        let grp = DispatchGroup()
+        var found: URL?
+
+        for p in providers where found == nil {
+            for id in identifiers where p.hasItemConformingToTypeIdentifier(id) {
+                grp.enter()
+                p.loadItem(forTypeIdentifier: id, options: nil) { item, _ in
+                    defer { grp.leave() }
+                    if let u = item as? URL { found = u; return }
+                    if let s = item as? String, let u = URL(string: s) { found = u; return }
+                    if let d = item as? Data, let s = String(data: d, encoding: .utf8), let u = URL(string: s) { found = u; return }
                 }
-            } else if let title = pageTitle, !title.isEmpty {
-                // No URL found, just share the text
-                self?.saveToSharedDefaults(content: title, type: "text")
+                break
             }
-            
-            self?.extensionContext?.completeRequest(returningItems: nil, completionHandler: nil)
+        }
+        grp.notify(queue: .main) { completion(found) }
+    }
+
+    private func loadFirstPlainText(from providers: [NSItemProvider], completion: @escaping (String?) -> Void) {
+        let id = UTType.plainText.identifier
+        let grp = DispatchGroup()
+        var text: String?
+        for p in providers where p.hasItemConformingToTypeIdentifier(id) {
+            grp.enter()
+            p.loadItem(forTypeIdentifier: id, options: nil) { item, _ in
+                defer { grp.leave() }
+                if let s = item as? String { text = s }
+                else if let d = item as? Data, let s = String(data: d, encoding: .utf8) { text = s }
+            }
+            break
+        }
+        grp.notify(queue: .main) { completion(text) }
+    }
+
+    // MARK: - Save + Finish
+    private func saveAndFinish(url: URL, title: String?) {
+        let payload: [String: String] = [
+            "url": url.absoluteString,
+            "title": title ?? url.host ?? "Shared Link"
+        ]
+        if let json = try? JSONSerialization.data(withJSONObject: payload),
+           let s = String(data: json, encoding: .utf8) {
+            saveToSharedDefaults(content: s, type: "url")
+            finishWithMessage("✓ Shared link to bitchat")
+        } else {
+            finishWithMessage("Failed to encode link")
         }
     }
-    
-    override func configurationItems() -> [Any]! {
-        // No configuration items needed
-        return []
+
+    private func saveAndFinish(text: String) {
+        saveToSharedDefaults(content: text, type: "text")
+        finishWithMessage("✓ Shared text to bitchat")
     }
-    
-    // MARK: - Helper Methods
-    
+
     private func saveToSharedDefaults(content: String, type: String) {
-        // Use app groups to share data between extension and main app
-        guard let userDefaults = UserDefaults(suiteName: "group.chat.bitchat") else {
-            return
-        }
-        
+        guard let userDefaults = UserDefaults(suiteName: "group.chat.bitchat") else { return }
         userDefaults.set(content, forKey: "sharedContent")
         userDefaults.set(type, forKey: "sharedContentType")
         userDefaults.set(Date(), forKey: "sharedContentDate")
-        userDefaults.synchronize()
-        
-        
-        // Force open the main app
-        self.openMainApp()
+        // No need to force synchronize; the system persists changes
     }
-    
-    private func openMainApp() {
-        // Share extensions cannot directly open the containing app
-        // The app will check for shared content when it becomes active
-        // Show success feedback to user
-        DispatchQueue.main.async {
-            self.textView.text = "✓ Shared to bitchat"
-            self.textView.isEditable = false
+
+    private func finishWithMessage(_ msg: String) {
+        statusLabel.text = msg
+        // Complete shortly after showing status
+        DispatchQueue.main.asyncAfter(deadline: .now() + TransportConfig.uiShareExtensionDismissDelaySeconds) {
+            self.extensionContext?.completeRequest(returningItems: nil, completionHandler: nil)
         }
     }
-}
+}

bitchatTests/NostrProtocolTests.swift

@@ -21,8 +21,10 @@ final class NostrProtocolTests: XCTestCase {
         let sender = try NostrIdentity.generate()
         let recipient = try NostrIdentity.generate()
         
+        #if DEBUG
         print("Sender pubkey: \(sender.publicKeyHex)")
         print("Recipient pubkey: \(recipient.publicKeyHex)")
+        #endif
         
         // Create a test message
         let originalContent = "Hello from NIP-17 test!"
@@ -34,8 +36,10 @@ final class NostrProtocolTests: XCTestCase {
             senderIdentity: sender
         )
         
+        #if DEBUG
         print("Gift wrap created with ID: \(giftWrap.id)")
         print("Gift wrap pubkey: \(giftWrap.pubkey)")
+        #endif
         
         // Decrypt the gift wrap
         let (decryptedContent, senderPubkey, timestamp) = try NostrProtocol.decryptPrivateMessage(
@@ -52,7 +56,9 @@ final class NostrProtocolTests: XCTestCase {
         let timeDiff = abs(messageDate.timeIntervalSinceNow)
         XCTAssertLessThan(timeDiff, 60, "Message timestamp should be recent")
         
+        #if DEBUG
         print("✅ Successfully decrypted message: '\(decryptedContent)' from \(senderPubkey) at \(messageDate)")
+        #endif
     }
     
     func testGiftWrapUsesUniqueEphemeralKeys() throws {
@@ -75,8 +81,10 @@ final class NostrProtocolTests: XCTestCase {
         
         // Gift wrap pubkeys should be different (unique ephemeral keys)
         XCTAssertNotEqual(message1.pubkey, message2.pubkey)
+        #if DEBUG
         print("Message 1 gift wrap pubkey: \(message1.pubkey)")
         print("Message 2 gift wrap pubkey: \(message2.pubkey)")
+        #endif
         
         // Both should decrypt successfully
         let (content1, _, _) = try NostrProtocol.decryptPrivateMessage(
@@ -109,7 +117,9 @@ final class NostrProtocolTests: XCTestCase {
             giftWrap: giftWrap,
             recipientIdentity: wrongRecipient
         )) { error in
+            #if DEBUG
             print("Expected error when decrypting with wrong key: \(error)")
+            #endif
         }
     }
 

bitchatTests/TestUtilities/LegacyTestProtocolTypes.swift

@@ -1,45 +0,0 @@
-//
-// LegacyTestProtocolTypes.swift
-// bitchatTests
-//
-// Minimal legacy protocol types used only by tests to simulate old flows.
-// These are not part of production code anymore.
-
-import Foundation
-
-struct ProtocolNack {
-    let originalPacketID: String
-    let nackID: String
-    let senderID: String
-    let receiverID: String
-    let packetType: UInt8
-    let reason: String
-    let errorCode: UInt8
-    
-    enum ErrorCode: UInt8 {
-        case unknown = 0
-        case decryptionFailed = 2
-    }
-    
-    init(originalPacketID: String, senderID: String, receiverID: String, packetType: UInt8, reason: String, errorCode: ErrorCode = .unknown) {
-        self.originalPacketID = originalPacketID
-        self.nackID = UUID().uuidString
-        self.senderID = senderID
-        self.receiverID = receiverID
-        self.packetType = packetType
-        self.reason = reason
-        self.errorCode = errorCode.rawValue
-    }
-    
-    func toBinaryData() -> Data {
-        // Tests don't parse the payload; return a compact encoding for completeness
-        var data = Data()
-        data.appendUUID(originalPacketID)
-        data.appendUUID(nackID)
-        data.append(UInt8(packetType))
-        data.append(UInt8(errorCode))
-        data.appendString(reason)
-        return data
-    }
-}
-

build.log

@@ -1,13 +0,0 @@
-Command line invocation:
-    /Applications/Xcode.app/Contents/Developer/usr/bin/xcodebuild -project bitchat.xcodeproj -scheme bitchat -configuration Debug -sdk iphonesimulator CODE_SIGNING_ALLOWED=NO ONLY_ACTIVE_ARCH=YES
-
-Build settings from command line:
-    CODE_SIGNING_ALLOWED = NO
-    ONLY_ACTIVE_ARCH = YES
-    SDKROOT = iphonesimulator18.5
-
-Resolve Package Graph
-/Users/jack/Library/org.swift.swiftpm/configuration is not accessible or not writable, disabling user-level cache features./Users/jack/Library/org.swift.swiftpm/security is not accessible or not writable, disabling user-level cache features./Users/jack/Library/Caches/org.swift.swiftpm is not accessible or not writable, disabling user-level cache features.
-Package: swift-secp256k1
-
-fatalError