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

package/ios/Tests/NimoCanvasCodecTests.swift

@@ -0,0 +1,217 @@
+import CoreGraphics
+import ImageIO
+@testable import MentraBluetoothSDK
+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()
+    }
+
+    private func packet(_ hex: String) -> Data {
+        let chars = Array(hex)
+        return Data(stride(from: 0, to: chars.count, by: 2).map { UInt8(String(chars[$0 ... $0 + 1]), radix: 16)! })
+    }
+
+    func testVendorGoldenPacketsMatchAndroid() throws {
+        let frame = try NimoCanvasCodec.replace([
+            NimoCanvasCodec.rectangle(20, 20, 120, 50, stroke: 2, radius: 8),
+            NimoCanvasCodec.label("Hello Glass", 160, 30, 300, 40, font: 2),
+        ])
+        XCTAssertEqual(try hex(NimoCanvasCodec.frames(key: 4, content: frame, writeCapacity: 512)[0]),
+                       "BF003600F72D000007043200FD000000020001010C0014001400780032000208FF00031900A0001E002C012800000002FF0B0048656C6C6F20476C617373")
+        XCTAssertEqual(try hex(NimoCanvasCodec.frames(key: 1, writeCapacity: 512)[0]), "BF000600F5E4000007010200FD00")
+        XCTAssertEqual(try hex(NimoCanvasCodec.frames(key: 3, writeCapacity: 512)[0]), "BF00050086E4000007030100FD")
+    }
+
+    func testPolarityOddPaddingAndImageHeader() throws {
+        let gray = Data([0, 85, 170, 255, 255])
+        XCTAssertEqual(try NimoCanvasCodec.pack2(gray), Data([0xE4, 0x3F]))
+        let bitmap = try NimoCanvasCodec.bitmap(0, 0, 5, 1, gray: gray)
+        XCTAssertEqual(bitmap.payload[10], 1)
+        XCTAssertEqual(bitmap.payload[19], 2)
+        XCTAssertEqual(bitmap.payload[20], 3)
+        XCTAssertEqual(bitmap.payload[21], 2)
+        XCTAssertEqual(bitmap.payload.dropFirst(29), Data([0x82, 0xE4, 0x3F]))
+    }
+
+    func testRleRunAndLiteralBoundariesRoundTrip() throws {
+        for size in [1, 2, 3, 126, 127, 128, 254, 27500] {
+            for source in [Data(repeating: 33, count: size), Data((0 ..< size).map { UInt8($0 % 251) })] {
+                let encoded = try [UInt8](NimoCanvasCodec.rle(source))
+                var decoded = Data(), i = 0
+                while i < encoded.count {
+                    let tag = encoded[i]; i += 1
+                    let count = Int(tag & 127)
+                    XCTAssertGreaterThan(count, 0)
+                    if tag & 128 != 0 { decoded.append(contentsOf: encoded[i ..< i + count]); i += count }
+                    else { decoded.append(Data(repeating: encoded[i], count: count)); i += 1 }
+                }
+                XCTAssertEqual(decoded, source)
+            }
+        }
+    }
+
+    func testZlibImageInflatesToPackedPixels() throws {
+        let pixels: [UInt8] = (0 ..< 32768).map { index in
+            let tone = ((index / 17) ^ (index / 43)) % 4
+            return UInt8(tone * 85)
+        }
+        let gray = Data(pixels)
+        let bitmap = try NimoCanvasCodec.bitmap(0, 0, 256, 128, gray: gray)
+        XCTAssertEqual(bitmap.payload[20], 7)
+        let compressed = Data(bitmap.payload.dropFirst(29))
+        var count: uLong = 8192
+        var output = Data(count: Int(count))
+        let status = output.withUnsafeMutableBytes { dst in
+            compressed.withUnsafeBytes { src in
+                uncompress(dst.bindMemory(to: UInt8.self).baseAddress!, &count,
+                           src.bindMemory(to: UInt8.self).baseAddress!, uLong(compressed.count))
+            }
+        }
+        XCTAssertEqual(status, Z_OK)
+        XCTAssertEqual(output, try NimoCanvasCodec.pack2(gray))
+    }
+
+    func testFragmentationRespectsCoreBluetoothCapacityAndCrc() throws {
+        let content = try NimoCanvasCodec.replace([NimoCanvasCodec.label(String(repeating: "X", count: 2048), 0, 0, 500, 220)])
+        var baseline: Data?
+        for capacity in [20, 64, 185, 244, 512] {
+            let frames = try NimoCanvasCodec.frames(key: 4, content: content, writeCapacity: capacity)
+            var stream = Data()
+            for (index, frame) in frames.enumerated() {
+                XCTAssertLessThanOrEqual(frame.count, capacity)
+                XCTAssertEqual(frame[1], 0)
+                XCTAssertEqual(Int(frame[6]) | Int(frame[7]) << 8, index == frames.count - 1 ? 0 : index + 1)
+                XCTAssertEqual(UInt16(frame[4]) | UInt16(frame[5]) << 8, nimoCrc16(Data(frame.dropFirst(8))))
+                stream += frame.dropFirst(8)
+            }
+            if let baseline { XCTAssertEqual(stream, baseline) } else { baseline = stream }
+        }
+        XCTAssertThrowsError(try NimoCanvasCodec.frames(key: 4, content: content, writeCapacity: 19))
+        XCTAssertThrowsError(try NimoCanvasCodec.frames(key: 4, content: Data(count: 12281), writeCapacity: 512))
+    }
+
+    func testStrictCanvasResponseParsing() {
+        let good = packet("BF000900D87900000704050000FD000000")
+        XCTAssertEqual(NimoCanvasCodec.response(good)?.payload, Data([0, 0xFD, 0, 0, 0]))
+        XCTAssertNil(NimoCanvasCodec.response(good + Data([0])))
+        for index in [0, 1, 2, 4, 6, 8, 10] {
+            var bad = good; bad[index] ^= 1
+            XCTAssertNil(NimoCanvasCodec.response(bad))
+        }
+        let body = Data([7, 4, 1, 0, 7])
+        let statusOnly = NimoFrameCodec.transportHeader(body, needsAck: false) + body
+        XCTAssertEqual(NimoCanvasCodec.response(statusOnly)?.payload, Data([7]))
+    }
+
+    func testUtf8RowsAndGeometryValidation() throws {
+        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: 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])
+        XCTAssertEqual(rows[1].payload[6], 20)
+        XCTAssertThrowsError(try NimoCanvasCodec.rectangle(Int.max, 0, 10, 1))
+        XCTAssertThrowsError(try NimoCanvasCodec.line(0, 0, 500, 219))
+        XCTAssertThrowsError(try NimoCanvasCodec.circle(0, 10, radius: 10))
+        XCTAssertEqual(try NimoCanvasCodec.circle(10, 10, radius: 10).payload.count, 9)
+    }
+
+    func testFrameBudgetsBeforeRasterDecode() throws {
+        XCTAssertEqual(try NimoCanvasCodec.replace([]), Data([0, 0, 1]))
+        let line = try NimoCanvasCodec.line(0, 0, 1, 1)
+        XCTAssertThrowsError(try NimoCanvasCodec.replace(Array(repeating: line, count: 65)))
+        let text = try NimoCanvasCodec.label(String(repeating: "a", count: 2048), 0, 0, 500, 220)
+        XCTAssertThrowsError(try NimoCanvasCodec.replace(Array(repeating: text, count: 5)))
+        let image = SceneElement(id: "image", type: "image", x: 0, y: 0, w: 500, h: 220, text: nil,
+                                 data: "unused", border: 0, radius: 0, change: "unchanged", contentHash: "")
+        var decoded = 0
+        XCTAssertThrowsError(try NimoCanvasCodec.scene([image, image]) { _, _, _ in decoded += 1; return Data() })
+        XCTAssertEqual(decoded, 0)
+        XCTAssertThrowsError(try NimoCanvasCodec.replace([.init(type: 4, payload: Data(count: 12278))]))
+    }
+
+    func testHostFrameReservationBoundsNativeEncoding() throws {
+        var seed: UInt32 = 42
+        func noise(_ count: Int) -> Data {
+            Data((0 ..< count).map { _ in
+                seed = seed &* 1_664_525 &+ 1_013_904_223
+                return UInt8(truncatingIfNeeded: seed >> 24)
+            })
+        }
+        for size in [1, 5, 80, 160, 200] {
+            let image = try NimoCanvasCodec.bitmap(0, 0, size, size, gray: noise(size * size))
+            let packed = (size * size + 3) / 4
+            let reserved = 32 + packed + (packed + 126) / 127
+            XCTAssertLessThanOrEqual(3 + image.payload.count, reserved)
+        }
+        // Retained prefixes of the host's over-budget regression scenes.
+        let rows = try NimoCanvasCodec.textRows(Array(repeating: "row", count: 11).joined(separator: "\n"), 0, 0, 500, 220)
+        XCTAssertLessThanOrEqual(try NimoCanvasCodec.replace(Array(repeating: rows, count: 5).flatMap { $0 }).count, 12280)
+        let images = try [200, 80].map { try NimoCanvasCodec.bitmap(0, 0, $0, $0, gray: noise($0 * $0)) }
+        XCTAssertLessThanOrEqual(try NimoCanvasCodec.replace(images).count, 12280)
+    }
+
+    func testWholeScenePreservesOrderAndIgnoresDiffAnnotations() throws {
+        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-AEsir", 10, 20, 100, 20),
+        ])
+        XCTAssertEqual(try NimoCanvasCodec.scene([text]) { _, _, _ in XCTFail("Not an image"); return Data() }, expected)
+    }
+
+    func testImageKindAndDimensionsAreValidatedBeforeDecode() throws {
+        let png = Data([0x89, 0x50, 0x4E, 0x47, 13, 10, 26, 10]) + Data(count: 24)
+        XCTAssertEqual(try NimoCanvasCodec.imageBytes(png.base64EncodedString()), png)
+        XCTAssertThrowsError(try NimoCanvasCodec.imageBytes("data:image/bmp;base64," + png.base64EncodedString()))
+        XCTAssertThrowsError(try NimoCanvasCodec.imageBytes("data:image/jpeg;base64,AAAA"))
+        XCTAssertThrowsError(try NimoCanvasCodec.imageBytes("Qk0"))
+        XCTAssertThrowsError(try NimoCanvasImage.source(png.base64EncodedString()))
+        XCTAssertThrowsError(try NimoCanvasCodec.imageBytes(String(repeating: "a", count: 2_800_001)))
+    }
+
+    func testJpegPixelsAreDecodedForRawAndDataUriInputs() throws {
+        let rgba = Data(repeating: 255, count: 16)
+        let provider = CGDataProvider(data: rgba as CFData)!
+        let image = try XCTUnwrap(CGImage(width: 2, height: 2, bitsPerComponent: 8, bitsPerPixel: 32, bytesPerRow: 8,
+                                          space: CGColorSpaceCreateDeviceRGB(), bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.noneSkipLast.rawValue),
+                                          provider: provider, decode: nil, shouldInterpolate: false, intent: .defaultIntent))
+        let bytes = NSMutableData()
+        let destination = try XCTUnwrap(CGImageDestinationCreateWithData(bytes, "public.jpeg" as CFString, 1, nil))
+        CGImageDestinationAddImage(destination, image, nil)
+        XCTAssertTrue(CGImageDestinationFinalize(destination))
+        let raw = (bytes as Data).base64EncodedString()
+        for input in [raw, "data:image/jpeg;base64," + raw] {
+            XCTAssertEqual(try NimoCanvasImage.decode(input, width: 2, height: 2), Data(repeating: 255, count: 4))
+        }
+        XCTAssertThrowsError(try NimoCanvasImage.source("data:image/png;base64," + raw))
+    }
+
+    func testRasterKeepsTopRowAndLuminanceWithoutInversion() throws {
+        // Top row red/green; bottom row blue/white. Match the Android integer luminance formula.
+        let rgba = Data([255, 0, 0, 255, 0, 255, 0, 255, 0, 0, 255, 255, 255, 255, 255, 255])
+        let provider = CGDataProvider(data: rgba as CFData)!
+        let image = try XCTUnwrap(CGImage(width: 2, height: 2, bitsPerComponent: 8, bitsPerPixel: 32, bytesPerRow: 8,
+                                          space: CGColorSpaceCreateDeviceRGB(), bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.last.rawValue),
+                                          provider: provider, decode: nil, shouldInterpolate: false, intent: .defaultIntent))
+        XCTAssertEqual(try NimoCanvasImage.grayscale(image, width: 2, height: 2), Data([77, 149, 29, 255]))
+    }
+}

package/ios/Tests/NimoCanvasSessionTests.swift

@@ -0,0 +1,181 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class NimoCanvasSessionTests: XCTestCase {
+    private let a = Data([0, 0, 1])
+    private let b = Data([1, 0, 1])
+    private func ack(_ session: NimoCanvasSession, _ key: Int, status: UInt8 = 0) -> [NimoCanvasSession.Action] {
+        session.response(key: key, payload: status == 0 ? (key == 4 ? Data([0, 0xFD, 0, 0, 0]) : Data([0, 0xFD])) : Data([status]))
+    }
+
+    private func sentKey(_ actions: [NimoCanvasSession.Action]) -> Int? {
+        guard case let .send(key, _, _) = actions.first else { return nil }
+        return key
+    }
+
+    private func connected(_ session: NimoCanvasSession) {
+        XCTAssertTrue(session.offer(a, scope: "app:1").isEmpty)
+        XCTAssertEqual(sentKey(session.readiness(true)), 1)
+        XCTAssertEqual(sentKey(ack(session, 1)), 4)
+        XCTAssertTrue(ack(session, 4).isEmpty)
+    }
+
+    func testReadinessLaunchAndLatestSceneWins() {
+        let session = NimoCanvasSession()
+        XCTAssertTrue(session.offer(a, scope: "app:1").isEmpty)
+        XCTAssertEqual(sentKey(session.readiness(true)), 1)
+        XCTAssertTrue(session.offer(b, scope: "app:1").isEmpty)
+        guard case let .send(key, frame, _) = ack(session, 1).first else { return XCTFail("Missing update") }
+        XCTAssertEqual(key, 4); XCTAssertEqual(frame, b)
+        XCTAssertTrue(ack(session, 4).isEmpty)
+        XCTAssertTrue(session.offer(b, scope: "app:1").isEmpty)
+        XCTAssertEqual(sentKey(session.offer(b, scope: "app:2")), 4)
+    }
+
+    func testForcedReplayAndReconnectDiscardAcceptedState() {
+        let session = NimoCanvasSession(); connected(session)
+        XCTAssertEqual(sentKey(session.offer(a, scope: "app:1", force: true)), 4)
+        _ = ack(session, 4)
+        session.disconnected()
+        XCTAssertEqual(sentKey(session.readiness(true)), 1)
+        XCTAssertEqual(sentKey(ack(session, 1)), 4)
+    }
+
+    func testStatusSevenRequiresFreshReadinessAndBoundsRetries() {
+        let session = NimoCanvasSession()
+        _ = session.offer(a, scope: "app:1"); _ = session.readiness(true)
+        for _ in 0 ..< 3 {
+            XCTAssertEqual(ack(session, 1, status: 7), [.rejected(7)])
+            XCTAssertTrue(session.readiness(true).isEmpty)
+            XCTAssertEqual(sentKey(session.readiness(true, confirmed: true)), 1)
+        }
+        _ = ack(session, 1, status: 7)
+        XCTAssertTrue(session.readiness(true, confirmed: true).isEmpty)
+        XCTAssertTrue(session.readiness(false).isEmpty)
+        XCTAssertEqual(sentKey(session.readiness(true)), 1)
+    }
+
+    func testWrongEchoAndWrongKeyDoNotAdvance() {
+        let session = NimoCanvasSession()
+        _ = session.offer(a, scope: "app:1"); _ = session.readiness(true)
+        XCTAssertTrue(session.response(key: 1, payload: Data([0])).isEmpty)
+        XCTAssertTrue(session.response(key: 1, payload: Data([0, 1])).isEmpty)
+        XCTAssertTrue(ack(session, 4).isEmpty)
+        XCTAssertEqual(sentKey(ack(session, 1)), 4)
+    }
+
+    func testLockedAndRejectedFramesDoNotSpin() {
+        let session = NimoCanvasSession(); connected(session)
+        _ = session.offer(b, scope: "app:1")
+        XCTAssertEqual(ack(session, 4, status: 5), [.rejected(5)])
+        XCTAssertTrue(session.offer(b, scope: "app:1", force: true).isEmpty)
+        XCTAssertEqual(sentKey(session.offer(a, scope: "app:2")), 4)
+        XCTAssertEqual(ack(session, 4, status: 8), [.rejected(8)])
+        XCTAssertTrue(session.readiness(true, confirmed: true).isEmpty)
+        XCTAssertTrue(session.offer(b, scope: "new").isEmpty)
+    }
+
+    func testTimeoutRequiresNewConnectionAndStaleTicketCannotResetIt() {
+        let session = NimoCanvasSession()
+        _ = session.offer(a, scope: "app")
+        guard case let .send(_, _, ticket) = session.readiness(true).first else { return XCTFail() }
+        XCTAssertEqual(session.timeout(ticket), [.reconnect("Canvas ACK timeout; reconnect before reusing a command key")])
+        XCTAssertTrue(ack(session, 1).isEmpty)
+        session.disconnected()
+        XCTAssertEqual(sentKey(session.readiness(true)), 1)
+        XCTAssertTrue(session.timeout(ticket).isEmpty)
+    }
+
+    func testReadinessLossDuringFlightRetiresTransport() {
+        let session = NimoCanvasSession(); connected(session)
+        _ = session.offer(b, scope: "app")
+        XCTAssertEqual(session.readiness(false), [.reconnect("Readiness lost during canvas command")])
+    }
+
+    func testExitReportPreservesNewHostScene() {
+        let session = NimoCanvasSession(); connected(session)
+        XCTAssertEqual(sentKey(session.exit()), 3)
+        _ = session.offer(b, scope: "new")
+        XCTAssertTrue(session.nativeApp(0xFD, entered: false).isEmpty)
+        XCTAssertEqual(sentKey(ack(session, 3)), 1)
+        guard case let .send(_, frame, _) = ack(session, 1).first else { return XCTFail() }
+        XCTAssertEqual(frame, b)
+    }
+
+    func testNativeTakeoverReplaysWithoutNewHostFrame() {
+        let session = NimoCanvasSession(); connected(session)
+        XCTAssertEqual(sentKey(session.nativeApp(0, entered: true)), 1)
+        XCTAssertTrue(session.nativeApp(0, entered: true).isEmpty)
+        guard case let .send(_, frame, _) = ack(session, 1).first else { return XCTFail() }
+        XCTAssertEqual(frame, a)
+        XCTAssertTrue(session.nativeApp(0xFD, entered: false).isEmpty)
+        XCTAssertEqual(sentKey(ack(session, 4)), 1)
+    }
+
+    func testTakeoverDuringUpdateReplaysIdenticalFrameAfterRelaunch() {
+        let session = NimoCanvasSession()
+        _ = session.offer(a, scope: "app:1"); _ = session.readiness(true)
+        XCTAssertEqual(sentKey(ack(session, 1)), 4)
+        XCTAssertTrue(session.nativeApp(0, entered: true).isEmpty)
+        XCTAssertEqual(sentKey(ack(session, 4)), 1)
+        guard case let .send(_, frame, _) = ack(session, 1).first else { return XCTFail("Missing replay Update") }
+        XCTAssertEqual(frame, a)
+        XCTAssertTrue(ack(session, 4).isEmpty)
+        XCTAssertTrue(session.offer(a, scope: "app:1").isEmpty)
+    }
+
+    func testStartupStockUiPreservesReconnectScene() {
+        let session = NimoCanvasSession(); connected(session)
+        session.disconnected()
+        XCTAssertTrue(session.nativeApp(0, entered: true).isEmpty)
+        XCTAssertTrue(session.activate().isEmpty)
+        XCTAssertEqual(sentKey(session.readiness(true)), 1)
+        guard case let .send(_, frame, _) = ack(session, 1).first else { return XCTFail() }
+        XCTAssertEqual(frame, a)
+    }
+
+    func testActivationEntersBlankCanvasBeforeAnyMiniapp() {
+        let session = NimoCanvasSession()
+        XCTAssertTrue(session.activate().isEmpty)
+        XCTAssertEqual(sentKey(session.readiness(true)), 1)
+        guard case let .send(_, frame, _) = ack(session, 1).first else { return XCTFail() }
+        XCTAssertEqual(frame, Data([0, 0, 1]))
+    }
+
+    func testExplicitExitStopsRestorationUntilAnotherConnection() {
+        let session = NimoCanvasSession(); connected(session)
+        XCTAssertEqual(sentKey(session.exit()), 3)
+        XCTAssertTrue(session.nativeApp(0, entered: true).isEmpty)
+        XCTAssertTrue(ack(session, 3).isEmpty)
+        XCTAssertTrue(session.nativeApp(0xFD, entered: false).isEmpty)
+        session.disconnected()
+        _ = session.activate()
+        XCTAssertEqual(sentKey(session.readiness(true)), 1)
+    }
+
+    func testSuccessfulUpdateRestoresProbeBudgetForNextRecovery() {
+        let session = NimoCanvasSession()
+        _ = session.activate(); _ = session.readiness(true)
+        for episode in 0 ..< 2 {
+            if episode > 0 { XCTAssertEqual(sentKey(session.nativeApp(0, entered: true)), 1) }
+            for _ in 0 ..< 3 {
+                _ = ack(session, 1, status: 7)
+                XCTAssertEqual(sentKey(session.retryNotReady()), 1)
+            }
+            XCTAssertEqual(sentKey(ack(session, 1)), 4)
+            XCTAssertTrue(ack(session, 4).isEmpty)
+        }
+    }
+
+    func testProbesAreBoundedAndHeartbeatCanStillRecover() {
+        let session = NimoCanvasSession()
+        _ = session.activate(); _ = session.readiness(true)
+        for _ in 0 ..< 3 {
+            _ = ack(session, 1, status: 7)
+            XCTAssertEqual(sentKey(session.retryNotReady()), 1)
+        }
+        _ = ack(session, 1, status: 7)
+        XCTAssertTrue(session.retryNotReady().isEmpty)
+        XCTAssertEqual(sentKey(session.readiness(true, confirmed: true)), 1)
+    }
+}

package/ios/Tests/NimoCanvasTransportTests.swift

@@ -0,0 +1,186 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+private final class NimoTestClock {
+    private final class Job {
+        let time: TimeInterval
+        let task: () -> Void
+        var cancelled = false
+        init(_ time: TimeInterval, _ task: @escaping () -> Void) {
+            self.time = time; self.task = task
+        }
+    }
+
+    private var now: TimeInterval = 0
+    private var jobs: [Job] = []
+    lazy var schedule: NimoScheduler = { [unowned self] delay, task in
+        let job = Job(self.now + delay, task)
+        self.jobs.append(job)
+        return { job.cancelled = true }
+    }
+
+    func advance(_ seconds: TimeInterval = 0) {
+        let end = now + seconds
+        while let job = jobs.filter({ !$0.cancelled && $0.time <= end }).min(by: { $0.time < $1.time }) {
+            jobs.removeAll { $0 === job }
+            now = job.time
+            job.task()
+        }
+        now = end
+    }
+}
+
+final class NimoCanvasTransportTests: XCTestCase {
+    private let frame = Data([0, 0, 1])
+
+    func testNotReadyProbesAreTimedBoundedAndCancelled() {
+        for stop in ["budget", "disconnect", "exit", "notReady"] {
+            let clock = NimoTestClock()
+            var keys: [Int] = []
+            let canvas = NimoCanvasCoordinator(schedule: clock.schedule, writeCapacity: { 512 }, enqueue: { frames, start, complete in
+                keys.append(Int(frames[0][9])); start(); complete(); return true
+            }, reconnect: { XCTFail($0) }, rejected: { _ in })
+            canvas.activate(); canvas.readiness(true)
+            for attempt in 0 ..< 4 {
+                canvas.response(key: 1, payload: Data([7]))
+                if stop == "disconnect" { canvas.disconnected() }
+                if stop == "exit" { canvas.exit() }
+                if stop == "notReady" { canvas.readiness(false) }
+                let before = keys.count
+                clock.advance(0.999)
+                XCTAssertEqual(keys.count, before)
+                clock.advance(0.001)
+                XCTAssertEqual(keys.count, before + (stop == "budget" && attempt < 3 ? 1 : 0))
+                if stop != "budget" { break }
+            }
+            clock.advance(60)
+            XCTAssertEqual(keys.count, stop == "budget" ? 4 : 1)
+        }
+    }
+
+    func testEarlyAckOnlyAdvancesAfterFinalWriteCompletes() {
+        let clock = NimoTestClock()
+        var chains: [[Data]] = [], starts: [() -> Void] = [], completes: [() -> Void] = []
+        let canvas = NimoCanvasCoordinator(schedule: clock.schedule, writeCapacity: { 20 }, enqueue: { frames, start, complete in
+            chains.append(frames); starts.append(start); completes.append(complete); return true
+        }, reconnect: { XCTFail($0) }, rejected: { XCTFail("Unexpected rejection \($0)") })
+        canvas.offer(frame, scope: "app")
+        canvas.readiness(true)
+        canvas.response(key: 1, payload: Data([0, 0xFD])) // Before final fragment: ignore.
+        starts[0]()
+        XCTAssertEqual(chains.count, 1)
+        canvas.response(key: 1, payload: Data([0, 0xFD])) // Before GATT callback: buffer.
+        XCTAssertEqual(chains.count, 1)
+        completes[0]()
+        XCTAssertEqual(chains.count, 2)
+        XCTAssertEqual(chains[1][0][9], 4)
+        starts[1](); completes[1]()
+        canvas.response(key: 4, payload: Data([0, 0xFD, 0, 0, 0]))
+        clock.advance(60)
+    }
+
+    func testTimeoutAndOldCompletionCannotAdvanceNewGeneration() {
+        let clock = NimoTestClock()
+        var completions: [() -> Void] = [], reasons: [String] = [], count = 0
+        let canvas = NimoCanvasCoordinator(schedule: clock.schedule, writeCapacity: { 512 }, enqueue: { _, start, complete in
+            count += 1; start(); completions.append(complete); return true
+        }, reconnect: { reasons.append($0) }, rejected: { _ in })
+        canvas.offer(frame, scope: "app"); canvas.readiness(true)
+        clock.advance(45)
+        XCTAssertEqual(reasons.count, 1)
+        canvas.readiness(true)
+        completions[0]()
+        canvas.response(key: 1, payload: Data([0, 0xFD]))
+        XCTAssertEqual(count, 2) // ACK buffered for the new flight until its own write completes.
+        completions[1]()
+        XCTAssertEqual(count, 3)
+        canvas.disconnected()
+    }
+
+    func testQueueWatchdogRetiresRatherThanSkippingFragment() {
+        let clock = NimoTestClock(), connection = NSObject(), characteristic = NSObject()
+        var bytes: [Data] = [], failures: [String] = []
+        let queue = NimoWriteQueue<NSObject>(schedule: clock.schedule, write: { _, data in bytes.append(data); return true }, failure: { failures.append($0) })
+        queue.connected(connection)
+        queue.enqueue(connection, characteristic: characteristic, frames: [Data([1]), Data([2])])
+        clock.advance(3)
+        XCTAssertEqual(bytes, [Data([1])]); XCTAssertEqual(failures, ["GATT write timed out"])
+        queue.written(connection, characteristic: characteristic, success: true)
+        clock.advance(1)
+        XCTAssertEqual(bytes.count, 1)
+    }
+
+    func testQueueRejectsOldPeripheralAndCharacteristicAndPacesWrites() {
+        let clock = NimoTestClock(), old = NSObject(), current = NSObject(), characteristic = NSObject()
+        var count = 0, completed = 0
+        let queue = NimoWriteQueue<NSObject>(schedule: clock.schedule, write: { _, _ in count += 1; return true }, failure: { XCTFail($0) })
+        queue.connected(old)
+        queue.enqueue(old, characteristic: characteristic, frames: [Data([0])])
+        queue.connected(current)
+        queue.enqueue(current, characteristic: characteristic, frames: [Data([1]), Data([2])], completed: { completed += 1 })
+        queue.written(old, characteristic: characteristic, success: true)
+        queue.written(current, characteristic: NSObject(), success: true)
+        clock.advance(0.01)
+        XCTAssertEqual(count, 2)
+        queue.written(current, characteristic: characteristic, success: true)
+        clock.advance(0.004)
+        XCTAssertEqual(count, 2)
+        clock.advance(0.001)
+        XCTAssertEqual(count, 3)
+        queue.written(current, characteristic: characteristic, success: true)
+        clock.advance(0.005)
+        XCTAssertEqual(completed, 1)
+        clock.advance(10)
+    }
+
+    func testGattErrorAbortsRemainingChain() {
+        let clock = NimoTestClock(), connection = NSObject(), characteristic = NSObject()
+        var count = 0, failures = 0
+        let queue = NimoWriteQueue<NSObject>(schedule: clock.schedule, write: { _, _ in count += 1; return true }, failure: { _ in failures += 1 })
+        queue.connected(connection)
+        queue.enqueue(connection, characteristic: characteristic, frames: [Data([1]), Data([2])])
+        queue.written(connection, characteristic: characteristic, success: false)
+        clock.advance(4)
+        XCTAssertEqual(count, 1); XCTAssertEqual(failures, 1)
+    }
+
+    func testLatestOnlyEncoderAndExitFenceRunningResults() {
+        let main = NimoTestClock(), worker = NimoTestClock()
+        var delivered: [Data] = [], encoded = 0
+        let encoder = NimoCanvasEncoder(main: main.schedule, worker: worker.schedule, failure: { XCTFail("\($0)") })
+        encoder.submit(encode: { encoded += 1; return Data([1]) }, deliver: { delivered.append($0) })
+        encoder.submit(encode: { encoded += 1; return Data([2]) }, deliver: { delivered.append($0) })
+        worker.advance()
+        XCTAssertEqual(encoded, 1)
+        encoder.invalidate() // Exit/disconnect while the finished encode awaits Main.
+        main.advance()
+        XCTAssertTrue(delivered.isEmpty)
+        encoder.submit(encode: { Data([3]) }, deliver: { delivered.append($0) })
+        worker.advance(); main.advance()
+        XCTAssertEqual(delivered, [Data([3])])
+    }
+
+    func testCompleteSceneThroughWriteQueueAndBusinessAcks() throws {
+        let clock = NimoTestClock(), connection = NSObject(), characteristic = NSObject()
+        var written: [Data] = []
+        let queue = NimoWriteQueue<NSObject>(schedule: clock.schedule, write: { _, data in written.append(data); return true }, failure: { XCTFail($0) })
+        queue.connected(connection)
+        let canvas = NimoCanvasCoordinator(schedule: clock.schedule, writeCapacity: { 20 }, enqueue: { frames, started, completed in
+            queue.enqueue(connection, characteristic: characteristic, frames: frames, finalStarted: started, completed: completed)
+        }, reconnect: { XCTFail($0) }, rejected: { XCTFail("Rejected \($0)") })
+        let content = try NimoCanvasCodec.replace([NimoCanvasCodec.label("Captions", 0, 0, 500, 20)])
+        canvas.offer(content, scope: "captions:1"); canvas.readiness(true)
+        queue.written(connection, characteristic: characteristic, success: true); clock.advance(0.005)
+        let launchAck = Data([0, 0xFD])
+        canvas.response(key: 1, payload: launchAck)
+        let expected = try NimoCanvasCodec.frames(key: 4, content: content, writeCapacity: 20)
+        for _ in expected {
+            queue.written(connection, characteristic: characteristic, success: true); clock.advance(0.005)
+        }
+        XCTAssertEqual(Array(written.dropFirst()), expected)
+        canvas.response(key: 4, payload: Data([0, 0xFD, 0, 0, 0]))
+        canvas.offer(content, scope: "captions:1")
+        XCTAssertEqual(written.count, expected.count + 1)
+        canvas.disconnected(); queue.reset()
+    }
+}

package/ios/Tests/NimoDeviceCommandsTests.swift

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