@mentra/bluetooth-sdk 3.3.0-dev.516 → 3.3.0-dev.523

package/ios/Tests/DeviceManagerReconnectTests.swift

@@ -0,0 +1,362 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+@MainActor
+final class DeviceManagerReconnectTests: XCTestCase {
+    private let requests = ["should_send_lc3", "should_send_pcm", "should_send_transcript", "local_stt_fallback_active"]
+
+    func testDelayedReconnectReplayPreservesNimoDepthEndpoints() {
+        for depth in [0, 10] {
+            withRecordingDevice { manager, store in
+                let device = manager.sgc as! ReconnectRecordingDevice
+                device.type = DeviceTypes.NIMO
+                store.set("bluetooth", "dashboard_height", 7)
+                store.set("bluetooth", "dashboard_depth", depth)
+                let replayed = expectation(description: "Delayed NIMO depth \(depth)")
+                replayed.assertForOverFulfill = false
+                device.onPosition = { replayed.fulfill() }
+                manager.handleDeviceReady()
+                XCTAssertTrue(device.positions.isEmpty)
+                wait(for: [replayed], timeout: 3)
+                XCTAssertEqual(device.positions.last?.0, 7)
+                XCTAssertEqual(device.positions.last?.1, depth)
+            }
+        }
+    }
+
+    private func withRecordingDevice(_ body: (DeviceManager, DeviceStore) -> Void) {
+        let manager = DeviceManager.shared
+        let store = DeviceStore.shared
+        let saved = ["bluetooth", "glasses"].map { ($0, store.store.getCategory($0)) }
+        let previousDevice = manager.sgc
+        let previousController = manager.controller
+        let previousClock = manager.micWatchdogNow
+        manager.micWatchdogNow = { 0 }
+        defer {
+            store.set("bluetooth", "micEnabled", false)
+            manager.updateMicState()
+            manager.micWatchdogNow = previousClock
+            manager.sgc = previousDevice
+            manager.controller = previousController
+            for (category, values) in saved {
+                for key in store.store.getCategory(category).keys where values[key] == nil {
+                    store.store.remove(category, key)
+                }
+                for (key, value) in values {
+                    store.set(category, key, value)
+                }
+            }
+        }
+        manager.controller = nil
+        manager.sgc = ReconnectRecordingDevice()
+        for key in requests {
+            store.set("bluetooth", key, false)
+        }
+        store.set("bluetooth", "micEnabled", false)
+        store.set("bluetooth", "micRanking", [MicTypes.GLASSES_CUSTOM])
+        store.set("glasses", "micEnabled", false)
+        store.set("glasses", "fullyBooted", false)
+        body(manager, store)
+    }
+
+    func testReconnectRestoresUnchangedAudioRequests() {
+        for request in requests {
+            withRecordingDevice { manager, store in
+                store.apply("bluetooth", request, true)
+                XCTAssertEqual(store.get("bluetooth", "micEnabled") as? Bool, true)
+                XCTAssertEqual(store.get("glasses", "micEnabled") as? Bool, true)
+                for _ in 0 ..< 3 {
+                    manager.disconnect()
+                    XCTAssertEqual(store.get("bluetooth", request) as? Bool, true)
+                    XCTAssertEqual(store.get("bluetooth", "micEnabled") as? Bool, false)
+                    XCTAssertEqual(store.get("glasses", "micEnabled") as? Bool, false)
+                    let reconnected = ReconnectRecordingDevice()
+                    manager.sgc = reconnected
+
+                    // Replaying the same consumer request is deduplicated. No test
+                    // reset of glasses.micEnabled: production teardown must clear it.
+                    store.apply("bluetooth", request, true)
+                    XCTAssertEqual(store.get("bluetooth", "micEnabled") as? Bool, false)
+                    store.apply("glasses", "fullyBooted", true)
+
+                    XCTAssertEqual(store.get("bluetooth", "micEnabled") as? Bool, true, request)
+                    XCTAssertEqual(reconnected.micChanges, [true], request)
+                    XCTAssertEqual(store.get("bluetooth", "currentMic") as? String, MicTypes.GLASSES_CUSTOM, request)
+                }
+            }
+        }
+    }
+
+    func testLinkDisconnectRetainsIntentForTheSameCommunicator() {
+        withRecordingDevice { manager, store in
+            store.apply("glasses", "fullyBooted", true)
+            store.apply("bluetooth", "should_send_lc3", true)
+            let original = manager.sgc as! ReconnectRecordingDevice
+            store.apply("glasses", "fullyBooted", false)
+            XCTAssertTrue((manager.sgc as? ReconnectRecordingDevice) === original)
+            XCTAssertEqual(store.get("bluetooth", "should_send_lc3") as? Bool, true)
+            XCTAssertEqual(store.get("glasses", "micEnabled") as? Bool, true)
+        }
+    }
+
+    func testDiscardingCommunicatorInvalidatesMicCache() {
+        withRecordingDevice { manager, store in
+            store.apply("bluetooth", "should_send_lc3", true)
+            manager.initSGC(manager.sgc!.type)
+            XCTAssertEqual(store.get("glasses", "micEnabled") as? Bool, true)
+
+            // An unsupported model exercises disposal without starting real BLE.
+            manager.initSGC("Unavailable test glasses")
+            XCTAssertNil(manager.sgc)
+            XCTAssertEqual(store.get("glasses", "micEnabled") as? Bool, false)
+            XCTAssertEqual(store.get("bluetooth", "should_send_lc3") as? Bool, true)
+        }
+    }
+
+    func testReconnectWithoutAudioRequestsLeavesMicOff() {
+        withRecordingDevice { manager, store in
+            store.set("glasses", "micEnabled", true)
+            manager.disconnect()
+            XCTAssertEqual(store.get("glasses", "micEnabled") as? Bool, false)
+            let reconnected = ReconnectRecordingDevice()
+            manager.sgc = reconnected
+            store.apply("glasses", "fullyBooted", true)
+            XCTAssertEqual(store.get("bluetooth", "micEnabled") as? Bool, false)
+            XCTAssertEqual(store.get("bluetooth", "currentMic") as? String, "")
+            XCTAssertTrue(reconnected.micChanges.isEmpty)
+        }
+    }
+
+    func testWatchdogRetriesWhenFirstPacketNeverArrivesAndLimitsRetries() {
+        withRecordingDevice { manager, store in
+            var now: TimeInterval = 0
+            manager.micWatchdogNow = { now }
+            store.apply("glasses", "fullyBooted", true)
+            store.apply("bluetooth", "should_send_pcm", true)
+            let device = manager.sgc as! ReconnectRecordingDevice
+            now = 4
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true])
+            now = 5
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true, true])
+            now = 5.1
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true, true])
+            now = 10
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true, true, true])
+        }
+    }
+
+    func testDecodedGlassesAudioKeepsWatchdogHealthyAndMissingPacketsAfterwardRetry() {
+        withRecordingDevice { manager, store in
+            var now: TimeInterval = 0
+            manager.micWatchdogNow = { now }
+            store.apply("glasses", "fullyBooted", true)
+            store.apply("bluetooth", "should_send_pcm", true)
+            let device = manager.sgc as! ReconnectRecordingDevice
+            // This is the decoded-audio entry point used by Nimo and AR99.
+            for tick in 1 ... 10 {
+                now = TimeInterval(tick * 10)
+                manager.handleGlassesPcm(Data([0, 0]))
+                manager.checkAndReinitGlassesMic()
+            }
+            XCTAssertEqual(device.micChanges, [true])
+            now = 104
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true])
+            now = 105
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true, true])
+        }
+    }
+
+    func testLc3GlassesAudioKeepsWatchdogHealthy() {
+        withRecordingDevice { manager, store in
+            var now: TimeInterval = 0
+            manager.micWatchdogNow = { now }
+            store.apply("glasses", "fullyBooted", true)
+            store.apply("bluetooth", "should_send_pcm", true)
+            let device = manager.sgc as! ReconnectRecordingDevice
+            let lc3 = manager.lc3Converter!.encode(Data(repeating: 0, count: 320), frameSize: 40) as Data
+            XCTAssertEqual(lc3.count, 40)
+            // G2 and Live deliver LC3 through this entry point, not decoded PCM.
+            for tick in 1 ... 10 {
+                now = TimeInterval(tick * 10)
+                manager.handleGlassesMicData(lc3, 40)
+                manager.checkAndReinitGlassesMic()
+            }
+            XCTAssertEqual(device.micChanges, [true])
+        }
+    }
+
+    func testPhonePcmAndEmptyGlassesPcmCannotHideAMissingGlassesStream() {
+        withRecordingDevice { manager, store in
+            var now: TimeInterval = 0
+            manager.micWatchdogNow = { now }
+            store.apply("glasses", "fullyBooted", true)
+            store.apply("bluetooth", "should_send_pcm", true)
+            let device = manager.sgc as! ReconnectRecordingDevice
+            now = 5
+            manager.handlePcm(Data([0, 0]))
+            manager.handleGlassesPcm(Data())
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true, true])
+        }
+    }
+
+    func testWatchdogRespectsSuspensionAndGivesResumeAFreshDeadline() {
+        withRecordingDevice { manager, store in
+            var now: TimeInterval = 0
+            manager.micWatchdogNow = { now }
+            store.apply("glasses", "fullyBooted", true)
+            store.apply("bluetooth", "should_send_pcm", true)
+            let device = manager.sgc as! ReconnectRecordingDevice
+            device.isMicSuspendedForAudio = true
+            now = 100
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true])
+            device.isMicSuspendedForAudio = false
+            now = 200
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true])
+            now = 205
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true, true])
+
+            store.apply("bluetooth", "should_send_pcm", false)
+            // A late firmware ACK can leave the shared cache true after demand ends.
+            store.set("glasses", "micEnabled", true)
+            now = 300
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true, true, false])
+        }
+    }
+
+    func testWatchdogRespectsOwnAppPlaybackAndPhoneRoute() {
+        withRecordingDevice { manager, store in
+            var now: TimeInterval = 0
+            manager.micWatchdogNow = { now }
+            let monitor = PhoneAudioMonitor.getInstance()
+            let wasPlaying = monitor.isOwnAppAudioPlaying()
+            defer { monitor.setOwnAppAudioPlaying(wasPlaying) }
+            monitor.setOwnAppAudioPlaying(false)
+            store.apply("glasses", "fullyBooted", true)
+            store.apply("bluetooth", "should_send_pcm", true)
+            let device = manager.sgc as! ReconnectRecordingDevice
+            monitor.setOwnAppAudioPlaying(true)
+            now = 100
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true])
+            monitor.setOwnAppAudioPlaying(false)
+            store.set("bluetooth", "currentMic", MicTypes.PHONE_INTERNAL)
+            now = 200
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true])
+        }
+    }
+
+    func testWatchdogDeadlineBelongsToTheCurrentConnection() {
+        withRecordingDevice { manager, store in
+            var now: TimeInterval = 0
+            manager.micWatchdogNow = { now }
+            store.apply("glasses", "fullyBooted", true)
+            store.apply("bluetooth", "should_send_pcm", true)
+            let device = manager.sgc as! ReconnectRecordingDevice
+            store.apply("glasses", "fullyBooted", false)
+            now = 100
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true])
+            store.apply("glasses", "fullyBooted", true)
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true])
+            now = 105
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true, true])
+        }
+    }
+}
+
+@MainActor
+private final class ReconnectRecordingDevice: SGCManager {
+    var type = "Reconnect test glasses"
+    let hasMic = true
+    let showConnectionConfirmation = false
+    var micChanges: [Bool] = []
+    var positions: [(Int, Int)] = []
+    var onPosition: (() -> Void)?
+    var isMicSuspendedForAudio = false
+
+    func clearSceneElements(_: [String]) async {}
+    func sendTextWall(_: String) async {}
+    func applySceneFrame(_: SceneFrame) async {}
+    func clearDisplay() {}
+
+    func setMicEnabled(_ enabled: Bool) {
+        micChanges.append(enabled)
+        DeviceStore.shared.set("glasses", "micEnabled", enabled)
+    }
+
+    func sortMicRanking(list: [String]) -> [String] {
+        list
+    }
+
+    func sendJson(_: [String: Any], wakeUp _: Bool, requireAck _: Bool) {}
+    func requestPhoto(_: PhotoRequest) {}
+    func startStream(_: [String: Any]) {}
+    func stopStream() {}
+    func sendStreamKeepAlive(_: [String: Any]) {}
+    func startVideoRecording(requestId _: String, save _: Bool, sound _: Bool) {}
+    func stopVideoRecording(requestId _: String) {}
+    func sendButtonPhotoSettings() {}
+    func sendButtonVideoRecordingSettings() {}
+    func sendCameraFovSetting() {}
+    func sendButtonMaxRecordingTime() {}
+    func setBrightness(_: Int, autoMode _: Bool) {}
+    func sendText(_: String) async {}
+    func sendDoubleTextWall(_: String, _: String) async {}
+    func displayBitmap(base64ImageData _: String, x _: Int32?, y _: Int32?, width _: Int32?, height _: Int32?) async -> Bool {
+        false
+    }
+
+    func showDashboard() {}
+    func setDashboardPosition(_ height: Int, _ depth: Int) {
+        positions.append((height, depth))
+        onPosition?()
+    }
+
+    func setHeadUpAngle(_: Int) {}
+    func getBatteryStatus() {}
+    func setSilentMode(_: Bool) {}
+    func exit() {}
+    func sendShutdown() {}
+    func sendReboot() {}
+    func sendRgbLedControl(requestId _: String, packageName _: String?, action _: String, color _: String?, onDurationMs _: Int, offDurationMs _: Int, count _: Int) {}
+    func disconnect() {}
+    func forget() {}
+    func findCompatibleDevices() {}
+    func stopScan() {}
+    func connectById(_: String) {}
+    func getConnectedBluetoothName() -> String? {
+        nil
+    }
+
+    func cleanup() {}
+    func ping() {}
+    func dbg1() {}
+    func dbg2() {}
+    func connectController() {}
+    func disconnectController() {}
+    func requestWifiScan(scanId _: String?) {}
+    func sendWifiCredentials(_: String, _: String) {}
+    func forgetWifiNetwork(_: String) {}
+    func sendHotspotState(_: Bool) {}
+    func sendUserEmailToGlasses(_: String) {}
+    func sendOtaStart(otaVersionUrl _: String?) {}
+    func sendOtaQueryStatus() {}
+    func queryGalleryStatus() {}
+    func sendGalleryMode() {}
+    func requestVersionInfo() {}
+    func sendIncidentId(_: String, apiBaseUrl _: String?) {}
+}

package/ios/Tests/G2ConnectionSessionTests.swift

@@ -0,0 +1,172 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class G2ConnectionSessionTests: XCTestCase {
+    func testEitherArmAloneCannotStartAuthenticationOrBecomeReady() {
+        for side in G2ConnectionSession.Side.allCases {
+            var session = G2ConnectionSession()
+            session.initialize(side)
+            XCTAssertNil(session.beginAuthentication())
+            session.authenticated(side, success: true)
+            session.completeSetup(generation: session.generation)
+            XCTAssertFalse(session.isReady)
+        }
+    }
+
+    func testReadinessWaitsForBothAuthenticationResponsesAndCompletedSetup() throws {
+        for completeSetupFirst in [false, true] {
+            var session = G2ConnectionSession()
+            session.initialize(.right)
+            session.initialize(.left)
+            let generation = try XCTUnwrap(session.beginAuthentication())
+            XCTAssertNil(session.beginAuthentication(), "Duplicate service callbacks must not restart setup")
+            if completeSetupFirst { session.completeSetup(generation: generation) }
+            session.authenticated(.left, success: true)
+            session.authenticated(.right, success: false)
+            XCTAssertFalse(session.isReady)
+            session.authenticated(.right, success: true)
+            XCTAssertEqual(session.isReady, completeSetupFirst)
+            session.completeSetup(generation: generation)
+            XCTAssertTrue(session.isReady)
+        }
+    }
+
+    func testDisconnectRetiresAuthenticationAndSuspendedSetup() throws {
+        var session = G2ConnectionSession()
+        session.initialize(.left)
+        session.initialize(.right)
+        let oldGeneration = try XCTUnwrap(session.beginAuthentication())
+        session.authenticated(.left, success: true)
+        session.reset()
+        session.authenticated(.right, success: true)
+        session.completeSetup(generation: oldGeneration)
+        XCTAssertFalse(session.isReady)
+
+        session.initialize(.left)
+        session.initialize(.right)
+        let newGeneration = try XCTUnwrap(session.beginAuthentication())
+        session.authenticated(.left, success: true)
+        session.authenticated(.right, success: true)
+        session.completeSetup(generation: oldGeneration)
+        XCTAssertFalse(session.isReady, "Old setup cannot complete the replacement attempt")
+        session.completeSetup(generation: newGeneration)
+        XCTAssertTrue(session.isReady)
+    }
+
+    func testAttemptDeadlineCoversBothPartialPairsAndIncompleteAuthentication() throws {
+        for sides: [G2ConnectionSession.Side] in [[], [.left], [.right], [.left, .right]] {
+            var session = G2ConnectionSession()
+            for side in sides {
+                session.initialize(side)
+            }
+            _ = session.beginAuthentication()
+            let attempt = session.generation
+            XCTAssertTrue(session.needsRecovery(attempt: attempt))
+            session.reset()
+            XCTAssertFalse(session.needsRecovery(attempt: attempt), "A retired deadline cannot reset a new attempt")
+        }
+        var ready = G2ConnectionSession()
+        ready.initialize(.left)
+        ready.initialize(.right)
+        let attempt = try XCTUnwrap(ready.beginAuthentication())
+        ready.authenticated(.left, success: true)
+        ready.authenticated(.right, success: true)
+        ready.completeSetup(generation: attempt)
+        XCTAssertFalse(ready.needsRecovery(attempt: attempt))
+    }
+
+    func testCachedArmsCanReconnectIndependentlyWithoutAdvertisements() {
+        let left = UUID(), right = UUID()
+        XCTAssertEqual(target(left, left: left), .left)
+        XCTAssertEqual(target(right, right: right), .right)
+        XCTAssertNil(target(UUID(), left: left, right: right))
+        XCTAssertNil(target(right, left: right, right: right), "Ambiguous cache must not bind one arm twice")
+    }
+
+    func testOnlySelectedSerialCanFillTheMissingArm() {
+        let id = UUID()
+        XCTAssertEqual(target(id, name: "Even G2_32_L_123456", serial: "S211SELECTED"), .left)
+        XCTAssertNil(target(id, name: "Even G2_32_L_123456", serial: "S211OTHER"))
+        XCTAssertNil(target(id, name: "Even G2_32_R_123456"))
+        XCTAssertNil(target(id, right: id, searchID: "NOT_SET"))
+        XCTAssertNil(target(id, right: id, searchID: ""))
+    }
+
+    private func target(
+        _ id: UUID, name: String? = nil, serial: String? = nil,
+        left: UUID? = nil, right: UUID? = nil, searchID: String = "S211SELECTED"
+    ) -> G2ConnectionSession.Side? {
+        G2ConnectionTarget.side(identifier: id, name: name, advertisedSerial: serial,
+                                searchID: searchID, leftUUID: left, rightUUID: right)
+    }
+}
+
+@MainActor
+final class G2PrematureReadinessTests: XCTestCase {
+    func testSystemExitAndTouchBeforePairInitializationDoNotPublishReady() {
+        let store = DeviceStore.shared.store
+        let connected = store.get("glasses", "connected")
+        let booted = store.get("glasses", "fullyBooted")
+        defer {
+            if let connected { store.set("glasses", "connected", connected) }
+            if let booted { store.set("glasses", "fullyBooted", booted) }
+        }
+        store.set("glasses", "connected", false)
+        store.set("glasses", "fullyBooted", false)
+        let g2 = G2()
+        // SendDeviceEvent.SysEvent { eventType: systemExit }, as observed on the right arm.
+        g2.handleTouchEvent(Data([0x1A, 0x02, 0x08, 0x07]))
+        XCTAssertEqual(store.get("glasses", "connected") as? Bool, false)
+        XCTAssertEqual(store.get("glasses", "fullyBooted") as? Bool, false)
+        g2.handleTouchEvent(Data([0x1A, 0x02, 0x08, 0x00]))
+        XCTAssertEqual(store.get("glasses", "connected") as? Bool, false)
+        XCTAssertEqual(store.get("glasses", "fullyBooted") as? Bool, false)
+    }
+}
+
+final class G2PartialConnectionTests: XCTestCase {
+    func testEitherPartialLinkStaysQuietForThreeSeconds() {
+        for leftConnected in [false, true] {
+            var progress = G2PartialConnection()
+            progress.update(leftConnected: leftConnected, rightConnected: !leftConnected, now: 10)
+            XCTAssertNil(progress.visibleMissingSide(now: 10))
+            XCTAssertNil(progress.visibleMissingSide(now: 12.999))
+            // Duplicate observations must not restart the grace period.
+            progress.update(leftConnected: leftConnected, rightConnected: !leftConnected, now: 12)
+            XCTAssertEqual(progress.visibleMissingSide(now: 13), leftConnected ? .right : .left)
+            XCTAssertEqual(progress.timeoutError, leftConnected ? "errors:g2RightArmUnavailable" : "errors:g2LeftArmUnavailable")
+        }
+    }
+
+    func testNormalSequentialPairingAndDisconnectedStateNeverShowMissingArm() {
+        var progress = G2PartialConnection()
+        progress.update(leftConnected: false, rightConnected: true, now: 10)
+        progress.update(leftConnected: true, rightConnected: true, now: 12)
+        XCTAssertNil(progress.visibleMissingSide(now: 15))
+        progress.update(leftConnected: false, rightConnected: false, now: 16)
+        XCTAssertNil(progress.visibleMissingSide(now: 20))
+        XCTAssertEqual(progress.timeoutError, "errors:g2ConnectionTimedOut")
+    }
+
+    func testPeerArrivalClearsVisibleNoticeAndNewPartialLinkGetsOwnGracePeriod() {
+        var progress = G2PartialConnection()
+        progress.update(leftConnected: true, rightConnected: false, now: 10)
+        XCTAssertEqual(progress.visibleMissingSide(now: 13), .right)
+        progress.update(leftConnected: true, rightConnected: true, now: 14)
+        XCTAssertNil(progress.visibleMissingSide(now: 14))
+        progress.update(leftConnected: false, rightConnected: true, now: 15)
+        XCTAssertNil(progress.visibleMissingSide(now: 17))
+        XCTAssertEqual(progress.visibleMissingSide(now: 18), .left)
+        progress = G2PartialConnection()
+        XCTAssertNil(progress.visibleMissingSide(now: 100))
+    }
+
+    func testStatusSnapshotAndUpdateCarryNoticeAndDisconnectClearsIt() throws {
+        let status = GlassesStatus(values: ["g2MissingArm": "left"])
+        XCTAssertEqual(status.dictionary["g2MissingArm"] as? String, "left")
+        XCTAssertEqual(GlassesStatusUpdate(values: ["g2MissingArm": "right"]).dictionary["g2MissingArm"] as? String, "right")
+        let disconnected = status.disconnected().dictionary
+        XCTAssertTrue(disconnected["g2MissingArm"] is NSNull)
+        XCTAssertNoThrow(try JSONSerialization.data(withJSONObject: disconnected))
+    }
+}

package/ios/Tests/NimoCanvasSessionTests.swift

@@ -102,11 +102,80 @@ final class NimoCanvasSessionTests: XCTestCase {
         XCTAssertEqual(frame, b)
     }
 
-    func testNativeTakeoverSuppressesReplayUntilHostOffersAgain() {
+    func testNativeTakeoverReplaysWithoutNewHostFrame() {
         let session = NimoCanvasSession(); connected(session)
-        XCTAssertTrue(session.nativeApp(1, entered: true).isEmpty)
-        XCTAssertTrue(session.readiness(true, confirmed: true).isEmpty)
-        XCTAssertEqual(sentKey(session.offer(b, scope: "new")), 1)
-        XCTAssertEqual(session.nativeApp(1, entered: true), [.reconnect("Native app transition interrupted canvas command")])
+        XCTAssertEqual(sentKey(session.nativeApp(0, entered: true)), 1)
+        XCTAssertTrue(session.nativeApp(0, entered: true).isEmpty)
+        guard case let .send(_, frame, _) = ack(session, 1).first else { return XCTFail() }
+        XCTAssertEqual(frame, a)
+        XCTAssertTrue(session.nativeApp(0xFD, entered: false).isEmpty)
+        XCTAssertEqual(sentKey(ack(session, 4)), 1)
+    }
+
+    func testTakeoverDuringUpdateReplaysIdenticalFrameAfterRelaunch() {
+        let session = NimoCanvasSession()
+        _ = session.offer(a, scope: "app:1"); _ = session.readiness(true)
+        XCTAssertEqual(sentKey(ack(session, 1)), 4)
+        XCTAssertTrue(session.nativeApp(0, entered: true).isEmpty)
+        XCTAssertEqual(sentKey(ack(session, 4)), 1)
+        guard case let .send(_, frame, _) = ack(session, 1).first else { return XCTFail("Missing replay Update") }
+        XCTAssertEqual(frame, a)
+        XCTAssertTrue(ack(session, 4).isEmpty)
+        XCTAssertTrue(session.offer(a, scope: "app:1").isEmpty)
+    }
+
+    func testStartupStockUiPreservesReconnectScene() {
+        let session = NimoCanvasSession(); connected(session)
+        session.disconnected()
+        XCTAssertTrue(session.nativeApp(0, entered: true).isEmpty)
+        XCTAssertTrue(session.activate().isEmpty)
+        XCTAssertEqual(sentKey(session.readiness(true)), 1)
+        guard case let .send(_, frame, _) = ack(session, 1).first else { return XCTFail() }
+        XCTAssertEqual(frame, a)
+    }
+
+    func testActivationEntersBlankCanvasBeforeAnyMiniapp() {
+        let session = NimoCanvasSession()
+        XCTAssertTrue(session.activate().isEmpty)
+        XCTAssertEqual(sentKey(session.readiness(true)), 1)
+        guard case let .send(_, frame, _) = ack(session, 1).first else { return XCTFail() }
+        XCTAssertEqual(frame, Data([0, 0, 1]))
+    }
+
+    func testExplicitExitStopsRestorationUntilAnotherConnection() {
+        let session = NimoCanvasSession(); connected(session)
+        XCTAssertEqual(sentKey(session.exit()), 3)
+        XCTAssertTrue(session.nativeApp(0, entered: true).isEmpty)
+        XCTAssertTrue(ack(session, 3).isEmpty)
+        XCTAssertTrue(session.nativeApp(0xFD, entered: false).isEmpty)
+        session.disconnected()
+        _ = session.activate()
+        XCTAssertEqual(sentKey(session.readiness(true)), 1)
+    }
+
+    func testSuccessfulUpdateRestoresProbeBudgetForNextRecovery() {
+        let session = NimoCanvasSession()
+        _ = session.activate(); _ = session.readiness(true)
+        for episode in 0 ..< 2 {
+            if episode > 0 { XCTAssertEqual(sentKey(session.nativeApp(0, entered: true)), 1) }
+            for _ in 0 ..< 3 {
+                _ = ack(session, 1, status: 7)
+                XCTAssertEqual(sentKey(session.retryNotReady()), 1)
+            }
+            XCTAssertEqual(sentKey(ack(session, 1)), 4)
+            XCTAssertTrue(ack(session, 4).isEmpty)
+        }
+    }
+
+    func testProbesAreBoundedAndHeartbeatCanStillRecover() {
+        let session = NimoCanvasSession()
+        _ = session.activate(); _ = session.readiness(true)
+        for _ in 0 ..< 3 {
+            _ = ack(session, 1, status: 7)
+            XCTAssertEqual(sentKey(session.retryNotReady()), 1)
+        }
+        _ = ack(session, 1, status: 7)
+        XCTAssertTrue(session.retryNotReady().isEmpty)
+        XCTAssertEqual(sentKey(session.readiness(true, confirmed: true)), 1)
     }
 }

package/ios/Tests/NimoCanvasTransportTests.swift

@@ -33,6 +33,31 @@ private final class NimoTestClock {
 final class NimoCanvasTransportTests: XCTestCase {
     private let frame = Data([0, 0, 1])
 
+    func testNotReadyProbesAreTimedBoundedAndCancelled() {
+        for stop in ["budget", "disconnect", "exit", "notReady"] {
+            let clock = NimoTestClock()
+            var keys: [Int] = []
+            let canvas = NimoCanvasCoordinator(schedule: clock.schedule, writeCapacity: { 512 }, enqueue: { frames, start, complete in
+                keys.append(Int(frames[0][9])); start(); complete(); return true
+            }, reconnect: { XCTFail($0) }, rejected: { _ in })
+            canvas.activate(); canvas.readiness(true)
+            for attempt in 0 ..< 4 {
+                canvas.response(key: 1, payload: Data([7]))
+                if stop == "disconnect" { canvas.disconnected() }
+                if stop == "exit" { canvas.exit() }
+                if stop == "notReady" { canvas.readiness(false) }
+                let before = keys.count
+                clock.advance(0.999)
+                XCTAssertEqual(keys.count, before)
+                clock.advance(0.001)
+                XCTAssertEqual(keys.count, before + (stop == "budget" && attempt < 3 ? 1 : 0))
+                if stop != "budget" { break }
+            }
+            clock.advance(60)
+            XCTAssertEqual(keys.count, stop == "budget" ? 4 : 1)
+        }
+    }
+
     func testEarlyAckOnlyAdvancesAfterFinalWriteCompletes() {
         let clock = NimoTestClock()
         var chains: [[Data]] = [], starts: [() -> Void] = [], completes: [() -> Void] = []

package/ios/Tests/NimoDeviceCommandsTests.swift

@@ -0,0 +1,16 @@
+import Foundation
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class NimoDeviceCommandsTests: XCTestCase {
+    func testSystemEnglishAndFactoryResetMatchFirmwareWireCommands() {
+        func hex(_ bytes: Data) -> String {
+            bytes.map { String(format: "%02X", $0) }.joined()
+        }
+        XCTAssertEqual(hex(NimoFrameCodec.encodeFrame(cmd: NimoProtocol.CMD_SET_PARAMETER,
+                                                      key: NimoProtocol.SET_SYSTEM_LANGUAGE, payload: Data([NimoProtocol.LANGUAGE_ENGLISH]))),
+                       "BF020500702500000324010001")
+        XCTAssertEqual(hex(NimoFrameCodec.encodeFrame(cmd: NimoProtocol.CMD_CONTROL_FACTORY,
+                                                      key: NimoProtocol.FACTORY_RECOVER, payload: Data())), "BF0204005358000008030000")
+    }
+}