@offline-protocol/mesh-sdk 0.2.1 → 0.2.3

package/ios/BleManager.swift

@@ -152,15 +152,35 @@ public class BleManager: NSObject, TransportManager {
     private var lastPeerCountUpdate: Date?
     private let SCAN_HEARTBEAT_INTERVAL: TimeInterval = 10.0
     private let SCAN_RESTART_INTERVAL: TimeInterval = 30.0
+    /// Force a complete BLE stack refresh periodically even when things seem healthy
+    private let FORCED_BLE_REFRESH_INTERVAL: TimeInterval = 120.0
+    private var lastForcedBleRefresh: Date?
     private var connectionMonitor: DispatchSourceTimer?
     private var connectionAttemptTimestamps: [UUID: Date] = [:]
+    private var connectionRetryCount: [UUID: Int] = [:]
     private let CONNECTION_MONITOR_INTERVAL: TimeInterval = 5.0
     private let MIN_RECONNECT_INTERVAL: TimeInterval = 5.0
+    private let MAX_RECONNECT_INTERVAL: TimeInterval = 60.0
+    private let MAX_CONNECTION_RETRIES = 5
     private var scanRestartCount: Int = 0
     private var lastCentralReset: Date?
     private let MAX_CONSECUTIVE_SCAN_RESTARTS = 3
     private let CENTRAL_RESET_BACKOFF: TimeInterval = 45.0
     private let MINIMUM_RSSI_TO_CONNECT: Int16 = -90
+    /// Rate limiting for unknown connectable devices that need GATT verification
+    private var unknownDeviceAttempts: [UUID: Date] = [:]
+    private let UNKNOWN_DEVICE_RATE_LIMIT: TimeInterval = 5.0 // More aggressive for cross-platform discovery
+    private let UNKNOWN_DEVICE_MIN_RSSI: Int16 = -80 // More lenient for cross-platform discovery
+    private let MAX_UNKNOWN_DEVICE_ATTEMPTS_PER_MINUTE = 10
+    /// Proactive scan refresh interval even when discoveries are occurring
+    private let PROACTIVE_SCAN_REFRESH_INTERVAL: TimeInterval = 60.0
+    private var lastProactiveScanRefresh: Date?
+    /// Tracks recently seen advertisement hashes to avoid duplicate processing
+    private var recentAdvertisementHashes: [UUID: (hash: Int, timestamp: Date)] = [:]
+    /// Initial aggressive discovery phase duration - more frequent scanning initially
+    private let AGGRESSIVE_DISCOVERY_PHASE: TimeInterval = 30.0
+    /// Tracks when aggressive discovery phase started
+    private var aggressiveDiscoveryStarted: Date?
 
     // MARK: - Thread helpers
     @inline(__always)
@@ -387,10 +407,15 @@ public class BleManager: NSObject, TransportManager {
         pendingFragments.removeAll()
         pendingOutboundFragments.removeAll()
         lastSeenMeshAdvertisements.removeAll()
+        unknownDeviceAttempts.removeAll()
+        recentAdvertisementHashes.removeAll()
         pendingAdvertiseRestart?.cancel()
         pendingAdvertiseRestart = nil
         lastAdvertiseRestartAt = nil
         transportStartAt = nil
+        lastProactiveScanRefresh = nil
+        lastForcedBleRefresh = nil
+        aggressiveDiscoveryStarted = nil
         subscribedCentrals.removeAll()
         
         // Clean up managers
@@ -477,13 +502,27 @@ public class BleManager: NSObject, TransportManager {
             scanRestartCount = 0
         }
         
+        // Scan without service UUID filter for iOS ↔ Android interoperability
+        // iOS's scanForPeripherals(withServices:) has known issues recognizing 128-bit
+        // service UUIDs from Android advertisements. Scanning with nil allows us to see
+        // all peripherals and filter in the discovery callback instead.
         central.scanForPeripherals(
-            withServices: [SERVICE_UUID],
+            withServices: nil,
             options: [CBCentralManagerScanOptionAllowDuplicatesKey: true]
         )
         isScanning = true
-        scanStartDate = Date()
+        let now = Date()
+        scanStartDate = now
         lastDiscoveryDate = scanStartDate
+        lastProactiveScanRefresh = now
+        // Start aggressive discovery phase for initial faster connection
+        if aggressiveDiscoveryStarted == nil {
+            aggressiveDiscoveryStarted = now
+            print("[BleManager] Starting aggressive discovery phase (\(AGGRESSIVE_DISCOVERY_PHASE)s)")
+            emitDiagnostic("info", "Starting aggressive discovery phase", context: [
+                "duration": AGGRESSIVE_DISCOVERY_PHASE
+            ])
+        }
         startScanMonitor()
         if logThrottler.shouldLog(key: "scan_started") {
             let context: [String: Any] = [
@@ -512,6 +551,7 @@ public class BleManager: NSObject, TransportManager {
         scanStartDate = nil
         lastDiscoveryDate = nil
         connectionAttemptTimestamps.removeAll()
+        connectionRetryCount.removeAll()
         if logThrottler.shouldLog(key: "scan_stopped") {
             print("[BleManager] Stopped scanning (reason: \(reason))")
         }
@@ -528,12 +568,61 @@ public class BleManager: NSObject, TransportManager {
             let now = Date()
             let lastActivity = self.lastDiscoveryDate ?? self.scanStartDate ?? now
             let idleDuration = now.timeIntervalSince(lastActivity)
+            
+            // Check for inactivity-based restart
             if idleDuration >= self.SCAN_RESTART_INTERVAL {
                 if self.logThrottler.shouldLog(key: "scan_watchdog", interval: self.SCAN_RESTART_INTERVAL) {
                     print("[BleManager] Restarting scan after \(Int(idleDuration))s of inactivity")
                     self.emitDiagnostic("warning", "Restarting BLE scan due to inactivity", context: ["idle_seconds": Int(idleDuration)])
                 }
                 self.restartScanningDueToInactivity()
+                return
+            }
+            
+            // Proactive scan refresh even when discoveries are occurring
+            // This ensures we don't miss devices due to BLE stack issues
+            let lastRefresh = self.lastProactiveScanRefresh ?? self.scanStartDate ?? now
+            if now.timeIntervalSince(lastRefresh) >= self.PROACTIVE_SCAN_REFRESH_INTERVAL {
+                if self.logThrottler.shouldLog(key: "proactive_scan_refresh", interval: self.PROACTIVE_SCAN_REFRESH_INTERVAL) {
+                    print("[BleManager] Proactively refreshing BLE scan")
+                    self.emitDiagnostic("info", "Proactive scan refresh")
+                }
+                self.lastProactiveScanRefresh = now
+                self.restartScanningDueToInactivity()
+            }
+            
+            // Forced complete BLE refresh - more aggressive than proactive refresh
+            // This helps recover from edge cases where the BLE stack becomes stuck
+            let lastForced = self.lastForcedBleRefresh ?? self.transportStartAt ?? now
+            if now.timeIntervalSince(lastForced) >= self.FORCED_BLE_REFRESH_INTERVAL {
+                self.lastForcedBleRefresh = now
+                if self.logThrottler.shouldLog(key: "forced_ble_refresh", interval: self.FORCED_BLE_REFRESH_INTERVAL) {
+                    print("[BleManager] Performing forced BLE refresh for reliability")
+                    self.emitDiagnostic("info", "Forced BLE refresh for reliability", context: [
+                        "connectedPeers": self.connections.connectedPeripheralCount(),
+                        "discoveredPeers": self.discoveredPeripherals.count
+                    ])
+                }
+                // Stop and restart both scanning and advertising
+                self.stopScanning(reason: "forced_refresh")
+                self.refreshAdvertising(reason: "forced_refresh")
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
+                    self?.startScanning(reason: "forced_refresh")
+                }
+            }
+            
+            // After aggressive phase ends, do a targeted scan with service UUID filter
+            // This can help discover Android devices that might have been missed
+            if let started = self.aggressiveDiscoveryStarted,
+               now.timeIntervalSince(started) >= self.AGGRESSIVE_DISCOVERY_PHASE,
+               now.timeIntervalSince(started) < self.AGGRESSIVE_DISCOVERY_PHASE + self.SCAN_HEARTBEAT_INTERVAL {
+                print("[BleManager] Aggressive phase ended, performing targeted service scan")
+                self.emitDiagnostic("info", "Aggressive phase ended, performing targeted service scan", context: [
+                    "discoveredPeers": self.discoveredPeripherals.count,
+                    "connectedPeers": self.connections.connectedPeripheralCount()
+                ])
+                // Brief targeted scan with service UUID
+                self.performTargetedServiceScan()
             }
         }
         timer.resume()
@@ -558,6 +647,33 @@ public class BleManager: NSObject, TransportManager {
         }
     }
     
+    /// Performs a brief targeted scan with service UUID filter.
+    /// This helps discover Android devices that might not advertise our service UUID
+    /// in the main advertisement packet but include it in scan response.
+    private func performTargetedServiceScan() {
+        guard let central = centralManager, central.state == .poweredOn else { return }
+        guard isScanning else { return }
+        
+        // Brief stop and restart with service filter
+        central.stopScan()
+        
+        // Scan with service UUID filter for 5 seconds
+        central.scanForPeripherals(
+            withServices: [SERVICE_UUID],
+            options: [CBCentralManagerScanOptionAllowDuplicatesKey: true]
+        )
+        
+        // After 5 seconds, go back to filterless scanning
+        DispatchQueue.main.asyncAfter(deadline: .now() + 5.0) { [weak self] in
+            guard let self = self, self.isScanning else { return }
+            self.centralManager?.stopScan()
+            self.centralManager?.scanForPeripherals(
+                withServices: nil,
+                options: [CBCentralManagerScanOptionAllowDuplicatesKey: true]
+            )
+        }
+    }
+    
     private func evaluateCentralHealthAfterRestart() {
         guard scanRestartCount >= MAX_CONSECUTIVE_SCAN_RESTARTS else { return }
         let now = Date()
@@ -617,13 +733,22 @@ public class BleManager: NSObject, TransportManager {
     private func attemptConnection(to peripheral: CBPeripheral, reason: String, rssi: Int16? = nil, desiredRole: MeshController.MeshRole? = nil) {
         DispatchQueue.main.async { [weak self] in
             guard let self = self else { return }
+            
+            // Atomic check-and-connect: all checks must pass before proceeding
+            // This prevents race conditions when multiple discovery callbacks try to connect
+            
+            // 1. Already connected check
             if self.connections.connectedPeripheral(for: peripheral.identifier) != nil {
                 return
             }
+            
+            // 2. Recent attempt cooldown check
             let now = Date()
             if let lastAttempt = self.connectionAttemptTimestamps[peripheral.identifier], now.timeIntervalSince(lastAttempt) < self.MIN_RECONNECT_INTERVAL {
                 return
             }
+            
+            // 3. RSSI threshold check
             if let effectiveRSSI = rssi ?? self.peripheralRSSI[peripheral.identifier], effectiveRSSI < self.MINIMUM_RSSI_TO_CONNECT {
                 if self.logThrottler.shouldLog(key: "rssi_skip_\(peripheral.identifier.uuidString)", interval: 10) {
                     self.emitDiagnostic("debug", "Skipping BLE connect due to weak RSSI", context: [
@@ -634,12 +759,24 @@ public class BleManager: NSObject, TransportManager {
                 }
                 return
             }
+            
+            // 4. Connection capacity check (atomic with the connect call)
             if self.currentConnectionCount() >= self.MAX_CONNECTIONS_PER_DEVICE {
                 if self.logThrottler.shouldLog(key: "mesh_conn_cap_ios", interval: 10) {
                     print("[BleManager] Connection cap reached, not connecting to \(peripheral.identifier)")
                 }
                 return
             }
+            
+            // 5. Double-check peripheral state before connecting
+            guard peripheral.state != .connecting else {
+                if self.logThrottler.shouldLog(key: "already_connecting_\(peripheral.identifier.uuidString)", interval: 5) {
+                    print("[BleManager] Already connecting to \(peripheral.identifier)")
+                }
+                return
+            }
+            
+            // All checks passed - proceed with connection
             self.connectionAttemptTimestamps[peripheral.identifier] = now
             if let desiredRole = desiredRole {
                 self.connections.setPendingRole(desiredRole, for: peripheral.identifier)
@@ -647,6 +784,7 @@ public class BleManager: NSObject, TransportManager {
                 self.connections.setPendingRole(.member, for: peripheral.identifier)
             }
             peripheral.delegate = self
+            
             if peripheral.state == .connected {
                 self.connections.registerPeripheral(peripheral)
                 if let service = peripheral.services?.first(where: { $0.uuid == self.SERVICE_UUID }) {
@@ -656,6 +794,7 @@ public class BleManager: NSObject, TransportManager {
                 }
                 return
             }
+            
             self.centralManager?.connect(peripheral, options: nil)
             if self.logThrottler.shouldLog(key: "connect_attempt_\(peripheral.identifier.uuidString)", interval: 10) {
                 print("[BleManager] Attempting connection to \(peripheral.identifier) (reason: \(reason))")
@@ -1026,6 +1165,7 @@ public class BleManager: NSObject, TransportManager {
         pendingFragments.removeValue(forKey: identifier)
         pendingOutboundFragments.removeValue(forKey: deviceId)
         connectionAttemptTimestamps.removeValue(forKey: identifier)
+        connectionRetryCount.removeValue(forKey: identifier)
         meshController.registerDisconnection(peerId: deviceId)
         refreshSelfMetrics()
         
@@ -1216,6 +1356,9 @@ public class BleManager: NSObject, TransportManager {
 
     private func pruneMeshObservations(now: Date = Date()) {
         lastSeenMeshAdvertisements = lastSeenMeshAdvertisements.filter { now.timeIntervalSince($0.value.timestamp) <= MESH_OBSERVATION_TTL }
+        
+        // Also clean up stale unknown device rate limiting entries
+        unknownDeviceAttempts = unknownDeviceAttempts.filter { now.timeIntervalSince($0.value) <= UNKNOWN_DEVICE_RATE_LIMIT * 3 }
     }
     
     // MARK: - Adaptive Scan Methods
@@ -1248,6 +1391,13 @@ public class BleManager: NSObject, TransportManager {
     /// Checks if we should skip this peripheral based on RSSI filtering.
     /// Returns true if the signal is too weak and we're in a dense environment.
     private func shouldFilterByRssi(_ rssi: Int16) -> Bool {
+        // During aggressive discovery phase, don't apply density-based filtering
+        if let started = aggressiveDiscoveryStarted,
+           Date().timeIntervalSince(started) < AGGRESSIVE_DISCOVERY_PHASE {
+            // Only filter out extremely weak signals during aggressive phase
+            return rssi < MINIMUM_RSSI_TO_CONNECT
+        }
+        
         // In dense networks, apply stricter RSSI filtering
         let threshold: Int16
         if estimatedVisiblePeerCount > ADAPTIVE_HIGH_DENSITY_THRESHOLD {
@@ -1266,19 +1416,34 @@ public class BleManager: NSObject, TransportManager {
     /// Checks if we should throttle connection attempts based on rate limits.
     /// Returns true if we should skip this connection attempt.
     private func shouldThrottleConnection(to peripheral: UUID, now: Date) -> Bool {
+        // During aggressive discovery phase, use much shorter cooldowns
+        let isAggressivePhase = aggressiveDiscoveryStarted.map { now.timeIntervalSince($0) < AGGRESSIVE_DISCOVERY_PHASE } ?? false
+        
         // Prune old entries
         let oneMinuteAgo = now.addingTimeInterval(-60.0)
         globalConnectionAttempts = globalConnectionAttempts.filter { $0 > oneMinuteAgo }
+        
+        let effectiveCooldown: TimeInterval = isAggressivePhase ? 5.0 : ADAPTIVE_COOLDOWN_PER_PERIPHERAL
         peripheralConnectionAttempts = peripheralConnectionAttempts.filter { 
-            now.timeIntervalSince($0.value) < ADAPTIVE_COOLDOWN_PER_PERIPHERAL 
+            now.timeIntervalSince($0.value) < effectiveCooldown 
         }
         
         // Check per-peripheral cooldown
         if let lastAttempt = peripheralConnectionAttempts[peripheral],
-           now.timeIntervalSince(lastAttempt) < ADAPTIVE_COOLDOWN_PER_PERIPHERAL {
+           now.timeIntervalSince(lastAttempt) < effectiveCooldown {
             return true
         }
         
+        // During aggressive phase, allow more connection attempts
+        if isAggressivePhase {
+            // Allow up to 3x the normal rate during aggressive phase
+            let maxAttempts = ADAPTIVE_MAX_CONNECTIONS_PER_MINUTE * 3
+            if globalConnectionAttempts.count >= maxAttempts {
+                return true
+            }
+            return false
+        }
+        
         // In dense networks, apply global rate limiting
         if estimatedVisiblePeerCount > ADAPTIVE_LOW_DENSITY_THRESHOLD {
             let maxAttempts = ADAPTIVE_MAX_CONNECTIONS_PER_MINUTE
@@ -1319,6 +1484,124 @@ public class BleManager: NSObject, TransportManager {
         
         return normalizedHash < skipProbability
     }
+    
+    // MARK: - Smart Filtering for iOS ↔ Android Interoperability
+    
+    /// Determines if a discovered peripheral should be processed.
+    /// This implements smart filtering since we scan without a service UUID filter
+    /// (required for iOS ↔ Android interoperability).
+    ///
+    /// Accepts:
+    /// - Devices advertising our service UUID (iOS devices)
+    /// - Devices with our service data
+    /// - Previously discovered mesh devices
+    /// - Unknown connectable devices (rate-limited, verified via GATT)
+    private func shouldProcessDiscoveredPeripheral(
+        peripheral: CBPeripheral,
+        advertisementData: [String: Any],
+        rssi: Int16,
+        now: Date
+    ) -> Bool {
+        // 1. Check if device is advertising our service UUID
+        if let serviceUUIDs = advertisementData[CBAdvertisementDataServiceUUIDsKey] as? [CBUUID] {
+            if serviceUUIDs.contains(SERVICE_UUID) {
+                return true
+            }
+        }
+        
+        // 2. Check for our service data (may come from scan response)
+        if let serviceData = advertisementData[CBAdvertisementDataServiceDataKey] as? [CBUUID: Data] {
+            if serviceData[SERVICE_UUID] != nil {
+                return true
+            }
+        }
+        
+        // 2b. Check overflow service UUIDs - Android devices sometimes advertise in overflow area
+        //     when the main advertisement packet is full
+        if let overflowUUIDs = advertisementData[CBAdvertisementDataOverflowServiceUUIDsKey] as? [CBUUID] {
+            if overflowUUIDs.contains(SERVICE_UUID) {
+                return true
+            }
+        }
+        
+        // 2c. Check solicited service UUIDs - some Android devices use this
+        if let solicitedUUIDs = advertisementData[CBAdvertisementDataSolicitedServiceUUIDsKey] as? [CBUUID] {
+            if solicitedUUIDs.contains(SERVICE_UUID) {
+                return true
+            }
+        }
+        
+        // 3. Check if this is a previously discovered mesh device
+        if lastSeenMeshAdvertisements[peripheral.identifier] != nil {
+            return true
+        }
+        
+        // 4. Check if we already have this peripheral in our discovered list
+        //    (previously connected or successfully verified via GATT)
+        if discoveredPeripherals[peripheral.identifier] != nil {
+            return true
+        }
+        
+        // 5. Check if we already have a device ID mapping for this peripheral
+        if connections.peripheralDeviceId(for: peripheral.identifier) != nil ||
+           connections.centralDeviceId(for: peripheral.identifier) != nil {
+            return true
+        }
+        
+        // 6. For unknown connectable devices, allow with rate limiting
+        //    These will be verified via GATT service discovery after connection
+        //    This is CRITICAL for iOS ↔ Android cross-platform discovery since
+        //    each platform may not recognize the other's service UUID format in advertisements
+        let isConnectable: Bool
+        if #available(iOS 13.0, *) {
+            isConnectable = (advertisementData[CBAdvertisementDataIsConnectable] as? NSNumber)?.boolValue ?? false
+        } else {
+            isConnectable = true
+        }
+        
+        if isConnectable {
+            // Rate limit unknown device connection attempts
+            if let lastAttempt = unknownDeviceAttempts[peripheral.identifier],
+               now.timeIntervalSince(lastAttempt) < UNKNOWN_DEVICE_RATE_LIMIT {
+                return false
+            }
+            
+            // Check global rate limit for unknown device attempts
+            let oneMinuteAgo = now.addingTimeInterval(-60.0)
+            let recentUnknownAttempts = unknownDeviceAttempts.values.filter { $0 > oneMinuteAgo }.count
+            if recentUnknownAttempts >= MAX_UNKNOWN_DEVICE_ATTEMPTS_PER_MINUTE {
+                return false
+            }
+            
+            // Use a tiered approach: stronger signals get priority
+            let shouldAttempt: Bool
+            if rssi >= -70 {
+                // Strong signal - always try
+                shouldAttempt = true
+            } else if rssi >= UNKNOWN_DEVICE_MIN_RSSI && recentUnknownAttempts < MAX_UNKNOWN_DEVICE_ATTEMPTS_PER_MINUTE / 2 {
+                // Moderate signal and we have budget
+                shouldAttempt = true
+            } else {
+                shouldAttempt = false
+            }
+            
+            if shouldAttempt {
+                unknownDeviceAttempts[peripheral.identifier] = now
+                if logThrottler.shouldLog(key: "unknown_connectable_\(peripheral.identifier.uuidString)", interval: 30) {
+                    print("[BleManager] Allowing unknown connectable device for GATT verification: \(peripheral.identifier) RSSI=\(rssi)")
+                    emitDiagnostic("debug", "Allowing unknown device for GATT verification", context: [
+                        "identifier": peripheral.identifier.uuidString,
+                        "rssi": rssi,
+                        "recentAttempts": recentUnknownAttempts
+                    ])
+                }
+                return true
+            }
+        }
+        
+        // Filter out all other devices (not our mesh network)
+        return false
+    }
 
     private func identifierForNodeHash(_ nodeHash: UInt64) -> UUID? {
         for (identifier, observation) in lastSeenMeshAdvertisements where observation.advertisement.nodeIdHash == nodeHash {
@@ -1326,6 +1609,32 @@ public class BleManager: NSObject, TransportManager {
         }
         return nil
     }
+    
+    /// Computes a hash of the advertisement data for duplicate detection.
+    /// Uses peripheral ID, RSSI bucket, and key advertisement data.
+    private func computeAdvertisementHash(peripheral: CBPeripheral, advertisementData: [String: Any], rssi: Int16) -> Int {
+        var hasher = Hasher()
+        hasher.combine(peripheral.identifier)
+        // Use RSSI buckets of 5 dBm to avoid hash changes from minor signal fluctuations
+        hasher.combine(rssi / 5)
+        
+        // Include service UUIDs if present
+        if let serviceUUIDs = advertisementData[CBAdvertisementDataServiceUUIDsKey] as? [CBUUID] {
+            for uuid in serviceUUIDs {
+                hasher.combine(uuid.uuidString)
+            }
+        }
+        
+        // Include service data if present
+        if let serviceData = advertisementData[CBAdvertisementDataServiceDataKey] as? [CBUUID: Data] {
+            for (uuid, data) in serviceData {
+                hasher.combine(uuid.uuidString)
+                hasher.combine(data)
+            }
+        }
+        
+        return hasher.finalize()
+    }
 
     private func maybeHandleRebalance(reason: String) {
         pruneMeshObservations()
@@ -1499,6 +1808,37 @@ extension BleManager: CBCentralManagerDelegate {
         // Adaptive scanning: track discoveries for density estimation
         recordDiscoveryForDensity(now: now)
         
+        // Duplicate advertisement detection - avoid processing identical advertisements
+        // This improves performance in dense networks where the same device may be seen many times
+        let advertHash = computeAdvertisementHash(peripheral: peripheral, advertisementData: advertisementData, rssi: rssiValue)
+        if let cached = recentAdvertisementHashes[peripheral.identifier] {
+            // If we've seen this exact advertisement recently, skip processing
+            if cached.hash == advertHash && now.timeIntervalSince(cached.timestamp) < 1.0 {
+                return
+            }
+        }
+        recentAdvertisementHashes[peripheral.identifier] = (hash: advertHash, timestamp: now)
+        
+        // Prune old advertisement cache entries periodically
+        if recentAdvertisementHashes.count > 100 {
+            let cutoff = now.addingTimeInterval(-30.0)
+            recentAdvertisementHashes = recentAdvertisementHashes.filter { $0.value.timestamp > cutoff }
+        }
+        
+        // Smart filtering for iOS ↔ Android interoperability
+        // Since we scan without a service UUID filter (for Android compatibility),
+        // we need to filter discovered peripherals here instead.
+        let shouldProcess = shouldProcessDiscoveredPeripheral(
+            peripheral: peripheral,
+            advertisementData: advertisementData,
+            rssi: rssiValue,
+            now: now
+        )
+        
+        if !shouldProcess {
+            return
+        }
+        
         // Adaptive scanning: early RSSI filtering in dense networks
         if shouldFilterByRssi(rssiValue) {
             if logThrottler.shouldLog(key: "adaptive_rssi_filter", interval: 10) {
@@ -1562,11 +1902,25 @@ extension BleManager: CBCentralManagerDelegate {
         }
         
         // Adaptive scanning: rate limit connection attempts
-        if shouldThrottleConnection(to: peripheral.identifier, now: now) {
-            if logThrottler.shouldLog(key: "adaptive_throttle_\(peripheral.identifier.uuidString)", interval: 30) {
-                print("[BleManager] Adaptive: throttling connection to \(peripheral.identifier)")
+        // Skip throttling for first-time discoveries with strong signals for faster connection
+        let notSeenBefore = lastSeenMeshAdvertisements[peripheral.identifier] == nil
+        let notConnected = connections.connectedPeripheral(for: peripheral.identifier) == nil
+        let isFirstDiscovery = notSeenBefore && notConnected
+        let hasStrongSignal = rssiValue >= -70
+        
+        if !isFirstDiscovery || !hasStrongSignal {
+            if shouldThrottleConnection(to: peripheral.identifier, now: now) {
+                if logThrottler.shouldLog(key: "adaptive_throttle_\(peripheral.identifier.uuidString)", interval: 30) {
+                    print("[BleManager] Adaptive: throttling connection to \(peripheral.identifier)")
+                }
+                return
             }
-            return
+        } else if isFirstDiscovery && hasStrongSignal {
+            print("[BleManager] Fast-tracking first discovery with strong signal: \(peripheral.identifier) RSSI=\(rssiValue)")
+            emitDiagnostic("info", "Fast-tracking first discovery", context: [
+                "identifier": peripheral.identifier.uuidString,
+                "rssi": rssiValue
+            ])
         }
 
         let desiredRole: MeshController.MeshRole = (decision.intent == .interCluster) ? .bridge : .member
@@ -1603,6 +1957,7 @@ extension BleManager: CBCentralManagerDelegate {
         
         connections.registerPeripheral(peripheral)
         connectionAttemptTimestamps.removeValue(forKey: peripheral.identifier)
+        connectionRetryCount.removeValue(forKey: peripheral.identifier) // Reset retry count on successful connection
         
         // Discover services
         peripheral.discoverServices([SERVICE_UUID])
@@ -1610,14 +1965,36 @@ extension BleManager: CBCentralManagerDelegate {
     
     public func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {
         print("[BleManager] Failed to connect to peripheral: \(error?.localizedDescription ?? "unknown")")
+        
+        // Increment retry count and calculate backoff
+        let retryCount = (connectionRetryCount[peripheral.identifier] ?? 0) + 1
+        connectionRetryCount[peripheral.identifier] = retryCount
+        
         emitDiagnostic("error", "Failed to connect to BLE peripheral", context: [
             "identifier": peripheral.identifier.uuidString,
-            "error": error?.localizedDescription ?? "unknown"
+            "error": error?.localizedDescription ?? "unknown",
+            "retryCount": retryCount
         ])
         connectionAttemptTimestamps.removeValue(forKey: peripheral.identifier)
         _ = connections.consumePendingRole(for: peripheral.identifier)
-        DispatchQueue.main.asyncAfter(deadline: .now() + MIN_RECONNECT_INTERVAL) { [weak self] in
-            self?.attemptConnection(to: peripheral, reason: "retry_fail")
+        
+        // Give up after max retries
+        guard retryCount <= MAX_CONNECTION_RETRIES else {
+            print("[BleManager] Max retries (\(MAX_CONNECTION_RETRIES)) exceeded for \(peripheral.identifier), giving up")
+            emitDiagnostic("warning", "Max connection retries exceeded", context: [
+                "identifier": peripheral.identifier.uuidString,
+                "retryCount": retryCount
+            ])
+            connectionRetryCount.removeValue(forKey: peripheral.identifier)
+            return
+        }
+        
+        // Exponential backoff: 5s, 10s, 20s, 40s, 60s (capped)
+        let backoffInterval = min(MAX_RECONNECT_INTERVAL, MIN_RECONNECT_INTERVAL * pow(2.0, Double(retryCount - 1)))
+        
+        DispatchQueue.main.asyncAfter(deadline: .now() + backoffInterval) { [weak self] in
+            guard let self = self, self.state == .running else { return }
+            self.attemptConnection(to: peripheral, reason: "retry_fail")
         }
     }
     
@@ -1668,8 +2045,34 @@ extension BleManager: CBCentralManagerDelegate {
                 }
             }
             
-            // Attempt reconnection after a short delay
-            DispatchQueue.main.asyncAfter(deadline: .now() + MIN_RECONNECT_INTERVAL) { [weak self] in
+            // Attempt reconnection with exponential backoff
+            let retryCount = (connectionRetryCount[peripheral.identifier] ?? 0) + 1
+            connectionRetryCount[peripheral.identifier] = retryCount
+            
+            // Give up after max retries
+            guard retryCount <= MAX_CONNECTION_RETRIES else {
+                print("[BleManager] Max retries (\(MAX_CONNECTION_RETRIES)) exceeded for \(peripheral.identifier) on disconnect, giving up")
+                connectionRetryCount.removeValue(forKey: peripheral.identifier)
+                // Notify peer lost since we're giving up
+                if let deviceId = connections.peripheralDeviceId(for: peripheral.identifier) {
+                    protocolInstance.removeNeighborRoutes(neighborId: deviceId)
+                    try? self.protocolInstance.blePeerLost(peerId: deviceId)
+                    meshController.registerDisconnection(peerId: deviceId)
+                    refreshSelfMetrics()
+                    connections.removeConnectionRole(for: deviceId)
+                    connections.removePeripheralDeviceId(for: peripheral.identifier)
+                    connections.removeCentralDeviceId(for: peripheral.identifier)
+                    DispatchQueue.main.async {
+                        self.refreshAdvertising(reason: "disconnect_max_retries")
+                    }
+                    maybeHandleRebalance(reason: "disconnect_max_retries")
+                }
+                return
+            }
+            
+            let backoffInterval = min(MAX_RECONNECT_INTERVAL, MIN_RECONNECT_INTERVAL * pow(2.0, Double(retryCount - 1)))
+            
+            DispatchQueue.main.asyncAfter(deadline: .now() + backoffInterval) { [weak self] in
                 guard let self = self else { return }
                 if self.state == .running && self.discoveredPeripherals[peripheral.identifier] != nil {
                     self.attemptConnection(to: peripheral, reason: "retry_disconnect")
@@ -2011,6 +2414,14 @@ extension BleManager: CBPeripheralManagerDelegate {
             ])
             return
         }
+        
+        // Track this central as subscribed for connection count
+        subscribedCentrals.insert(central.identifier)
+        print("[BleManager] Central subscribed: \(central.identifier)")
+        emitDiagnostic("info", "Central subscribed to characteristic", context: [
+            "central": central.identifier.uuidString,
+            "totalSubscribed": subscribedCentrals.count
+        ])
 
         if connections.centralDeviceId(for: central.identifier) == nil && connections.peripheralDeviceId(for: central.identifier) == nil {
             ensureDeviceId(for: central.identifier)
@@ -2024,9 +2435,11 @@ extension BleManager: CBPeripheralManagerDelegate {
     
     public func peripheralManager(_ peripheral: CBPeripheralManager, central: CBCentral, didUnsubscribeFrom characteristic: CBCharacteristic) {
         print("[BleManager] Central unsubscribed from characteristic: \(characteristic.uuid)")
+        subscribedCentrals.remove(central.identifier)
         emitDiagnostic("info", "Central unsubscribed", context: [
             "central": central.identifier.uuidString,
-            "characteristic": characteristic.uuid.uuidString
+            "characteristic": characteristic.uuid.uuidString,
+            "remainingSubscribed": subscribedCentrals.count
         ])
         connections.removeCentralDeviceId(for: central.identifier)
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@offline-protocol/mesh-sdk",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Offline-first mesh networking SDK with intelligent transport switching for React Native",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",