@mentra/bluetooth-sdk 3.2.1 → 3.3.0-beta.954

package/ios/Tests/BluetoothSdkUsageTrackerTests.swift

@@ -0,0 +1,296 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class BluetoothSdkUsageTrackerTests: XCTestCase {
+    private var tracker = BluetoothSdkUsageTracker()
+
+    func testApiPhotoReportsItsRequestShapeLatencyAndOutcome() {
+        let ok = tracker.photoSettled(
+            size: "medium", mode: "photo", compress: "none", save: true, transferMethod: "auto",
+            latencyMs: 812, fileSizeBytes: 204_800, errorCode: nil
+        )
+        XCTAssertEqual(ok.name, "bluetooth_sdk_photo_taken")
+        XCTAssertEqual(ok.properties["trigger"] as? String, "api")
+        XCTAssertEqual(ok.properties["success"] as? Bool, true)
+        XCTAssertEqual(ok.properties["latency_ms"] as? Int64, 812)
+        XCTAssertEqual(ok.properties["photo_size"] as? String, "medium")
+        XCTAssertEqual(ok.properties["save_to_gallery"] as? Bool, true)
+        XCTAssertEqual(ok.properties["transfer_method"] as? String, "auto")
+        XCTAssertEqual(ok.properties["file_size_bytes"] as? Int64, 204_800)
+        XCTAssertNil(ok.properties["error_code"])
+
+        let failed = tracker.photoSettled(
+            size: "max", mode: "photo", compress: "none", save: false, transferMethod: "ble",
+            latencyMs: 30000, fileSizeBytes: nil, errorCode: "request_timeout"
+        )
+        XCTAssertEqual(failed.properties["success"] as? Bool, false)
+        XCTAssertEqual(failed.properties["error_code"] as? String, "request_timeout")
+        XCTAssertNil(failed.properties["file_size_bytes"])
+    }
+
+    func testFailedButtonPhotoIsReportedAsButtonTrigger() {
+        let event = tracker.buttonPhotoFailed(errorCode: "CAMERA_BUSY")
+        XCTAssertEqual(event.properties["trigger"] as? String, "button")
+        XCTAssertEqual(event.properties["success"] as? Bool, false)
+        XCTAssertEqual(event.properties["error_code"] as? String, "CAMERA_BUSY")
+        XCTAssertEqual(tracker.buttonPhotoFailed(errorCode: nil).properties["error_code"] as? String, "photo_request_failed")
+    }
+
+    func testApiRecordingReportsLengthParametersAndAppStopOnce() throws {
+        tracker.videoRequested(requestId: "rec-1", width: 1920, height: 1080, fps: 30, save: true, maxDurationMinutes: 0)
+        XCTAssertNil(tracker.videoStatus(requestId: "rec-1", status: "recording_started", success: true, nowMs: 1000))
+        // A duplicate start does not move the start time.
+        XCTAssertNil(tracker.videoStatus(requestId: "rec-1", status: "recording_started", success: true, nowMs: 2000))
+        tracker.videoStopRequested(requestId: "rec-1")
+
+        let stopped = try XCTUnwrap(tracker.videoStatus(requestId: "rec-1", status: "recording_stopped", success: true, nowMs: 61000))
+        XCTAssertEqual(stopped.name, "bluetooth_sdk_video_recorded")
+        XCTAssertEqual(stopped.properties["trigger"] as? String, "api")
+        XCTAssertEqual(stopped.properties["success"] as? Bool, true)
+        XCTAssertEqual(stopped.properties["duration_ms"] as? Int64, 60000)
+        XCTAssertEqual(stopped.properties["width"] as? Int, 1920)
+        XCTAssertEqual(stopped.properties["fps"] as? Int, 30)
+        XCTAssertEqual(stopped.properties["save_to_gallery"] as? Bool, true)
+        XCTAssertEqual(stopped.properties["stopped_by_app"] as? Bool, true)
+        XCTAssertNil(stopped.properties["max_duration_minutes"])
+
+        XCTAssertNil(tracker.videoStatus(requestId: "rec-1", status: "recording_stopped", success: true, nowMs: 62000))
+    }
+
+    func testButtonRecordingIsReportedWithButtonTriggerAndNoAppStop() throws {
+        let id = "local_video_1728000000_ab12"
+        _ = tracker.videoStatus(requestId: id, status: "recording_started", success: true, nowMs: 0)
+        let stopped = try XCTUnwrap(tracker.videoStatus(requestId: id, status: "recording_stopped", success: true, nowMs: 5000))
+        XCTAssertEqual(stopped.properties["trigger"] as? String, "button")
+        XCTAssertEqual(stopped.properties["duration_ms"] as? Int64, 5000)
+        XCTAssertEqual(stopped.properties["stopped_by_app"] as? Bool, false)
+    }
+
+    func testRecordingFailureIsReportedButNotRecordingIsNotARecording() throws {
+        tracker.videoRequested(requestId: "rec-2", width: 0, height: 0, fps: 0, save: false, maxDurationMinutes: 5)
+        let failed = try XCTUnwrap(tracker.videoStatus(requestId: "rec-2", status: "battery_low", success: false, nowMs: 0))
+        XCTAssertEqual(failed.properties["success"] as? Bool, false)
+        XCTAssertEqual(failed.properties["error_code"] as? String, "battery_low")
+        XCTAssertEqual(failed.properties["max_duration_minutes"] as? Int, 5)
+        XCTAssertNil(failed.properties["duration_ms"])
+        XCTAssertNil(failed.properties["width"])
+
+        XCTAssertNil(tracker.videoStatus(requestId: "rec-3", status: "not_recording", success: false, nowMs: 0))
+        XCTAssertNil(tracker.videoStatus(requestId: "", status: "recording_stopped", success: true, nowMs: 0))
+    }
+
+    func testStreamIsReportedAtStartAndOnceAtItsTerminalStatus() throws {
+        XCTAssertNil(tracker.streamRequested(streamId: "s1", streamUrl: "rtmps://live.example.com/app/secret-key", nowMs: 6600))
+        // The first live status can arrive before startStream returns.
+        XCTAssertNil(stream("streaming", nowMs: 10000))
+        let started = tracker.streamStartSettled(
+            streamUrl: "rtmps://live.example.com/app/secret-key",
+            width: 1280,
+            height: 720,
+            fps: 30,
+            bitrate: 2_000_000,
+            captureAudio: true,
+            glassesNetwork: "wifi",
+            latencyMs: 3400,
+            errorCode: nil
+        )
+        XCTAssertEqual(started.name, "bluetooth_sdk_stream_started")
+        XCTAssertEqual(started.properties["success"] as? Bool, true)
+        XCTAssertEqual(started.properties["protocol"] as? String, "rtmp")
+        XCTAssertEqual(started.properties["glasses_network"] as? String, "wifi")
+        XCTAssertFalse(started.properties.values.contains { "\($0)".contains("secret-key") })
+
+        XCTAssertNil(stream("reconnecting", reconnectAttempt: 1, nowMs: 20000))
+        XCTAssertNil(stream("reconnected", reconnectAttempt: 2, nowMs: 21000))
+        XCTAssertNil(stream("streaming", bitrate: 1_800_000, droppedFrames: 12, nowMs: 30000))
+        // Statuses for another stream id do not touch this one.
+        XCTAssertNil(tracker.streamStatus(
+            streamId: "other", state: "stopped", terminal: true, reconnectAttempt: nil, bitrate: nil, fps: nil,
+            droppedFrames: nil, temperatureC: nil, errorDetails: nil, nowMs: 31000
+        ))
+        tracker.streamStopRequested()
+
+        let ended = try XCTUnwrap(stream("stopped", terminal: true, nowMs: 70000))
+        XCTAssertEqual(ended.name, "bluetooth_sdk_stream_ended")
+        XCTAssertEqual(ended.properties["protocol"] as? String, "rtmp")
+        XCTAssertEqual(ended.properties["duration_ms"] as? Int64, 60000)
+        XCTAssertEqual(ended.properties["end_state"] as? String, "stopped")
+        XCTAssertEqual(ended.properties["stopped_by_app"] as? Bool, true)
+        XCTAssertEqual(ended.properties["reconnect_attempts"] as? Int, 2)
+        XCTAssertEqual(ended.properties["bitrate"] as? Int64, 1_800_000)
+        XCTAssertEqual(ended.properties["dropped_frames"] as? Int64, 12)
+
+        XCTAssertNil(stream("stopped", terminal: true, nowMs: 71000))
+    }
+
+    func testStreamThatEndsRightAfterGoingLiveIsStillReported() throws {
+        _ = tracker.streamRequested(streamId: "s1", streamUrl: "rtmp://host/app", nowMs: 0)
+        XCTAssertNil(stream("streaming", nowMs: 1000))
+        let ended = try XCTUnwrap(stream("error", terminal: true, nowMs: 1500))
+        XCTAssertEqual(ended.properties["duration_ms"] as? Int64, 500)
+        XCTAssertEqual(ended.properties["end_state"] as? String, "error")
+    }
+
+    func testNewStartReportsTheLiveStreamItReplaces() throws {
+        _ = tracker.streamRequested(streamId: "s1", streamUrl: "rtmp://host/app", nowMs: 0)
+        _ = stream("streaming", nowMs: 1000)
+        let replaced = try XCTUnwrap(tracker.streamRequested(streamId: "s2", streamUrl: "srt://host:9000", nowMs: 11000))
+        XCTAssertEqual(replaced.name, "bluetooth_sdk_stream_ended")
+        XCTAssertEqual(replaced.properties["protocol"] as? String, "rtmp")
+        XCTAssertEqual(replaced.properties["end_state"] as? String, "replaced")
+        XCTAssertEqual(replaced.properties["duration_ms"] as? Int64, 10000)
+        // The replaced stream's own late terminal status is not reported again.
+        XCTAssertNil(stream("stopped", terminal: true, nowMs: 12000))
+        XCTAssertNil(tracker.streamStatus(
+            streamId: "s2", state: "streaming", terminal: nil, reconnectAttempt: nil, bitrate: nil, fps: nil,
+            droppedFrames: nil, temperatureC: nil, errorDetails: nil, nowMs: 12000
+        ))
+        let second = try XCTUnwrap(tracker.streamStatus(
+            streamId: "s2", state: "stopped", terminal: true, reconnectAttempt: nil, bitrate: nil, fps: nil,
+            droppedFrames: nil, temperatureC: nil, errorDetails: nil, nowMs: 20000
+        ))
+        XCTAssertEqual(second.properties["protocol"] as? String, "srt")
+        XCTAssertEqual(second.properties["duration_ms"] as? Int64, 8000)
+    }
+
+    func testOlderGlassesEndAStreamOnStoppedAndErrorDetailsLoseTheirUrls() throws {
+        _ = tracker.streamRequested(streamId: "s2", streamUrl: "https://whip.example.com/whip/abc", nowMs: 0)
+        XCTAssertNil(tracker.streamStatus(
+            streamId: nil, state: "streaming", terminal: nil, reconnectAttempt: nil, bitrate: nil, fps: nil,
+            droppedFrames: nil, temperatureC: nil, errorDetails: nil, nowMs: 500
+        ))
+        XCTAssertNil(tracker.streamStatus(
+            streamId: nil, state: "error", terminal: nil, reconnectAttempt: nil, bitrate: nil, fps: nil,
+            droppedFrames: nil, temperatureC: nil, errorDetails: nil, nowMs: 1000
+        ))
+        let ended = try XCTUnwrap(tracker.streamStatus(
+            streamId: nil, state: "reconnect_failed", terminal: nil, reconnectAttempt: nil, bitrate: nil, fps: nil,
+            droppedFrames: nil, temperatureC: nil, errorDetails: "connect to https://whip.example.com/whip/abc failed",
+            nowMs: 9000
+        ))
+        XCTAssertEqual(ended.properties["protocol"] as? String, "whip")
+        XCTAssertEqual(ended.properties["end_state"] as? String, "reconnect_failed")
+        XCTAssertEqual(ended.properties["error_code"] as? String, "connect to <url> failed")
+        XCTAssertEqual(ended.properties["stopped_by_app"] as? Bool, false)
+    }
+
+    func testStreamThatNeverWentLiveEndsWithoutASecondEvent() {
+        _ = tracker.streamRequested(streamId: "s3", streamUrl: "srt://host:9000", nowMs: 0)
+        let failed = tracker.streamStartSettled(
+            streamUrl: "srt://host:9000", width: nil, height: nil, fps: nil, bitrate: nil,
+            captureAudio: true, glassesNetwork: "none", latencyMs: 30000, errorCode: "stream_start_failed"
+        )
+        XCTAssertEqual(failed.properties["success"] as? Bool, false)
+        XCTAssertEqual(failed.properties["error_code"] as? String, "stream_start_failed")
+        XCTAssertEqual(failed.properties["protocol"] as? String, "srt")
+        XCTAssertNil(tracker.streamStatus(
+            streamId: "s3", state: "stopped", terminal: true, reconnectAttempt: nil, bitrate: nil, fps: nil,
+            droppedFrames: nil, temperatureC: nil, errorDetails: nil, nowMs: 1000
+        ))
+        // Nothing live was replaced either.
+        XCTAssertNil(tracker.streamRequested(streamId: "s4", streamUrl: "srt://host:9000", nowMs: 2000))
+    }
+
+    func testStreamProtocolFollowsTheGlassesSchemeMapping() {
+        XCTAssertEqual(BluetoothSdkUsageTracker.streamProtocol("rtmp://a"), "rtmp")
+        XCTAssertEqual(BluetoothSdkUsageTracker.streamProtocol("RTMPS://a"), "rtmp")
+        XCTAssertEqual(BluetoothSdkUsageTracker.streamProtocol("srt://a"), "srt")
+        XCTAssertEqual(BluetoothSdkUsageTracker.streamProtocol("http://a"), "whip")
+        XCTAssertEqual(BluetoothSdkUsageTracker.streamProtocol("rtmpt://a"), "unknown")
+        XCTAssertEqual(BluetoothSdkUsageTracker.streamProtocol("not a url"), "unknown")
+    }
+
+    func testMicSessionEndsWhenTheSourceTurnsOffOrChanges() throws {
+        XCTAssertNil(tracker.observeMic(currentMic: "", transcribing: false, nowMs: 0))
+        XCTAssertNil(tracker.observeMic(currentMic: "glasses", transcribing: false, nowMs: 1000))
+        XCTAssertNil(tracker.observeMic(currentMic: "glasses", transcribing: true, nowMs: 2000))
+
+        let switched = try XCTUnwrap(tracker.observeMic(currentMic: "phone", transcribing: false, nowMs: 11000))
+        XCTAssertEqual(switched.name, "bluetooth_sdk_mic_session")
+        XCTAssertEqual(switched.properties["mic_source"] as? String, "glasses")
+        XCTAssertEqual(switched.properties["duration_ms"] as? Int64, 10000)
+        XCTAssertEqual(switched.properties["local_transcription"] as? Bool, true)
+
+        let off = try XCTUnwrap(tracker.observeMic(currentMic: "", transcribing: false, nowMs: 14000))
+        XCTAssertEqual(off.properties["mic_source"] as? String, "phone")
+        XCTAssertEqual(off.properties["duration_ms"] as? Int64, 3000)
+        XCTAssertEqual(off.properties["local_transcription"] as? Bool, false)
+        XCTAssertNil(tracker.observeMic(currentMic: "", transcribing: false, nowMs: 15000))
+    }
+
+    func testWifiAndHotspotSetupReportOutcomeAndLatency() {
+        let wifi = tracker.wifiSetupSettled(latencyMs: 4000, errorCode: nil)
+        XCTAssertEqual(wifi.properties["success"] as? Bool, true)
+        XCTAssertEqual(wifi.properties["latency_ms"] as? Int64, 4000)
+        XCTAssertEqual(
+            tracker.wifiSetupSettled(latencyMs: 15000, errorCode: "connect_timeout").properties["error_code"] as? String,
+            "connect_timeout"
+        )
+        XCTAssertEqual(tracker.hotspotStartSettled(latencyMs: 2500, errorCode: nil).name, "bluetooth_sdk_hotspot_started")
+    }
+
+    func testOtaSessionIsReportedOnceWithItsStartingVersions() throws {
+        XCTAssertNil(ota("ota-1", "in_progress", nowMs: 0, fromBuild: "38"))
+        XCTAssertNil(ota("ota-1", "step_complete", nowMs: 60000, fromBuild: "39"))
+        let done = try XCTUnwrap(ota("ota-1", "complete", nowMs: 300_000, fromBuild: "40"))
+        XCTAssertEqual(done.name, "bluetooth_sdk_ota_finished")
+        XCTAssertEqual(done.properties["success"] as? Bool, true)
+        XCTAssertEqual(done.properties["duration_ms"] as? Int64, 300_000)
+        XCTAssertEqual(done.properties["from_build_number"] as? String, "38")
+        XCTAssertEqual(done.properties["total_steps"] as? Int, 2)
+        XCTAssertNil(done.properties["failed_step_type"])
+        XCTAssertNil(ota("ota-1", "complete", nowMs: 301_000, fromBuild: "40"))
+
+        let failed = try XCTUnwrap(ota(
+            "ota-2", "failed", nowMs: 0, fromBuild: "40", stepType: "bes",
+            error: "download failed: https://ota.example.com/x.bin"
+        ))
+        XCTAssertEqual(failed.properties["success"] as? Bool, false)
+        XCTAssertEqual(failed.properties["failed_step_type"] as? String, "bes")
+        XCTAssertEqual(failed.properties["error_message"] as? String, "download failed: <url>")
+        XCTAssertNil(failed.properties["duration_ms"])
+    }
+
+    func testRequestTimeoutsAreCappedPerTracker() throws {
+        var capped = BluetoothSdkUsageTracker(maxRequestTimeouts: 2)
+        let first = try XCTUnwrap(capped.requestTimedOut(operation: "photo request"))
+        XCTAssertEqual(first.name, "bluetooth_sdk_request_failed")
+        XCTAssertEqual(first.properties["operation"] as? String, "photo request")
+        XCTAssertEqual(first.properties["error_code"] as? String, "request_timeout")
+        XCTAssertNotNil(capped.requestTimedOut(operation: "start stream"))
+        XCTAssertNil(capped.requestTimedOut(operation: "start stream"))
+    }
+
+    func testDetailsAreSanitizedAndCapped() {
+        XCTAssertNil(BluetoothSdkUsageTracker.sanitizedDetail("   "))
+        XCTAssertEqual(BluetoothSdkUsageTracker.sanitizedDetail(String(repeating: "x", count: 500))?.count, 200)
+    }
+
+    private func stream(
+        _ state: String,
+        terminal: Bool? = nil,
+        reconnectAttempt: Int? = nil,
+        bitrate: Int64? = nil,
+        droppedFrames: Int64? = nil,
+        nowMs: Int64
+    ) -> AnalyticsEvent? {
+        tracker.streamStatus(
+            streamId: "s1", state: state, terminal: terminal, reconnectAttempt: reconnectAttempt, bitrate: bitrate,
+            fps: nil, droppedFrames: droppedFrames, temperatureC: nil, errorDetails: nil, nowMs: nowMs
+        )
+    }
+
+    private func ota(
+        _ sessionId: String,
+        _ status: String,
+        nowMs: Int64,
+        fromBuild: String,
+        stepType: String = "apk",
+        error: String? = nil
+    ) -> AnalyticsEvent? {
+        tracker.otaStatus(
+            sessionId: sessionId, status: status, stepType: stepType, totalSteps: 2, errorMessage: error,
+            fromBuildNumber: fromBuild, fromBesFirmwareVersion: "", fromMtkFirmwareVersion: "", nowMs: nowMs
+        )
+    }
+}

package/ios/Tests/G1TextSanitizerTests.swift

@@ -0,0 +1,32 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class G1TextSanitizerTests: XCTestCase {
+    func testPreservesSwedishTextAndComposesDecomposedAccents() {
+        let text = "“Hallå, hallå”\nÅÄÖ åäö"
+        XCTAssertEqual(G1Text.sanitizeForDisplay(text), text)
+        XCTAssertEqual(G1Text.sanitizeForDisplay("Halla\u{030A}, halla\u{030A}"), "Hallå, hallå")
+        XCTAssertEqual(G1Text.sanitizeForDisplay("Cafe\u{0301}\nĐa Nang"), "Café\nDa Nang")
+    }
+
+    func testFallsBackOnlyForUnmappedLatinAndIsIdempotent() {
+        let text = "Tiếng Việt: Đặng, Nguyễn, phở bò; Øresund Łódź Æsir Œuvre Straße Ðingvellir Þingvellir"
+        let expected = "Tieng Viet: Dang, Nguyen, pho bò; Øresund Łódź Æsir OEuvre Straße Ðingvellir Þingvellir"
+        XCTAssertEqual(G1Text.sanitizeForDisplay(text), expected)
+        XCTAssertEqual(G1Text.sanitizeForDisplay(expected), expected)
+    }
+
+    func testPreservesOtherScriptsAndNimoKeepsItsOwnFallback() {
+        let otherScripts = "が カ\u{3099} 한\u{302E} Α\u{0301} مُرَحَّبًا शि ❤️"
+        XCTAssertEqual(G1Text.sanitizeForDisplay(otherScripts), otherScripts)
+        XCTAssertEqual(LatinTextSanitizer.sanitizeForDisplay("Hallå Æsir Straße", preserveOtherScripts: true),
+                       "Halla AEsir Strasse")
+    }
+
+    func testPreservesEveryEmbeddedExtendedLatinGlyphInComposedAndDecomposedForms() {
+        let glyphs = "ÀÂÇÈÉÊËÎÏÔÙÛÜàçèéêëîïôùûüÿŸÄäÖößẞâÁáÍíÑñúÓóÚⁱIJijŠšŽžÃÅÆÌÐÒÕØÝÞãåæìðòõøýþĄąĆćČčĎďĘęĚěĞğŁłŃńŇňŘřŚśŞşŤťŮůŹźŻżĂăıȘșȚțǖǘǚǜǎǐǒǔŐőŰű"
+        XCTAssertEqual(Array(G1Text.sanitizeForDisplay(glyphs).utf8), Array(glyphs.utf8))
+        let decomposed = glyphs.decomposedStringWithCanonicalMapping
+        XCTAssertEqual(Array(G1Text.sanitizeForDisplay(decomposed).utf8), Array(glyphs.utf8))
+    }
+}

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/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)
+    }
+}

package/ios/Tests/NimoCanvasCodecTests.swift

@@ -5,6 +5,14 @@ import XCTest
 import zlib
 
 final class NimoCanvasCodecTests: XCTestCase {
+    func testLatinFallbackPreservesOtherScriptsAndTheirMarks() throws {
+        let otherScripts = "ありがとう が パ カ\u{3099} 한국어 한\u{302E} Α\u{0301} مُرَحَّبًا शि ❤️"
+        let label = try NimoCanvasCodec.label("\(otherScripts) café—Æ\u{0301}", 0, 0, 500, 220)
+        let expected = Data("\(otherScripts) cafe-AE".utf8)
+        XCTAssertEqual(Data(label.payload.dropFirst(14)), expected)
+        XCTAssertEqual(label.textBytes, expected.count)
+    }
+
     private func hex(_ data: Data) -> String {
         data.map { String(format: "%02X", $0) }.joined()
     }
@@ -107,9 +115,14 @@ final class NimoCanvasCodecTests: XCTestCase {
     }
 
     func testUtf8RowsAndGeometryValidation() throws {
-        XCTAssertEqual(try NimoCanvasCodec.label("😀é", 0, 0, 100, 20).textBytes, 6)
+        let dashes = try NimoCanvasCodec.label("—éÆß— - –", 0, 0, 100, 20)
+        let expectedText = Data("-eAEss- - –".utf8)
+        XCTAssertEqual(Data(dashes.payload.dropFirst(14)), expectedText)
+        XCTAssertEqual(dashes.textBytes, expectedText.count)
+        XCTAssertEqual(Int(dashes.payload[12]), expectedText.count)
+        XCTAssertEqual(try NimoCanvasCodec.label("😀界", 0, 0, 100, 20).textBytes, 7)
         XCTAssertThrowsError(try NimoCanvasCodec.label("a\0b", 0, 0, 100, 20))
-        XCTAssertThrowsError(try NimoCanvasCodec.label(String(repeating: "é", count: 1025), 0, 0, 100, 20))
+        XCTAssertThrowsError(try NimoCanvasCodec.label(String(repeating: "界", count: 683), 0, 0, 100, 20))
         let rows = try NimoCanvasCodec.textRows("first\n\nthird", 12, 15, 400, 100)
         XCTAssertEqual(rows.count, 2)
         XCTAssertEqual(rows.map { $0.payload[2] }, [15, 55])
@@ -156,11 +169,11 @@ final class NimoCanvasCodecTests: XCTestCase {
     }
 
     func testWholeScenePreservesOrderAndIgnoresDiffAnnotations() throws {
-        let text = SceneElement(id: "caption", type: "text", x: 10, y: 20, w: 100, h: 40, text: "hello",
+        let text = SceneElement(id: "caption", type: "text", x: 10, y: 20, w: 100, h: 40, text: "héllo—Æsir",
                                 data: nil, border: 2, radius: 3, change: "unchanged", contentHash: "")
         let expected = try NimoCanvasCodec.replace([
             NimoCanvasCodec.rectangle(10, 20, 100, 40, stroke: 2, radius: 3),
-            NimoCanvasCodec.label("hello", 10, 20, 100, 20),
+            NimoCanvasCodec.label("hello-AEsir", 10, 20, 100, 20),
         ])
         XCTAssertEqual(try NimoCanvasCodec.scene([text]) { _, _, _ in XCTFail("Not an image"); return Data() }, expected)
     }