@offline-protocol/mesh-sdk 0.2.2 → 0.2.3

package/ios/BleManager.swift

@@ -152,10 +152,16 @@ 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
@@ -163,7 +169,18 @@ public class BleManager: NSObject, TransportManager {
     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 = 10.0
+    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)
@@ -391,10 +408,14 @@ public class BleManager: NSObject, TransportManager {
         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
@@ -490,8 +511,18 @@ public class BleManager: NSObject, TransportManager {
             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] = [
@@ -520,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))")
         }
@@ -536,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()
@@ -566,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()
@@ -625,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: [
@@ -642,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)
@@ -655,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 }) {
@@ -664,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))")
@@ -1034,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()
         
@@ -1259,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 {
@@ -1277,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
@@ -1362,6 +1516,21 @@ public class BleManager: NSObject, TransportManager {
             }
         }
         
+        // 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
@@ -1381,6 +1550,8 @@ public class BleManager: NSObject, TransportManager {
         
         // 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
@@ -1395,14 +1566,33 @@ public class BleManager: NSObject, TransportManager {
                 return false
             }
             
-            // Only process strong signals for unknown devices
-            if rssi >= -75 {
+            // 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
+                        "rssi": rssi,
+                        "recentAttempts": recentUnknownAttempts
                     ])
                 }
                 return true
@@ -1419,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()
@@ -1592,6 +1808,23 @@ 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.
@@ -1669,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
@@ -1710,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])
@@ -1717,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")
         }
     }
     
@@ -1775,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")
@@ -2118,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)
@@ -2131,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.2",
+  "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",