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

package/ios/Tests/NimoDiscoveryTests.swift

@@ -0,0 +1,79 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+@MainActor
+final class NimoDiscoveryTests: XCTestCase {
+    @MainActor
+    private final class Radio {
+        var connected: [String] = []
+        var events: [String] = []
+        var found: [String] = []
+        var selected: String?
+        lazy var discovery: NimoDiscovery<String> = NimoDiscovery(
+            register: { [unowned self] in self.events.append("register") },
+            connected: { [unowned self] in self.events.append("retrieve"); return self.connected },
+            scan: { [unowned self] in self.events.append("scan") },
+            stop: { [unowned self] in self.events.append("stop") },
+            name: { $0 },
+            found: { [unowned self] _, name, _ in
+                found.append(name)
+                if selected == name { discovery.cancel() }
+            }
+        )
+    }
+
+    func testAlreadyConnectedClassicDeviceIsFoundWithoutAdvertisement() {
+        let radio = Radio()
+        radio.connected = ["NIMO_1234", "NIMO_1234_BLE", "Unrelated"]
+        radio.discovery.start()
+        XCTAssertEqual(radio.events, ["register", "retrieve", "scan"])
+        XCTAssertEqual(radio.found, ["NIMO_1234"])
+    }
+
+    func testPairingInSettingsAfterScanStartedDeliversDevice() {
+        let radio = Radio()
+        radio.discovery.start()
+        XCTAssertTrue(radio.found.isEmpty)
+        // Same entry point as connectionEventDidOccur(.peerConnected).
+        radio.discovery.receive("NIMO_5678")
+        XCTAssertEqual(radio.found, ["NIMO_5678"])
+    }
+
+    func testSelectionFromConnectedSnapshotStopsBeforeStartingBleScan() {
+        let radio = Radio()
+        radio.selected = "NIMO_5678"
+        radio.connected = ["NIMO_1234", "NIMO_5678", "NIMO_9999"]
+        radio.discovery.start()
+        XCTAssertEqual(radio.found, ["NIMO_1234", "NIMO_5678"])
+        XCTAssertEqual(radio.events, ["register", "retrieve", "stop"])
+        XCTAssertFalse(radio.discovery.active)
+    }
+
+    func testCancelledDiscoveryIgnoresQueuedEventsAndCanRestart() {
+        let radio = Radio()
+        radio.discovery.start()
+        radio.discovery.cancel()
+        radio.discovery.receive("NIMO_1234")
+        XCTAssertTrue(radio.found.isEmpty)
+        radio.connected = ["NIMO_1234"]
+        radio.discovery.start()
+        XCTAssertEqual(radio.found, ["NIMO_1234"])
+    }
+
+    func testBleFallbackUsesAdvertisementNameAndPreservesSignalStrength() {
+        var found: [String] = []
+        var signal: Int?
+        let discovery = NimoDiscovery<String>(
+            register: {}, connected: { [] }, scan: {}, stop: {}, name: { _ in nil },
+            found: { _, name, rssi in found.append(name); signal = rssi }
+        )
+        discovery.start()
+        discovery.receive("uuid", advertisedName: "NiMo_1234_bLe", rssi: -60)
+        discovery.receive("uuid", advertisedName: "Unrelated", rssi: -60)
+        discovery.receive("uuid")
+        XCTAssertTrue(found.isEmpty)
+        discovery.receive("uuid", advertisedName: "NiMo_1234", rssi: -55)
+        XCTAssertEqual(found, ["NiMo_1234"])
+        XCTAssertEqual(signal, -55)
+    }
+}

package/ios/Tests/SGCConnectionTargetTests.swift

@@ -0,0 +1,48 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class SGCConnectionTargetTests: XCTestCase {
+    func testG1RejectsAnotherPairsLegacyUUID() {
+        XCTAssertFalse(G1ConnectionTarget.matchesCachedPeripheral(name: "Even G1_12_L_123456", searchID: "_47_", cachedSearchID: nil))
+        XCTAssertTrue(G1ConnectionTarget.matchesCachedPeripheral(name: "Even G1_47_L_123456", searchID: "_47_", cachedSearchID: nil))
+        XCTAssertFalse(G1ConnectionTarget.matchesCachedPeripheral(name: "Even G1_470_R_123456", searchID: "_47_", cachedSearchID: nil))
+    }
+
+    func testG1NamelessBackgroundReconnectRequiresRecordedTarget() {
+        XCTAssertTrue(G1ConnectionTarget.matchesCachedPeripheral(name: nil, searchID: "_47_", cachedSearchID: "_47_"))
+        XCTAssertFalse(G1ConnectionTarget.matchesCachedPeripheral(name: nil, searchID: "_47_", cachedSearchID: "_12_"))
+        XCTAssertFalse(G1ConnectionTarget.matchesCachedPeripheral(name: nil, searchID: "_47_", cachedSearchID: nil))
+        XCTAssertFalse(G1ConnectionTarget.matchesCachedPeripheral(name: "Even G1_12_L_123456", searchID: "_47_", cachedSearchID: "_47_"))
+        XCTAssertFalse(G1ConnectionTarget.matchesCachedPeripheral(name: nil, searchID: "NOT_SET", cachedSearchID: "NOT_SET"))
+    }
+
+    func testNexExplicitSelectionExcludesSavedAndPreferredFallbacks() {
+        XCTAssertFalse(nex(name: "Nex1-old", target: "Nex1-new"))
+        XCTAssertFalse(nex(name: "Nex1-new-extra", target: "Nex1-new"))
+        XCTAssertTrue(nex(name: "Nex1-new", target: "Nex1-new"))
+        XCTAssertFalse(nex(name: "Nex1-old", target: ""))
+    }
+
+    func testNexDiscoveryNeverConnectsAndSavedReconnectStillWorks() {
+        XCTAssertFalse(nex(name: "Nex1-old", target: nil, discovery: true))
+        XCTAssertFalse(nex(name: "Nex1-new", target: "Nex1-new", discovery: true))
+        XCTAssertTrue(nex(name: "Nex1-old", target: nil))
+        XCTAssertTrue(nex(name: "Nex1-renamed", target: nil))
+    }
+
+    func testVuzixCurrentLinkMustMatchTheSelectedBracketedID() {
+        XCTAssertTrue(VuzixConnectionTarget.matches(name: "Vuzix Z100 [abc123]", target: "abc123"))
+        XCTAssertTrue(VuzixConnectionTarget.matches(name: "Vuzix Z100 [abc123]", target: "Vuzix Z100 [abc123]"))
+        XCTAssertFalse(VuzixConnectionTarget.matches(name: "Vuzix Z100 [old123]", target: "abc123"))
+        XCTAssertFalse(VuzixConnectionTarget.matches(name: nil, target: "abc123"))
+        XCTAssertFalse(VuzixConnectionTarget.matches(name: "", target: ""))
+        XCTAssertEqual(VuzixConnectionTarget.identifier("abc123"), "abc123")
+    }
+
+    private func nex(name: String, target: String?, discovery: Bool = false) -> Bool {
+        NexConnectionTarget.shouldConnect(
+            name: name, target: target, discoveryOnly: discovery,
+            savedName: "Nex1-old", preferredID: "old", discoveredID: "old"
+        )
+    }
+}

package/ios/Tests/VersionInfoCommandTests.swift

@@ -0,0 +1,194 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+@MainActor
+private final class VersionInfoCommandTransport: MentraLive {
+    var requestId: String?
+    var reply = true
+    var includeResponseId = true
+    var metadataOverrides: [String: Any] = [:]
+
+    override func sendJson(_ jsonOriginal: [String: Any], wakeUp: Bool, requireAck: Bool) {
+        XCTAssertEqual(jsonOriginal["type"] as? String, "request_version")
+        XCTAssertTrue(wakeUp, "An idle ASG must wake to finish its version response")
+        XCTAssertTrue(requireAck)
+        do {
+            let bytes = try JSONSerialization.data(withJSONObject: jsonOriginal)
+            let command = try XCTUnwrap(JSONSerialization.jsonObject(with: bytes) as? [String: Any])
+            let id = try XCTUnwrap(command["request_id"] as? String)
+            requestId = id
+            guard reply else { return }
+            var common: [String: Any] = ["sid": "asg-1", "chunkCount": 2]
+            if includeResponseId { common["request_id"] = id }
+            for chunk: [String: Any] in [
+                ["type": "version_info_1", "chunkIndex": 1, "final": false,
+                 "build_number": "303000008", "app_version": "3.3.0"],
+                ["type": "version_info_3", "chunkIndex": 2, "final": true,
+                 "bes_fw_version": "26.9.23.0", "mtk_fw_version": "MentraLive_20260921.0"],
+            ] {
+                let response = common.merging(chunk) { _, value in value }
+                    .merging(metadataOverrides) { _, value in value }
+                try processReceivedData(JSONSerialization.data(withJSONObject: response))
+            }
+        } catch {
+            XCTFail("Could not replay version request: \(error)")
+        }
+    }
+}
+
+@MainActor
+final class VersionInfoCommandTests: XCTestCase {
+    func testPublicVersionRequestWakesGlassesAndCombinesBothResponseChunks() async throws {
+        let previous = DeviceManager.shared.sgc
+        let transport = VersionInfoCommandTransport()
+        DeviceManager.shared.sgc = transport
+        let sdk = MentraBluetoothSDK()
+        var diagnostics: [[String: Any]] = []
+        let sink = Bridge.addEventSink { event, body in
+            if let diagnostic = self.diagnostic(event, body) { diagnostics.append(diagnostic) }
+        }
+        defer {
+            Bridge.removeEventSink(sink)
+            sdk.invalidate()
+            DeviceManager.shared.sgc = previous
+        }
+
+        let result = try await sdk.requestVersionInfo()
+
+        XCTAssertNotNil(transport.requestId)
+        XCTAssertEqual(result.buildNumber, "303000008")
+        XCTAssertEqual(result.appVersion, "3.3.0")
+        XCTAssertEqual(result.besFirmwareVersion, "26.9.23.0")
+        XCTAssertEqual(result.mtkFirmwareVersion, "MentraLive_20260921.0")
+        XCTAssertEqual(diagnostics.compactMap { $0["stage"] as? String }, [
+            "registered", "response-waiting", "response-complete", "resolved",
+        ])
+        XCTAssertTrue(diagnostics.allSatisfy { $0["requestId"] as? String == transport.requestId })
+        XCTAssertEqual(diagnostics[1]["responseRequestId"] as? String, transport.requestId)
+        XCTAssertEqual(diagnostics[2]["responseChunk"] as? String, "version_info_3")
+        XCTAssertEqual(diagnostics[1]["_responseChunkIndex"] as? String, "number:1")
+        XCTAssertEqual(diagnostics[2]["_responseChunkIndex"] as? String, "number:2")
+        XCTAssertEqual(diagnostics[1]["_responseFinal"] as? String, "boolean:false")
+        XCTAssertFalse(diagnostics.contains { $0["besFirmwareVersion"] != nil || $0["serialNumber"] != nil })
+    }
+
+    func testUncorrelatedResponseAndCancellationRetainThePendingUuidAndOriginalError() async throws {
+        let previous = DeviceManager.shared.sgc
+        let transport = VersionInfoCommandTransport()
+        transport.includeResponseId = false
+        DeviceManager.shared.sgc = transport
+        let sdk = MentraBluetoothSDK()
+        var diagnostics: [[String: Any]] = []
+        let sink = Bridge.addEventSink { event, body in
+            if let diagnostic = self.diagnostic(event, body) { diagnostics.append(diagnostic) }
+        }
+        defer {
+            Bridge.removeEventSink(sink)
+            sdk.invalidate()
+            DeviceManager.shared.sgc = previous
+        }
+        let task = Task { try await sdk.requestVersionInfo() }
+        while transport.requestId == nil {
+            await Task.yield()
+        }
+        do {
+            _ = try await sdk.requestVersionInfo()
+            XCTFail("The original pending request must retain its slot")
+        } catch let error as BluetoothSdkError {
+            XCTAssertEqual(error.code, "request_in_flight")
+        }
+        task.cancel()
+        do {
+            _ = try await task.value
+            XCTFail("Uncorrelated responses must not complete the request")
+        } catch let error as BluetoothSdkError {
+            XCTAssertEqual(error.code, "request_cancelled")
+            let rejected = try XCTUnwrap(diagnostics.last)
+            XCTAssertEqual(rejected["stage"] as? String, "rejected")
+            XCTAssertEqual(rejected["code"] as? String, error.code)
+            XCTAssertEqual(rejected["message"] as? String, error.message)
+        }
+        XCTAssertEqual(diagnostics.compactMap { $0["stage"] as? String }, [
+            "registered", "response-ignored", "response-ignored", "refused", "rejected",
+        ])
+        XCTAssertTrue(diagnostics.allSatisfy { $0["requestId"] as? String == transport.requestId })
+        XCTAssertEqual(diagnostics[1]["responseRequestId"] as? String, "")
+    }
+
+    func testNoResponseRetainsTheOriginalTimeoutAndElapsedTime() async throws {
+        let previous = DeviceManager.shared.sgc
+        let transport = VersionInfoCommandTransport()
+        transport.reply = false
+        DeviceManager.shared.sgc = transport
+        let sdk = MentraBluetoothSDK()
+        var diagnostics: [[String: Any]] = []
+        let sink = Bridge.addEventSink { event, body in
+            if let diagnostic = self.diagnostic(event, body) { diagnostics.append(diagnostic) }
+        }
+        defer {
+            Bridge.removeEventSink(sink)
+            sdk.invalidate()
+            DeviceManager.shared.sgc = previous
+        }
+        do {
+            _ = try await sdk.requestVersionInfo()
+            XCTFail("An absent response must time out")
+        } catch let error as BluetoothSdkError {
+            XCTAssertEqual(error.code, "request_timeout")
+            let rejected = try XCTUnwrap(diagnostics.last)
+            XCTAssertEqual(rejected["code"] as? String, error.code)
+            XCTAssertEqual(rejected["message"] as? String, error.message)
+            XCTAssertGreaterThanOrEqual(try XCTUnwrap(rejected["elapsedMs"] as? Int), 15000)
+        }
+        XCTAssertEqual(diagnostics.compactMap { $0["stage"] as? String }, ["registered", "rejected"])
+        XCTAssertTrue(diagnostics.allSatisfy { $0["requestId"] as? String == transport.requestId })
+    }
+
+    func testMalformedMetadataRetainsItsTypeThroughTheActualBridgeLog() async throws {
+        let previous = DeviceManager.shared.sgc
+        let transport = VersionInfoCommandTransport()
+        DeviceManager.shared.sgc = transport
+        let sdk = MentraBluetoothSDK()
+        var diagnostics: [[String: Any]] = []
+        let sink = Bridge.addEventSink { event, body in
+            if let diagnostic = self.diagnostic(event, body) { diagnostics.append(diagnostic) }
+        }
+        defer {
+            Bridge.removeEventSink(sink)
+            sdk.invalidate()
+            DeviceManager.shared.sgc = previous
+        }
+        for (wireKey, logKey, value, expected) in [
+            ("chunkIndex", "_responseChunkIndex", true as Any, "boolean:true"),
+            ("chunkCount", "_responseChunkCount", true as Any, "boolean:true"),
+            ("final", "_responseFinal", 1 as Any, "number:1"),
+        ] {
+            diagnostics.removeAll()
+            transport.requestId = nil
+            transport.metadataOverrides = [wireKey: value]
+            let task = Task { try await sdk.requestVersionInfo() }
+            while transport.requestId == nil {
+                await Task.yield()
+            }
+            task.cancel()
+            do {
+                _ = try await task.value
+                XCTFail("Malformed metadata must not resolve")
+            } catch let error as BluetoothSdkError {
+                XCTAssertEqual(error.code, "request_cancelled")
+            }
+            let ignored = diagnostics.filter { $0["stage"] as? String == "response-ignored" }
+            XCTAssertEqual(ignored.count, 2)
+            XCTAssertTrue(ignored.allSatisfy { $0[logKey] as? String == expected })
+        }
+    }
+
+    private func diagnostic(_ event: String, _ body: [String: Any]) -> [String: Any]? {
+        guard event == "log", let message = body["message"] as? String,
+              message.contains("layer=sdk_version_request"),
+              let payload = message.range(of: " payload="),
+              let data = String(message[payload.upperBound...]).data(using: .utf8)
+        else { return nil }
+        return try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+    }
+}

package/ios/Tests/VersionInfoResponseAccumulatorTests.swift

@@ -117,6 +117,71 @@ final class VersionInfoResponseAccumulatorTests: XCTestCase {
         }
     }
 
+    func testFactoryAsg27CompletesAfterItsTwoChunks() {
+        // Exact January wire shape after Bridge normalization; firmware can be unknown.
+        for firmware in ["", "17.26.1.13"] {
+            let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+            _ = accumulator.accept(chunk("version_info_1", nil, ["buildNumber": "27", "appVersion": "27.0"]))
+            guard case let .complete(result) = accumulator.accept(chunk("version_info_2", nil, [
+                "buildNumber": "", "otaVersionUrl": "https://ota.example/live_version.json", "firmwareVersion": firmware,
+            ])) else { return XCTFail("ASG27 has no third chunk") }
+            XCTAssertEqual(result.buildNumber, "27")
+            XCTAssertEqual(result.otaVersionUrl, "https://ota.example/live_version.json")
+            XCTAssertEqual(result.firmwareVersion, firmware)
+        }
+    }
+
+    func testOtherLegacyBuildsStillRequireTheirThirdChunk() {
+        for build in ["", "26", "28", "31", "37", "42"] {
+            let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+            _ = accumulator.accept(chunk("version_info_1", nil, ["buildNumber": build]))
+            guard case .waiting = accumulator.accept(chunk("version_info_2", nil, [
+                "otaVersionUrl": "https://ota.example/version.json",
+            ])) else { return XCTFail("Unknown or three-chunk builds must wait: " + build) }
+            guard case .complete = accumulator.accept(chunk("version_info_3", nil, ["besFirmwareVersion": "new"]))
+            else { return XCTFail("Legacy third chunk must complete") }
+        }
+    }
+
+    func testFactorySecondChunkCannotCompleteWithoutFirstChunkAndOtaUrl() {
+        let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+        let second = chunk("version_info_2", nil, ["otaVersionUrl": "https://ota.example/version.json"])
+        guard case .ignored = accumulator.accept(second) else { return XCTFail("Trailing chunk is stale") }
+        _ = accumulator.accept(chunk("version_info_1", nil, ["buildNumber": "27"]))
+        for values in [[:], ["otaVersionUrl": ""], ["otaVersionUrl": " \n"]] as [[String: Any]] {
+            guard case .waiting = accumulator.accept(chunk("version_info_2", nil, values))
+            else { return XCTFail("Incomplete second chunk cannot complete") }
+        }
+        guard case .complete = accumulator.accept(second) else { return XCTFail("Actual terminal chunk") }
+    }
+
+    func testSecondChunkCannotChangeBuildIntoFactoryProtocol() {
+        let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+        _ = accumulator.accept(chunk("version_info_1", nil, ["buildNumber": "31"]))
+        guard case .waiting = accumulator.accept(chunk("version_info_2", nil, [
+            "buildNumber": "27", "otaVersionUrl": "https://ota.example/version.json",
+        ])) else { return XCTFail("Only the first chunk declares the protocol") }
+    }
+
+    func testRepeatedFirstChunkClearsFactoryCompletionRule() {
+        let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+        _ = accumulator.accept(chunk("version_info_1", nil, ["buildNumber": "27"]))
+        _ = accumulator.accept(chunk("version_info_1", nil, ["buildNumber": "31"]))
+        guard case .waiting = accumulator.accept(chunk("version_info_2", nil, [
+            "otaVersionUrl": "https://ota.example/version.json",
+        ])) else { return XCTFail("The latest first chunk determines the protocol") }
+    }
+
+    func testFactoryBuildCannotBypassModernCorrelation() {
+        let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+        _ = accumulator.accept(chunk("version_info_1", "request-1", ["buildNumber": "27"]))
+        guard case .ignored = accumulator.accept(chunk("version_info_2", nil, [
+            "otaVersionUrl": "https://ota.example/version.json",
+        ])) else { return XCTFail("Uncorrelated terminal chunk cannot complete a modern request") }
+        guard case .complete = accumulator.accept(chunk("version_info_3", "request-1", ["besFirmwareVersion": "new"]))
+        else { return XCTFail("Modern completeness metadata remains authoritative") }
+    }
+
     func testModernFinalChunkWaitsForMissingFirstChunk() {
         let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
         guard case .waiting = accumulator.accept(chunk("version_info_3", "request-1", ["besFirmwareVersion": "new"])) else {

package/ios/Tests/VideoRecordingCommandTests.swift

@@ -0,0 +1,81 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+/// Replace the radio handoff while retaining public SDK dispatch and response handling.
+@MainActor
+private final class VideoRecordingCommandTransport: MentraLive {
+    var commands: [[String: Any]] = []
+
+    override func sendJson(_ jsonOriginal: [String: Any], wakeUp: Bool, requireAck: Bool) {
+        do {
+            let bytes = try JSONSerialization.data(withJSONObject: jsonOriginal)
+            let command = try XCTUnwrap(JSONSerialization.jsonObject(with: bytes) as? [String: Any])
+            let type = try XCTUnwrap(command["type"] as? String)
+            let requestId = try XCTUnwrap(command["requestId"] as? String)
+            commands.append(command)
+            XCTAssertTrue(wakeUp, "\(type) must wake the glasses before ASG can handle it")
+            XCTAssertTrue(requireAck)
+
+            let statuses = [
+                "start_video_recording": "recording_started",
+                "get_video_recording_status": "recording_status",
+                "stop_video_recording": "recording_stopped",
+            ]
+            let status = try XCTUnwrap(statuses[type])
+            let response: [String: Any] = [
+                "type": "video_recording_status", "requestId": requestId,
+                "status": status, "success": true,
+            ]
+            try processReceivedData(JSONSerialization.data(withJSONObject: response))
+        } catch {
+            XCTFail("Could not replay video recording command: \(error)")
+        }
+    }
+}
+
+@MainActor
+final class VideoRecordingCommandTests: XCTestCase {
+    func testStartStatusAndStopWakeGlassesThroughPublicSDK() async throws {
+        let previous = DeviceManager.shared.sgc
+        let store = DeviceStore.shared.store
+        let savedConnected = store.getCategory("glasses")["connected"]
+        let transport = VideoRecordingCommandTransport()
+        transport.connectionState = ConnTypes.CONNECTED
+        DeviceManager.shared.sgc = transport
+        DeviceStore.shared.apply("glasses", "connected", true)
+        let sdk = MentraBluetoothSDK()
+        defer {
+            sdk.invalidate()
+            DeviceManager.shared.sgc = previous
+            if let savedConnected {
+                store.set("glasses", "connected", savedConnected)
+            } else {
+                store.remove("glasses", "connected")
+            }
+        }
+
+        let requestId = "idle-recording"
+        let started = try await sdk.startVideoRecording(VideoRecordingRequest(
+            requestId: requestId, save: true, sound: false,
+            width: 1280, height: 720, fps: 30, maxRecordingTimeMinutes: 2
+        ))
+        XCTAssertEqual(started.status, "recording_started")
+        XCTAssertEqual(started.requestId, requestId)
+        let start = try XCTUnwrap(transport.commands.last)
+        XCTAssertEqual(start["save"] as? Bool, true)
+        XCTAssertEqual(start["sound"] as? Bool, false)
+        XCTAssertEqual(start["settings"] as? [String: Int], ["width": 1280, "height": 720, "fps": 30])
+        XCTAssertEqual(start["maxRecordingTimeMinutes"] as? Int, 2)
+
+        let status = try await sdk.queryVideoRecordingStatus(requestId: requestId)
+        XCTAssertEqual(status.status, "recording_status")
+        XCTAssertEqual(status.requestId, requestId)
+
+        let stopped = try await sdk.stopVideoRecording(requestId: requestId)
+        XCTAssertEqual(stopped.status, "recording_stopped")
+        XCTAssertEqual(stopped.requestId, requestId)
+        XCTAssertEqual(transport.commands.compactMap { $0["type"] as? String }, [
+            "start_video_recording", "get_video_recording_status", "stop_video_recording",
+        ])
+    }
+}

package/ios/Tests/WifiCredentialLoggingTests.swift

@@ -0,0 +1,42 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+/// Captures packed BLE writes instead of sending them, so the real device dispatch,
+/// command serialization and transport logging run without a radio.
+@MainActor
+private final class CapturingMentraLive: MentraLive {
+    var writes: [Data] = []
+
+    override func queueSend(_ data: Data, id _: String, trace _: BleWriteTrace?) {
+        writes.append(data)
+    }
+}
+
+@MainActor
+final class WifiCredentialLoggingTests: XCTestCase {
+    func testWifiCredentialsReachTheBleQueueWithoutBeingLogged() {
+        let ssid = "synthetic-\(UUID().uuidString)"
+        let password = UUID().uuidString
+        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) }
+        let manager = DeviceManager()
+        let live = CapturingMentraLive()
+        manager.sgc = live
+
+        manager.sendWifiCredentials(ssid, password)
+
+        XCTAssertFalse(logs.contains { $0.contains(password) }, "password logged")
+        XCTAssertTrue(logs.contains("MAN: Sending wifi credentials: \(ssid)"))
+        XCTAssertTrue(logs.contains("LIVE: Sending data to glasses: <set_wifi_credentials with credentials omitted>"))
+        // The glasses still receive the unchanged credentials.
+        let wire = live.writes.map { String(decoding: $0, as: UTF8.self) }.joined()
+        XCTAssertTrue(wire.contains("set_wifi_credentials"))
+        XCTAssertTrue(wire.contains(ssid))
+        XCTAssertTrue(wire.contains(password))
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/bluetooth-sdk",
-  "version": "3.2.1-dev.314",
+  "version": "3.3.0-beta.942",
   "description": "SDK for communicating with smart glasses",
   "main": "build/index.js",
   "react-native": "src/index.ts",
@@ -114,7 +114,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@mentra/cloud-protocol": "3.2.1-dev.314"
+    "@mentra/cloud-protocol": "3.3.0-beta.942"
   },
   "devDependencies": {
     "@types/node": "^25.9.3",

package/plugin/build/withIos.d.ts

@@ -2,5 +2,7 @@ import { IOSConfig, type ConfigPlugin } from "expo/config-plugins";
 import { type BluetoothSdkPluginProps } from "./index";
 export declare const INFO_ANALYTICS_ENVIRONMENT = "MentraBluetoothSdkAnalyticsEnvironment";
 export declare const INFO_SDK_VERSION = "MentraBluetoothSdkVersion";
+/** Lets iOS complete the SDK's pending reconnect, and deliver BLE events, while the app is suspended. */
+export declare const IOS_BLUETOOTH_BACKGROUND_MODE = "bluetooth-central";
 export declare function applyBluetoothSdkInfoPlist(infoPlist: IOSConfig.InfoPlist, props: BluetoothSdkPluginProps | undefined): IOSConfig.InfoPlist;
 export declare const withIosConfiguration: ConfigPlugin<BluetoothSdkPluginProps>;

package/plugin/build/withIos.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withIosConfiguration = exports.INFO_SDK_VERSION = exports.INFO_ANALYTICS_ENVIRONMENT = void 0;
+exports.withIosConfiguration = exports.IOS_BLUETOOTH_BACKGROUND_MODE = exports.INFO_SDK_VERSION = exports.INFO_ANALYTICS_ENVIRONMENT = void 0;
 exports.applyBluetoothSdkInfoPlist = applyBluetoothSdkInfoPlist;
 const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
@@ -17,6 +17,8 @@ exports.INFO_ANALYTICS_ENVIRONMENT = "MentraBluetoothSdkAnalyticsEnvironment";
 exports.INFO_SDK_VERSION = "MentraBluetoothSdkVersion";
 const STALE_INFO_POSTHOG_API_KEY = "MentraBluetoothSdkPostHogApiKey";
 const STALE_INFO_POSTHOG_HOST = "MentraBluetoothSdkPostHogHost";
+/** Lets iOS complete the SDK's pending reconnect, and deliver BLE events, while the app is suspended. */
+exports.IOS_BLUETOOTH_BACKGROUND_MODE = "bluetooth-central";
 const ensureBluetoothSdkExpoAdapterPodEnv = (podfile) => {
     if (podfile.includes(BLUETOOTH_SDK_EXPO_ADAPTER_ENV)) {
         return podfile;
@@ -70,6 +72,15 @@ function applyBluetoothSdkInfoPlist(infoPlist, props) {
     delete infoPlist[STALE_INFO_POSTHOG_API_KEY];
     delete infoPlist[STALE_INFO_POSTHOG_HOST];
     infoPlist[exports.INFO_SDK_VERSION] = sdkVersion;
+    // Merge, never replace: apps may also declare audio, location or other modes.
+    const declaredModes = infoPlist.UIBackgroundModes;
+    if (declaredModes !== undefined && !Array.isArray(declaredModes)) {
+        throw new Error("ios.infoPlist.UIBackgroundModes must be an array of background mode strings");
+    }
+    const backgroundModes = declaredModes ?? [];
+    if (!backgroundModes.includes(exports.IOS_BLUETOOTH_BACKGROUND_MODE)) {
+        infoPlist.UIBackgroundModes = [...backgroundModes, exports.IOS_BLUETOOTH_BACKGROUND_MODE];
+    }
     if (analytics.disabled !== undefined) {
         infoPlist[INFO_ANALYTICS_DISABLED] = analytics.disabled;
     }

package/src/BluetoothSdk.types.ts

@@ -82,6 +82,7 @@ export function isBusyGlassesConnectionStatus(status: GlassesConnectionStatus):
 export function createDisconnectedGlassesStatus(): Partial<GlassesStatus> {
   return {
     connection: {state: "disconnected"},
+    g2MissingArm: null,
     hotspot: {state: "disabled"},
     voiceActivityDetectionEnabled: DEFAULT_VOICE_ACTIVITY_DETECTION_ENABLED,
     wifi: {state: "disconnected"},
@@ -543,6 +544,15 @@ export type WearTuning = {
 export type WearStateEvent = {
   type: "wear_state"
   worn: boolean
+  /** Unworn countdown, present on firmware that reports it. Milliseconds. */
+  elapsedMs?: number
+  timeoutMs?: number
+  /** cs_swit type 11. Absent on older firmware. */
+  enabled?: boolean
+  /** Countdown is running (glasses are off the face and the feature is on). */
+  armed?: boolean
+  /** Clock is running, but charging, a call, OTA, or factory test is holding shutdown. */
+  inhibited?: boolean
 }
 
 /**
@@ -1115,6 +1125,7 @@ export type BluetoothSdkModuleEvents = {
   glasses_status: (changed: Partial<GlassesStatus>) => void
   bluetooth_status: (changed: Partial<BluetoothStatus>) => void
   log: (event: LogEvent) => void
+  sdk_update_notice: (event: {message: string}) => void
   device_discovered: (device: Device) => void
   default_device_changed: (event: {device?: Device}) => void
   // Individual event handlers
@@ -1417,6 +1428,7 @@ export interface BluetoothSdkPublicModule {
   setGalleryModeEnabled(enabled: boolean): Promise<SettingsAckSuccessEvent>
   setVoiceActivityDetectionEnabled(enabled: boolean): Promise<void>
   setLoudnessGateEnabled(enabled: boolean): Promise<void>
+  setAutoPowerOffEnabled(enabled: boolean): Promise<void>
   /**
    * @deprecated Sticky action-button photo presets are deprecated. Prefer per-request
    * `requestPhoto(...)` options (e.g. `mode: "text"` for text sensor size/crop, or explicit per-shot
@@ -1603,6 +1615,8 @@ export interface OtaProgress {
 }
 
 export interface GlassesStatus {
+  /** iOS G2 arm still disconnected after a three-second partial link; cleared on reset or both links. */
+  g2MissingArm?: "left" | "right" | null
   // state:
   connection: GlassesConnectionStatus
   micEnabled: boolean
@@ -1798,6 +1812,7 @@ export type BluetoothSettingsUpdate = Partial<{
   gallery_mode: boolean
   voice_activity_detection_enabled: boolean
   loudness_gate_enabled: boolean
+  auto_power_off_enabled: boolean
   /** Effective mic tuning only. `{}` means "reset to firmware defaults". */
   mic_tuning: MicTuning
   button_photo_size: ButtonPhotoSize