@mentra/bluetooth-sdk 3.2.1-dev.314 → 3.3.0-beta.942

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/G2TextTests.swift

@@ -0,0 +1,10 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class G2TextTests: XCTestCase {
+    func testBlankRowsAreEncodedOnlyAtTheDeviceBoundary() {
+        XCTAssertEqual(G2Text.containerContent("hello\n\nworld\n"), "hello\n\u{200B}\nworld\n\u{200B}")
+        XCTAssertEqual(G2Text.containerContent(""), " ")
+        XCTAssertEqual(G2Text.containerContent("hello\nworld"), "hello\nworld")
+    }
+}

package/ios/Tests/IncidentLogDispatchTests.swift

@@ -0,0 +1,111 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+/// Keep native admission, serialization and fragment packing; replace only the radio writes.
+@MainActor
+private final class IncidentLogTransport: MentraLive {
+    var ready = true
+    var writes: [(Data, BleWriteTrace?)] = []
+
+    override var incidentLogTransportReady: Bool {
+        ready
+    }
+
+    override func queueSend(_ data: Data, id _: String, trace: BleWriteTrace?) {
+        writes.append((data, trace))
+    }
+}
+
+@MainActor
+final class IncidentLogDispatchTests: XCTestCase {
+    private let incident = "rep_01M4HBVT88DFSN8TYNZ1WTV4PB"
+    private let apiBase = "https://core.dev.us-west-2.mentraglass.com"
+
+    func testMissingNativeLinkRejectsDespiteCachedConnectedStatus() {
+        let live = MentraLive()
+        let store = DeviceStore.shared.store
+        let saved = store.getCategory("glasses")["connected"]
+        store.set("glasses", "connected", true)
+        defer {
+            if let saved { store.set("glasses", "connected", saved) }
+            else { store.remove("glasses", "connected") }
+        }
+        XCTAssertThrowsError(try live.sendIncidentId(incident, apiBaseUrl: apiBase)) { error in
+            XCTAssertEqual((error as? BluetoothSdkError)?.code, "glasses_not_connected")
+        }
+    }
+
+    func testNoDriverRejectsThroughDeviceManager() {
+        let manager = DeviceManager()
+        manager.sgc = nil
+        XCTAssertThrowsError(try manager.sendIncidentId(incident, apiBaseUrl: apiBase)) { error in
+            XCTAssertEqual((error as? BluetoothSdkError)?.code, "glasses_not_connected")
+        }
+    }
+
+    func testMissingCurrentTokenDoesNotQueueAnUpload() throws {
+        try withToken("") {
+            let live = IncidentLogTransport()
+            XCTAssertThrowsError(try live.sendIncidentId(incident, apiBaseUrl: apiBase)) { error in
+                XCTAssertEqual((error as? BluetoothSdkError)?.code, "core_token_unavailable")
+            }
+            XCTAssertTrue(live.writes.isEmpty)
+        }
+    }
+
+    func testCurrentTokenPrecedesUploadAndNeverAppearsInLogs() throws {
+        let token = "synthetic-\(UUID().uuidString)"
+        try withToken(token) {
+            let live = IncidentLogTransport()
+            let manager = DeviceManager()
+            manager.sgc = live
+            var logs: [String] = []
+            let sink = Bridge.addEventSink { event, body in
+                if event == "log", let message = body["message"] as? String { logs.append(message) }
+            }
+            defer { Bridge.removeEventSink(sink) }
+
+            try manager.sendIncidentId(incident, apiBaseUrl: apiBase)
+
+            XCTAssertEqual(live.writes.compactMap { $0.1?.commandType }, ["auth_token", "upload_incident_logs"])
+            XCTAssertTrue(live.writes.allSatisfy { $0.1?.wakeup == true })
+            let wire = live.writes.map { String(decoding: $0.0, as: UTF8.self) }.joined()
+            XCTAssertTrue(wire.contains(token), "The current token must reach the glasses")
+            XCTAssertTrue(wire.contains(incident))
+            XCTAssertFalse(logs.contains { $0.contains(token) }, "Tokens must stay out of native and incident logs")
+        }
+    }
+
+    func testAllTokenFragmentsPrecedeUpload() throws {
+        try withToken(String(repeating: "synthetic", count: 120)) {
+            let live = IncidentLogTransport()
+            try live.sendIncidentId(incident, apiBaseUrl: apiBase)
+            let types = live.writes.compactMap { $0.1?.commandType }
+            XCTAssertGreaterThan(types.filter { $0 == "auth_token" }.count, 1)
+            XCTAssertEqual(types.last, "upload_incident_logs")
+            XCTAssertTrue(types.dropLast().allSatisfy { $0 == "auth_token" })
+        }
+    }
+
+    func testCommandQueueInsertionAndSessionClearAreSynchronous() {
+        let queue = MentraLive.CommandQueue()
+        let first = MentraLive.PendingMessage(data: Data([1]), id: "auth", retries: 0)
+        let second = MentraLive.PendingMessage(data: Data([2]), id: "upload", retries: 0)
+        XCTAssertEqual(queue.enqueue(first), 1)
+        XCTAssertEqual(queue.enqueue(second), 2)
+        XCTAssertEqual(queue.dequeue()?.id, "auth")
+        queue.removeAll()
+        XCTAssertNil(queue.dequeue())
+    }
+
+    private func withToken<T>(_ value: String, body: () throws -> T) rethrows -> T {
+        let store = DeviceStore.shared.store
+        let saved = store.getCategory("bluetooth")["core_token"]
+        store.set("bluetooth", "core_token", value)
+        defer {
+            if let saved { store.set("bluetooth", "core_token", saved) }
+            else { store.remove("bluetooth", "core_token") }
+        }
+        return try body()
+    }
+}

package/ios/Tests/MentraLiveFileTransferSessionTests.swift

@@ -0,0 +1,47 @@
+import Foundation
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class MentraLiveFileTransferSessionTests: XCTestCase {
+    func testDynamicPayloadUsesTrueSizeEvenWhenDivisibleBy400() {
+        for pack in [244, 474, 800] {
+            var session = MentraLiveFileTransferSession(fileName: "photo", fileSize: 80000, flags: 2)
+            session.recalculateTotalPackets(actualPackSize: pack)
+            XCTAssertEqual(session.totalPackets, (80000 + pack - 1) / pack)
+            for index in 0 ..< session.totalPackets {
+                XCTAssertTrue(session.addPacket(index, data: Data(repeating: 7, count: min(pack, 80000 - index * pack))))
+            }
+            XCTAssertTrue(session.isComplete)
+            XCTAssertEqual(session.assembleFile()?.count, 80000)
+        }
+    }
+
+    func testLegacyInflatedSizeAndLargeUnflaggedPayloads() {
+        // Old senders inflate the header length for small packs, including
+        // the short final pack. Flag 1 only enables batched ACKs.
+        for (pack, headerSize, actualSize, packets) in [(221, 80000, 43982, 200), (400, 80000, 79777, 200), (800, 80000, 80000, 100)] {
+            var session = MentraLiveFileTransferSession(fileName: "photo", fileSize: headerSize, flags: 1)
+            session.recalculateTotalPackets(actualPackSize: pack)
+            XCTAssertEqual(session.totalPackets, packets)
+            let source = Data((0 ..< actualSize).map { UInt8($0 % 251) })
+            for index in (0 ..< packets).reversed() {
+                let start = index * pack
+                XCTAssertTrue(session.addPacket(index, data: source.subdata(in: start ..< min(start + pack, actualSize))))
+            }
+            XCTAssertTrue(session.isComplete)
+            XCTAssertEqual(session.assembleFile(), source)
+        }
+    }
+
+    func testMalformedOrDuplicatePacketsCannotCompleteFile() {
+        var session = MentraLiveFileTransferSession(fileName: "photo", fileSize: 1000, flags: 2)
+        session.recalculateTotalPackets(actualPackSize: 800)
+        XCTAssertFalse(session.addPacket(0, data: Data(count: 799)))
+        XCTAssertFalse(session.addPacket(2, data: Data(count: 200)))
+        XCTAssertTrue(session.addPacket(1, data: Data(count: 200)))
+        XCTAssertFalse(session.isComplete)
+        XCTAssertFalse(session.addPacket(1, data: Data(count: 200)))
+        XCTAssertTrue(session.addPacket(0, data: Data(count: 800)))
+        XCTAssertEqual(session.assembleFile()?.count, 1000)
+    }
+}

package/ios/Tests/MentraLiveReconnectPolicyTests.swift

@@ -0,0 +1,58 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class MentraLiveReconnectPolicyTests: XCTestCase {
+    private func decide(
+        isKilled: Bool = false,
+        pairingYieldActive: Bool = false,
+        bluetoothPoweredOn: Bool = true,
+        peripheralName: String? = "Mentra_Live_D910",
+        savedDeviceName: String? = "Mentra_Live_D910"
+    ) -> Bool {
+        MentraLiveConnectionAttemptPolicy.shouldReconnectDirectly(
+            isKilled: isKilled,
+            pairingYieldActive: pairingYieldActive,
+            bluetoothPoweredOn: bluetoothPoweredOn,
+            peripheralName: peripheralName,
+            savedDeviceName: savedDeviceName
+        )
+    }
+
+    func testRemembersLostGlassesWithPendingConnect() {
+        XCTAssertTrue(decide())
+    }
+
+    func testDoesNotReconnectAfterUserDisconnectOrKill() {
+        XCTAssertFalse(decide(isKilled: true))
+    }
+
+    func testYieldsToAnotherPhonePairing() {
+        XCTAssertFalse(decide(pairingYieldActive: true))
+    }
+
+    func testFallsBackWhenBluetoothIsOff() {
+        XCTAssertFalse(decide(bluetoothPoweredOn: false))
+    }
+
+    func testDoesNotReconnectForgottenOrDifferentGlasses() {
+        XCTAssertFalse(decide(savedDeviceName: nil))
+        XCTAssertFalse(decide(savedDeviceName: "Mentra_Live_023B"))
+        XCTAssertFalse(decide(peripheralName: nil))
+        XCTAssertFalse(decide(peripheralName: "", savedDeviceName: ""))
+    }
+
+    func testFailureThenFallbackLeavesTheStaleSettleTimerPowerless() {
+        var pending = MentraLivePendingReconnect()
+        let first = pending.arm()
+        XCTAssertTrue(pending.owns(first))
+
+        // didFailToConnect or a fallback connectToDevice clears tracking.
+        pending.clear()
+        XCTAssertFalse(pending.owns(first))
+
+        // A later re-arm does not revive the earlier attempt's timer.
+        let second = pending.arm()
+        XCTAssertFalse(pending.owns(first))
+        XCTAssertTrue(pending.owns(second))
+    }
+}

package/ios/Tests/MentraLiveSessionReadinessTests.swift

@@ -0,0 +1,163 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+@MainActor
+private final class SessionReadinessTransport: MentraLive {
+    var commands: [[String: Any]] = []
+
+    override func sendJson(_ jsonOriginal: [String: Any], wakeUp: Bool, requireAck: Bool) {
+        commands.append(jsonOriginal)
+    }
+}
+
+@MainActor
+final class MentraLiveSessionReadinessTests: XCTestCase {
+    func testChangedSessionPublishesPendingReadinessBeforeItsBuildAndRecoversAtGlassesReady() throws {
+        let store = DeviceStore.shared.store
+        let saved = ["bluetooth", "glasses"].map { ($0, store.getCategory($0)) }
+        let previous = DeviceManager.shared.sgc
+        let transport = SessionReadinessTransport()
+        let sdk = MentraBluetoothSDK()
+        DeviceManager.shared.sgc = transport
+        var observations: [(key: String, ready: Bool, connected: Bool)] = []
+        let listener = store.addListener { category, changed in
+            guard category == "glasses" else { return }
+            for key in changed.keys where key == "fullyBooted" || key == "buildNumber" {
+                observations.append((key, sdk.glassesStatus.fullyBooted, sdk.glassesStatus.connected))
+            }
+        }
+        var sessionEvents: [Bool] = []
+        let sink = Bridge.addEventSink { event, body in
+            if event == "glasses_session_changed" {
+                sessionEvents.append(sdk.glassesStatus.fullyBooted)
+            }
+        }
+        defer {
+            store.removeListener(listener)
+            Bridge.removeEventSink(sink)
+            sdk.invalidate()
+            transport.cleanup()
+            DeviceManager.shared.sgc = previous
+            for (category, values) in saved {
+                for key in store.getCategory(category).keys where values[key] == nil {
+                    store.remove(category, key)
+                }
+                for (key, value) in values { store.set(category, key, value) }
+            }
+        }
+
+        func receive(_ value: [String: Any]) throws {
+            try transport.processReceivedData(JSONSerialization.data(withJSONObject: value))
+        }
+        try receive(["type": "glasses_ready", "sid": "original"])
+        observations.removeAll()
+        transport.commands.removeAll()
+
+        // The physical BLE link remains live across APK replacement. Its first
+        // version chunk can prove the target build before remote wire readiness.
+        try receive(["type": "version_info_1", "sid": "replacement", "build_number": "302010070"])
+        XCTAssertEqual(observations.map(\.key), ["fullyBooted", "buildNumber"])
+        XCTAssertTrue(observations.allSatisfy { !$0.ready && $0.connected })
+        XCTAssertEqual(sessionEvents, [false])
+        XCTAssertEqual(transport.commands.compactMap { $0["type"] as? String }, ["phone_ready"])
+
+        // Another chunk from the same pending process must not restart readiness.
+        try receive(["type": "version_info_3", "sid": "replacement"])
+        XCTAssertEqual(sessionEvents, [false])
+        XCTAssertFalse(sdk.glassesStatus.fullyBooted)
+
+        try receive(["type": "glasses_ready", "sid": "replacement"])
+        XCTAssertTrue(sdk.glassesStatus.connected)
+        XCTAssertTrue(sdk.glassesStatus.fullyBooted)
+        XCTAssertEqual(observations.last?.key, "fullyBooted")
+        XCTAssertEqual(observations.last?.ready, true)
+        XCTAssertEqual(transport.commands.filter { $0["type"] as? String == "request_version" }.count, 1)
+
+        observations.removeAll()
+        try receive(["type": "version_info_1", "sid": "replacement", "build_number": "302010070"])
+        XCTAssertTrue(sdk.glassesStatus.fullyBooted)
+        XCTAssertFalse(observations.contains { $0.key == "fullyBooted" })
+        XCTAssertEqual(sessionEvents, [false])
+
+        // A physical teardown before the next logical restart becomes ready must
+        // still run disconnect cleanup, even though readiness is already false.
+        try receive(["type": "version_info_1", "sid": "third", "build_number": "303000267"])
+        store.set("glasses", "headUp", true)
+        store.set("glasses", "voiceActivityDetectionEnabled", !BluetoothSdkDefaults.voiceActivityDetectionEnabled)
+        XCTAssertFalse(sdk.glassesStatus.fullyBooted)
+        XCTAssertTrue(sdk.glassesStatus.connected)
+        transport.cleanup()
+        XCTAssertFalse(sdk.glassesStatus.connected)
+        XCTAssertEqual(store.get("glasses", "headUp") as? Bool, false)
+        XCTAssertEqual(store.get("glasses", "voiceActivityDetectionEnabled") as? Bool,
+                       BluetoothSdkDefaults.voiceActivityDetectionEnabled)
+    }
+
+    func testPairingYieldDuringPendingReadinessCleansUpAndReclaimsAfterItsWindow() async throws {
+        let store = DeviceStore.shared.store
+        let saved = ["bluetooth", "glasses"].map { ($0, store.getCategory($0)) }
+        let previous = DeviceManager.shared.sgc
+        let transport = SessionReadinessTransport()
+        let sdk = MentraBluetoothSDK()
+        DeviceManager.shared.sgc = transport
+        defer {
+            sdk.invalidate()
+            transport.cleanup()
+            DeviceManager.shared.sgc = previous
+            for (category, values) in saved {
+                for key in store.getCategory(category).keys where values[key] == nil {
+                    store.remove(category, key)
+                }
+                for (key, value) in values { store.set(category, key, value) }
+            }
+        }
+
+        func receive(_ value: [String: Any]) throws {
+            try transport.processReceivedData(JSONSerialization.data(withJSONObject: value))
+        }
+        try receive(["type": "glasses_ready", "sid": "original"])
+        try receive(["type": "version_info_1", "sid": "replacement", "build_number": "302010070"])
+        XCTAssertTrue(sdk.glassesStatus.connected)
+        XCTAssertFalse(sdk.glassesStatus.fullyBooted)
+        store.set("glasses", "headUp", true)
+        store.set("glasses", "voiceActivityDetectionEnabled", !BluetoothSdkDefaults.voiceActivityDetectionEnabled)
+
+        try receive(["type": "entering_pairing_mode", "window_ms": 5000])
+        XCTAssertTrue(transport.isPairingYieldActive())
+        XCTAssertFalse(sdk.glassesStatus.connected)
+        XCTAssertFalse(sdk.glassesStatus.fullyBooted)
+        XCTAssertEqual(store.get("glasses", "headUp") as? Bool, false)
+        XCTAssertEqual(store.get("glasses", "voiceActivityDetectionEnabled") as? Bool,
+                       BluetoothSdkDefaults.voiceActivityDetectionEnabled)
+
+        // Readiness queued on the relinquished GATT must not close the yield.
+        try receive(["type": "glasses_ready", "sid": "replacement"])
+        XCTAssertTrue(transport.isPairingYieldActive())
+        XCTAssertFalse(sdk.glassesStatus.fullyBooted)
+
+        // Let the existing minimum yield expire, then accept a fresh readiness.
+        try await Task.sleep(nanoseconds: 5_100_000_000)
+        XCTAssertFalse(transport.isPairingYieldActive())
+        try receive(["type": "glasses_ready", "sid": "reclaimed"])
+        XCTAssertTrue(sdk.glassesStatus.connected)
+        XCTAssertTrue(sdk.glassesStatus.fullyBooted)
+    }
+
+    func testInitialVersionChunkDoesNotStartAnExtraReadinessExchange() throws {
+        let store = DeviceStore.shared.store
+        let saved = store.getCategory("glasses")
+        let transport = SessionReadinessTransport()
+        defer {
+            transport.cleanup()
+            for key in store.getCategory("glasses").keys where saved[key] == nil { store.remove("glasses", key) }
+            for (key, value) in saved { store.set("glasses", key, value) }
+        }
+        store.set("glasses", "fullyBooted", false)
+        try transport.processReceivedData(JSONSerialization.data(withJSONObject: [
+            "type": "version_info_1", "sid": "initial", "build_number": "303000267",
+        ]))
+        XCTAssertTrue(transport.commands.isEmpty)
+        XCTAssertEqual(store.get("glasses", "buildNumber") as? String, "303000267")
+        XCTAssertEqual(store.get("glasses", "fullyBooted") as? Bool, false)
+    }
+}