@mentra/bluetooth-sdk 3.2.0-dev.195 → 3.2.0-dev.200

package/android/src/test/java/com/mentra/bluetoothsdk/sgcs/MentraLiveGattLifecycleTest.kt

@@ -0,0 +1,112 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class MentraLiveGattLifecycleTest {
+    @Test
+    fun `replacement connection waits for disconnect completion`() {
+        val barrier = MentraLiveGattTeardownBarrier()
+        val events = mutableListOf<String>()
+        val teardown = barrier.beginTeardown()
+
+        barrier.runWhenIdle { events.add("connect") }
+        assertEquals(emptyList<String>(), events)
+
+        events.add("disconnect")
+        barrier.completeTeardown(teardown)
+
+        assertEquals(listOf("disconnect", "connect"), events)
+    }
+
+    @Test
+    fun `all active teardowns must finish before connections resume`() {
+        val barrier = MentraLiveGattTeardownBarrier()
+        val events = mutableListOf<String>()
+        val first = barrier.beginTeardown()
+        val second = barrier.beginTeardown()
+
+        barrier.runWhenIdle { events.add("connect") }
+        barrier.completeTeardown(first)
+        assertTrue(events.isEmpty())
+
+        barrier.completeTeardown(second)
+        assertEquals(listOf("connect"), events)
+    }
+
+    @Test
+    fun `newest deferred connection replaces an older retry`() {
+        val barrier = MentraLiveGattTeardownBarrier()
+        val events = mutableListOf<String>()
+        val teardown = barrier.beginTeardown()
+
+        barrier.runWhenIdle { events.add("stale reconnect") }
+        barrier.runWhenIdle { events.add("current user retry") }
+        barrier.completeTeardown(teardown)
+
+        assertEquals(listOf("current user retry"), events)
+    }
+
+    @Test
+    fun `timeout releases connection and late disconnect cannot release it twice`() {
+        val barrier = MentraLiveGattTeardownBarrier()
+        var connections = 0
+        val teardown = barrier.beginTeardown()
+
+        barrier.runWhenIdle { connections++ }
+        barrier.completeTeardown(teardown)
+        barrier.completeTeardown(teardown)
+
+        assertEquals(1, connections)
+        val connectImmediately: () -> Unit = { connections += 1 }
+        barrier.runWhenIdle(connectImmediately)
+        assertEquals(2, connections)
+    }
+
+    @Test
+    fun `admitted connection runs inline before another teardown can begin`() {
+        val barrier = MentraLiveGattTeardownBarrier()
+        val events = mutableListOf<String>()
+        barrier.runWhenIdle { events.add("connect") }
+        barrier.beginTeardown()
+        events.add("teardown")
+        assertEquals(listOf("connect", "teardown"), events)
+    }
+
+    @Test
+    fun `resumed connection can open another teardown without losing newer work`() {
+        val barrier = MentraLiveGattTeardownBarrier()
+        val first = barrier.beginTeardown()
+        var next = 0L
+        val events = mutableListOf<String>()
+        barrier.runWhenIdle {
+            next = barrier.beginTeardown()
+            barrier.runWhenIdle { events.add("next") }
+        }
+        barrier.completeTeardown(first)
+        assertTrue(events.isEmpty())
+        barrier.completeTeardown(next)
+        assertEquals(listOf("next"), events)
+    }
+
+    @Test
+    fun `mtu callback and watchdog share one completion`() {
+        val gate = MentraLiveMtuSetupGate()
+        val setup = gate.begin()
+
+        assertTrue(gate.complete(setup))
+        assertFalse(gate.complete(setup))
+    }
+
+    @Test
+    fun `cancelled mtu setup rejects a late callback`() {
+        val gate = MentraLiveMtuSetupGate()
+        val setup = gate.begin()
+
+        gate.cancel()
+
+        assertFalse(gate.complete(setup))
+    }
+}

package/build/generated/releaseMetadata.js

@@ -1,10 +1,10 @@
 export const BLUETOOTH_SDK_RELEASE_METADATA = Object.freeze({
     "schemaVersion": 1,
     "familyBaseVersion": "3.2.0",
-    "releaseIdentity": "3.2.0-dev.195",
-    "releaseSetId": "mentra-3.2.0-dev.195",
-    "sourceCommit": "321202ca96ec1852be19a7230ebcc3593fe87e54",
-    "otaManifestUrl": "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.195.json",
-    "otaManifestSha256": "70f26063b2c281b9b046965f6f6d7ca22f8b53242c6c5be02030c5a04c7115e4"
+    "releaseIdentity": "3.2.0-dev.200",
+    "releaseSetId": "mentra-3.2.0-dev.200",
+    "sourceCommit": "1cdd911f596eba7b2b2f0e9ba5655c7ff16b5362",
+    "otaManifestUrl": "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.200.json",
+    "otaManifestSha256": "f0b5cca2fa4d1d43acf5933fb4de629819d36a145a162c763f4faa27a7c8ff79"
 });
 //# sourceMappingURL=releaseMetadata.js.map

package/build/generated/releaseMetadata.js.map

@@ -1 +1 @@
-{"version":3,"file":"releaseMetadata.js","sourceRoot":"","sources":["../../src/generated/releaseMetadata.ts"],"names":[],"mappings":"AAWA,MAAM,CAAC,MAAM,8BAA8B,GAA0C,MAAM,CAAC,MAAM,CAAC;IACjG,eAAe,EAAE,CAAC;IAClB,mBAAmB,EAAE,OAAO;IAC5B,iBAAiB,EAAE,eAAe;IAClC,cAAc,EAAE,sBAAsB;IACtC,cAAc,EAAE,0CAA0C;IAC1D,gBAAgB,EAAE,wHAAwH;IAC1I,mBAAmB,EAAE,kEAAkE;CACxF,CAAC,CAAA","sourcesContent":["/** Generated by release CI. Do not edit in a release checkout. */\nexport interface BluetoothSdkReleaseMetadata {\n  schemaVersion: 1\n  familyBaseVersion: string | null\n  releaseIdentity: string | null\n  releaseSetId: string | null\n  sourceCommit: string | null\n  otaManifestUrl: string | null\n  otaManifestSha256: string | null\n}\n\nexport const BLUETOOTH_SDK_RELEASE_METADATA: Readonly<BluetoothSdkReleaseMetadata> = Object.freeze({\n  \"schemaVersion\": 1,\n  \"familyBaseVersion\": \"3.2.0\",\n  \"releaseIdentity\": \"3.2.0-dev.195\",\n  \"releaseSetId\": \"mentra-3.2.0-dev.195\",\n  \"sourceCommit\": \"321202ca96ec1852be19a7230ebcc3593fe87e54\",\n  \"otaManifestUrl\": \"https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.195.json\",\n  \"otaManifestSha256\": \"70f26063b2c281b9b046965f6f6d7ca22f8b53242c6c5be02030c5a04c7115e4\"\n})\n"]}
+{"version":3,"file":"releaseMetadata.js","sourceRoot":"","sources":["../../src/generated/releaseMetadata.ts"],"names":[],"mappings":"AAWA,MAAM,CAAC,MAAM,8BAA8B,GAA0C,MAAM,CAAC,MAAM,CAAC;IACjG,eAAe,EAAE,CAAC;IAClB,mBAAmB,EAAE,OAAO;IAC5B,iBAAiB,EAAE,eAAe;IAClC,cAAc,EAAE,sBAAsB;IACtC,cAAc,EAAE,0CAA0C;IAC1D,gBAAgB,EAAE,wHAAwH;IAC1I,mBAAmB,EAAE,kEAAkE;CACxF,CAAC,CAAA","sourcesContent":["/** Generated by release CI. Do not edit in a release checkout. */\nexport interface BluetoothSdkReleaseMetadata {\n  schemaVersion: 1\n  familyBaseVersion: string | null\n  releaseIdentity: string | null\n  releaseSetId: string | null\n  sourceCommit: string | null\n  otaManifestUrl: string | null\n  otaManifestSha256: string | null\n}\n\nexport const BLUETOOTH_SDK_RELEASE_METADATA: Readonly<BluetoothSdkReleaseMetadata> = Object.freeze({\n  \"schemaVersion\": 1,\n  \"familyBaseVersion\": \"3.2.0\",\n  \"releaseIdentity\": \"3.2.0-dev.200\",\n  \"releaseSetId\": \"mentra-3.2.0-dev.200\",\n  \"sourceCommit\": \"1cdd911f596eba7b2b2f0e9ba5655c7ff16b5362\",\n  \"otaManifestUrl\": \"https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.200.json\",\n  \"otaManifestSha256\": \"f0b5cca2fa4d1d43acf5933fb4de629819d36a145a162c763f4faa27a7c8ff79\"\n})\n"]}

package/ios/Source/BluetoothSdkDefaults.swift

@@ -11,7 +11,7 @@ enum BluetoothSdkDefaults {
     static let voiceActivityDetectionEnabled = false
     static let loudnessGateEnabled = false
     private static let infoSdkVersionKey = "MentraBluetoothSdkVersion"
-    private static let swiftPackageSdkVersion = "3.2.0-dev.195"
+    private static let swiftPackageSdkVersion = "3.2.0-dev.200"
     private static let swiftPackageSdkVersionPlaceholder = "__MENTRA" + "_BLUETOOTH_SDK_VERSION__"
 
     private static func normalizedSdkVersion(_ value: String?) -> String? {

package/ios/Source/Bridge.swift

@@ -366,9 +366,10 @@ class Bridge {
         Bridge.sendTypedMessage(type, body: body)
     }
 
-    static func sendVersionInfo(_ values: [String: Any]) {
+    static func sendVersionInfo(_ values: [String: Any], responseChunk: String = "version_info") {
         var body: [String: Any] = [
             "type": "version_info",
+            VersionInfoResponseAccumulator.responseChunkKey: responseChunk,
             "androidVersion": stringValue(values, "androidVersion", "android_version") ?? "",
             "firmwareVersion": stringValue(values, "firmwareVersion", "firmware_version") ?? "",
             "besFirmwareVersion": stringValue(values, "besFirmwareVersion", "bes_fw_version") ?? "",
@@ -377,6 +378,19 @@ class Bridge {
             "otaVersionUrl": stringValue(values, "otaVersionUrl", "ota_version_url") ?? "",
             "appVersion": stringValue(values, "appVersion", "app_version") ?? "",
         ]
+        for (wireKey, internalKey) in [
+            "chunkIndex": VersionInfoResponseAccumulator.responseIndexKey,
+            "chunkCount": VersionInfoResponseAccumulator.responseCountKey,
+            "final": VersionInfoResponseAccumulator.responseFinalKey,
+            "sid": VersionInfoResponseAccumulator.responseSidKey,
+        ] {
+            body[internalKey] = values[wireKey]
+        }
+        if let responseRequestId = stringValue(values, "requestId", "request_id"),
+           !responseRequestId.isEmpty
+        {
+            body[VersionInfoResponseAccumulator.responseRequestIdKey] = responseRequestId
+        }
         if let systemTimeMs = intValue(values["systemTimeMs"]) ?? intValue(values["system_time_ms"]) {
             body["systemTimeMs"] = systemTimeMs
         }

package/ios/Source/DeviceManager.swift

@@ -1032,7 +1032,7 @@ struct ViewState {
 
         let connectionKey = "\(sgc.type):\(deviceName)"
         syncSystemTimeOnceForConnection(sgc, connectionKey: connectionKey)
-        
+
         // re-apply display height/depth after reconnection
         DispatchQueue.main.asyncAfter(deadline: .now() + 2) { [weak self] in
             // Re-read the current sgc rather than capturing the connect-time instance: the user may
@@ -1682,9 +1682,13 @@ struct ViewState {
 
     /// Request version info from glasses.
     /// Glasses will respond with version_info message containing build number, firmware version, etc.
-    func requestVersionInfo() {
+    func requestVersionInfo(requestId: String? = nil) {
         Bridge.log("MAN: 📱 Requesting version info from glasses")
-        sgc?.requestVersionInfo()
+        if let live = sgc as? MentraLive {
+            live.requestVersionInfo(requestId: requestId)
+        } else {
+            sgc?.requestVersionInfo()
+        }
     }
 
     /// Send shutdown command to glasses.

package/ios/Source/GeneratedReleaseMetadata.swift

@@ -3,9 +3,9 @@ import Foundation
 /// Generated by release CI. Do not edit in a release checkout.
 enum GeneratedReleaseMetadata {
     static let familyBaseVersion = "3.2.0"
-    static let releaseIdentity = "3.2.0-dev.195"
-    static let releaseSetId = "mentra-3.2.0-dev.195"
-    static let sourceCommit = "321202ca96ec1852be19a7230ebcc3593fe87e54"
-    static let otaManifestUrl = "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.195.json"
-    static let otaManifestSha256 = "70f26063b2c281b9b046965f6f6d7ca22f8b53242c6c5be02030c5a04c7115e4"
+    static let releaseIdentity = "3.2.0-dev.200"
+    static let releaseSetId = "mentra-3.2.0-dev.200"
+    static let sourceCommit = "1cdd911f596eba7b2b2f0e9ba5655c7ff16b5362"
+    static let otaManifestUrl = "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.200.json"
+    static let otaManifestSha256 = "f0b5cca2fa4d1d43acf5933fb4de629819d36a145a162c763f4faa27a7c8ff79"
 }

package/ios/Source/MentraBluetoothSDK.swift

@@ -101,6 +101,17 @@ private final class PendingVideoRecordingRequest {
     }
 }
 
+@MainActor
+private final class PendingVersionInfoRequest {
+    let pending: PendingResponse<VersionInfoResult>
+    let accumulator: VersionInfoResponseAccumulator
+
+    init(pending: PendingResponse<VersionInfoResult>, requestId: String) {
+        self.pending = pending
+        accumulator = VersionInfoResponseAccumulator(expectedRequestId: requestId)
+    }
+}
+
 // seq records send order (assigned and handed to the BLE queue in a single
 // MainActor turn) so that an id-carrying status for a newer start can
 // identify which older in-flight starts it preempted.
@@ -219,7 +230,7 @@ public final class MentraBluetoothSDK {
     private var wifiScanTask: Task<[WifiScanResult], Error>?
     private var pendingWifiStatus: PendingWifiStatusRequest?
     private var pendingHotspotStatus: PendingHotspotStatusRequest?
-    private var pendingVersionInfo: PendingResponse<VersionInfoResult>?
+    private var pendingVersionInfo: PendingVersionInfoRequest?
     private var configuredOtaVersionUrl: String?
 
     public init(configuration: MentraBluetoothSDKConfiguration = .default) {
@@ -1242,17 +1253,19 @@ public final class MentraBluetoothSDK {
                 message: "A version info request is already waiting for a glasses response."
             )
         }
+        let requestId = UUID().uuidString
         let pending = PendingResponse<VersionInfoResult>(operation: "version info request")
-        pendingVersionInfo = pending
-        DeviceManager.shared.requestVersionInfo()
+        let request = PendingVersionInfoRequest(pending: pending, requestId: requestId)
+        pendingVersionInfo = request
+        DeviceManager.shared.requestVersionInfo(requestId: requestId)
         do {
             let status = try await pending.wait()
-            if pendingVersionInfo === pending {
+            if pendingVersionInfo === request {
                 pendingVersionInfo = nil
             }
             return status
         } catch {
-            if pendingVersionInfo === pending {
+            if pendingVersionInfo === request {
                 pendingVersionInfo = nil
             }
             throw error
@@ -2175,6 +2188,19 @@ private func dispatchDiscoveredDevices(_ rawSearchResults: Any?) {
         activeSession.onComplete(activeSession.latestResults)
     }
 
+    private func handleVersionInfoForRequest(_ data: [String: Any]) {
+        guard let request = pendingVersionInfo else { return }
+        switch request.accumulator.accept(data) {
+        case .ignored:
+            break
+        case .waiting:
+            break
+        case let .complete(result):
+            pendingVersionInfo = nil
+            request.pending.resolve(result)
+        }
+    }
+
     private func dispatchBridgeEvent(_ eventName: String, _ data: [String: Any]) {
         switch eventName {
         case "log":
@@ -2307,7 +2333,7 @@ private func dispatchDiscoveredDevices(_ rawSearchResults: Any?) {
             delegate?.mentraBluetoothSDK(self, didReceive: .settingsAck(event))
         case "version_info":
             let event = VersionInfoResult(values: data)
-            pendingVersionInfo?.resolve(event)
+            handleVersionInfoForRequest(data)
             delegate?.mentraBluetoothSDK(self, didReceive: .versionInfo(event))
         case "compatible_glasses_search_stop":
             delegate?.mentraBluetoothSDK(self, didStopScan: .completed)

package/ios/Source/requests/VersionInfoResponseAccumulator.swift

@@ -0,0 +1,101 @@
+import CoreFoundation
+import Foundation
+
+enum VersionInfoAccumulatorOutcome {
+    case ignored
+    case waiting
+    case complete(VersionInfoResult)
+}
+
+/// One request, explicit modern completion, or the deployed legacy chunk-3 terminal boundary.
+final class VersionInfoResponseAccumulator {
+    static let responseChunkKey = "_responseChunk"
+    static let responseRequestIdKey = "_responseRequestId"
+    static let responseIndexKey = "_responseChunkIndex"
+    static let responseCountKey = "_responseChunkCount"
+    static let responseFinalKey = "_responseFinal"
+    static let responseSidKey = "_responseSid"
+    private static let modernKeys = [responseRequestIdKey, responseIndexKey, responseCountKey, responseFinalKey]
+
+    private let expectedRequestId: String
+    private var values: [String: Any] = [:]
+    private var chunks: [Int: [String: Any]] = [:]
+    private var count: Int?
+    private var sid: String?
+    private var legacyStarted = false
+    private var completed = false
+
+    init(expectedRequestId: String) {
+        self.expectedRequestId = expectedRequestId
+    }
+
+    func accept(_ event: [String: Any]) -> VersionInfoAccumulatorOutcome {
+        guard !completed else { return .ignored }
+        if Self.modernKeys.contains(where: { event[$0] != nil }) {
+            guard event[Self.responseRequestIdKey] as? String == expectedRequestId,
+                  let index = integer(event[Self.responseIndexKey]),
+                  let total = integer(event[Self.responseCountKey]),
+                  let final = event[Self.responseFinalKey] as? NSNumber,
+                  CFGetTypeID(final) == CFBooleanGetTypeID(),
+                  let process = event[Self.responseSidKey] as? String, !process.isEmpty,
+                  (1 ... 16).contains(total), (1 ... total).contains(index),
+                  final.boolValue == (index == total)
+            else { return .ignored }
+            if let count, count != total || sid != process { return .ignored }
+            if count == nil {
+                values.removeAll()
+                count = total
+                sid = process
+            }
+            chunks[index] = event
+            guard chunks.count == total else { return .waiting }
+            for index in 1 ... total {
+                merge(chunks[index]!)
+            }
+            return finish()
+        }
+        guard count == nil else { return .ignored }
+        switch event[Self.responseChunkKey] as? String ?? "version_info" {
+        case "version_info":
+            values.removeAll()
+            merge(event)
+            return finish()
+        case "version_info_1":
+            values.removeAll()
+            legacyStarted = true
+            merge(event)
+        case "version_info_2":
+            guard legacyStarted else { return .ignored }
+            merge(event)
+        case "version_info_3":
+            guard legacyStarted else { return .ignored }
+            merge(event)
+            return finish()
+        default: return .ignored
+        }
+        // Silence is never evidence of completion. The request's normal deadline handles loss.
+        return .waiting
+    }
+
+    private func finish() -> VersionInfoAccumulatorOutcome {
+        completed = true
+        return .complete(VersionInfoResult(values: values))
+    }
+
+    private func merge(_ event: [String: Any]) {
+        for (key, value) in event where !key.hasPrefix("_response") && key != "type" {
+            if let string = value as? String, string.isEmpty { continue }
+            values[key] = value
+        }
+    }
+
+    private func integer(_ value: Any?) -> Int? {
+        guard let number = value as? NSNumber,
+              CFGetTypeID(number) != CFBooleanGetTypeID(),
+              number.doubleValue.isFinite,
+              number.doubleValue >= 1, number.doubleValue <= 16,
+              number.doubleValue == Double(number.intValue)
+        else { return nil }
+        return number.intValue
+    }
+}

package/ios/Source/sgcs/MentraLive.swift

@@ -3157,7 +3157,7 @@ class MentraLive: NSObject, SGCManager {
                 maybeSendWireHandshake()
                 handleGlassesSessionId(json)
 
-                Bridge.sendVersionInfo(fields)
+                Bridge.sendVersionInfo(fields, responseChunk: type)
             } else {
                 Bridge.log("Unhandled message type: \(type)")
             }
@@ -5026,7 +5026,14 @@ class MentraLive: NSObject, SGCManager {
     }
 
     func requestVersionInfo() {
-        let json: [String: Any] = ["type": "request_version"]
+        requestVersionInfo(requestId: nil)
+    }
+
+    func requestVersionInfo(requestId: String?) {
+        var json: [String: Any] = ["type": "request_version"]
+        if let requestId {
+            json["request_id"] = requestId
+        }
         sendJson(json)
     }
 

package/ios/Source/status/DeviceStatus.swift

@@ -420,9 +420,8 @@ public struct VersionInfoResult: CustomStringConvertible {
         if let systemTimeMs {
             values["systemTimeMs"] = systemTimeMs
         }
-        // Only when known. requestVersionInfo() resolves from ANY version_info chunk, and only
-        // chunk 1 carries package_name — emitting "" from a chunk-3 resolution would overwrite a
-        // known identity with "absent", which the OTA guard reads as stock.
+        // Only when known: per-chunk events may omit package identity. Emitting an empty value
+        // would overwrite a known identity, which the OTA guard uses to identify stock.
         if !packageName.isEmpty {
             values["packageName"] = packageName
         }

package/ios/Tests/VersionInfoBridgeTests.swift

@@ -0,0 +1,32 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class VersionInfoBridgeTests: XCTestCase {
+    func testWireMetadataSurvivesBridgeNormalization() {
+        let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+        let delivered = expectation(description: "Both version chunks")
+        delivered.expectedFulfillmentCount = 2
+        var outcomes: [VersionInfoAccumulatorOutcome] = []
+        let sink = Bridge.addEventSink { type, body in
+            guard type == "version_info" else { return }
+            outcomes.append(accumulator.accept(body))
+            delivered.fulfill()
+        }
+        defer { Bridge.removeEventSink(sink) }
+        Bridge.sendVersionInfo([
+            "request_id": "request-1", "sid": "asg-1", "chunkCount": 2,
+            "chunkIndex": 1, "final": false, "build_number": "42",
+        ], responseChunk: "version_info_1")
+        Bridge.sendVersionInfo([
+            "request_id": "request-1", "sid": "asg-1", "chunkCount": 2,
+            "chunkIndex": 2, "final": true, "bes_fw_version": "new",
+        ], responseChunk: "version_info_3")
+        wait(for: [delivered], timeout: 2)
+        guard case .waiting = outcomes[0], case let .complete(result) = outcomes[1] else {
+            return XCTFail("Expected an explicitly complete combined response")
+        }
+        XCTAssertEqual(result.buildNumber, "42")
+        XCTAssertEqual(result.besFirmwareVersion, "new")
+        XCTAssertFalse(result.dictionary.keys.contains { $0.hasPrefix("_response") })
+    }
+}

package/ios/Tests/VersionInfoResponseAccumulatorTests.swift

@@ -0,0 +1,181 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class VersionInfoResponseAccumulatorTests: XCTestCase {
+    func testMergesCurrentChunksAndCompletesOnFirmwareChunk() {
+        let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+
+        guard case .waiting = accumulator.accept(
+            chunk("version_info_1", "request-1", ["buildNumber": "42"])
+        )
+        else {
+            return XCTFail("Expected first chunk to wait")
+        }
+
+        let outcome = accumulator.accept(
+            chunk(
+                "version_info_3",
+                "request-1",
+                [
+                    "buildNumber": "",
+                    "besFirmwareVersion": "26.8.27.0",
+                    "mtkFirmwareVersion": "MentraLive_20260709",
+                ]
+            )
+        )
+        guard case let .complete(result) = outcome else {
+            return XCTFail("Expected final chunk to complete")
+        }
+
+        XCTAssertEqual(result.buildNumber, "42")
+        XCTAssertEqual(result.besFirmwareVersion, "26.8.27.0")
+        XCTAssertEqual(result.mtkFirmwareVersion, "MentraLive_20260709")
+    }
+
+    func testIgnoresMismatchedAndTrailingStaleChunks() {
+        let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+
+        guard case .ignored = accumulator.accept(chunk("version_info_1", "other", ["buildNumber": "old"]))
+        else {
+            return XCTFail("Expected mismatched response to be ignored")
+        }
+        guard case .ignored = accumulator.accept(chunk("version_info_3", nil, ["besFirmwareVersion": "stale"]))
+        else {
+            return XCTFail("Expected stale trailing chunk to be ignored")
+        }
+    }
+
+    func testDoesNotMixCorrelatedAndUncorrelatedSequences() {
+        let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+        _ = accumulator.accept(chunk("version_info_1", "request-1", ["buildNumber": "42"]))
+
+        guard case .ignored = accumulator.accept(
+            chunk("version_info_3", nil, ["besFirmwareVersion": "stale"])
+        ) else {
+            return XCTFail("Expected uncorrelated trailing chunk to be ignored")
+        }
+
+        let outcome = accumulator.accept(
+            chunk("version_info_3", "request-1", ["besFirmwareVersion": "current"])
+        )
+        guard case let .complete(result) = outcome else {
+            return XCTFail("Expected correlated final chunk to complete")
+        }
+        XCTAssertEqual(result.besFirmwareVersion, "current")
+    }
+
+    func testStaleUncorrelatedResponsesCannotReplaceCorrelatedSequence() {
+        let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+        _ = accumulator.accept(chunk("version_info_1", "request-1", ["buildNumber": "42"]))
+
+        guard case .ignored = accumulator.accept(chunk("version_info_1", nil, ["buildNumber": "stale"]))
+        else {
+            return XCTFail("Expected stale first chunk to be ignored")
+        }
+        guard case .ignored = accumulator.accept(chunk("version_info", nil, ["buildNumber": "legacy"]))
+        else {
+            return XCTFail("Expected stale legacy response to be ignored")
+        }
+
+        let outcome = accumulator.accept(
+            chunk("version_info_3", "request-1", ["besFirmwareVersion": "current"])
+        )
+        guard case let .complete(result) = outcome else {
+            return XCTFail("Expected correlated final chunk to complete")
+        }
+        XCTAssertEqual(result.buildNumber, "42")
+        XCTAssertEqual(result.besFirmwareVersion, "current")
+    }
+
+    func testRepeatedFirstChunkResetsRatherThanMixingResponses() {
+        let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+        _ = accumulator.accept(chunk("version_info_1", nil, ["appVersion": "old"]))
+        _ = accumulator.accept(chunk("version_info_1", nil, ["buildNumber": "43"]))
+
+        guard case let .complete(result) = accumulator.accept(
+            chunk("version_info_3", nil, ["besFirmwareVersion": "new"])
+        ) else { return XCTFail("Legacy final chunk must complete immediately") }
+        XCTAssertEqual(result.appVersion, "")
+        XCTAssertEqual(result.buildNumber, "43")
+        XCTAssertEqual(result.besFirmwareVersion, "new")
+    }
+
+    func testLegacySingleMessageCompletesImmediately() {
+        let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+
+        let outcome = accumulator.accept(chunk("version_info", nil, ["buildNumber": "7"]))
+        guard case let .complete(result) = outcome else {
+            return XCTFail("Expected legacy response to complete")
+        }
+        XCTAssertEqual(result.buildNumber, "7")
+    }
+
+    func testLegacyFirstChunkDoesNotComplete() {
+        let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+        guard case .waiting = accumulator.accept(chunk("version_info_1", nil, ["buildNumber": "8"])) else {
+            return XCTFail("Partial response must wait for final chunk or deadline")
+        }
+    }
+
+    func testModernFinalChunkWaitsForMissingFirstChunk() {
+        let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+        guard case .waiting = accumulator.accept(chunk("version_info_3", "request-1", ["besFirmwareVersion": "new"])) else {
+            return XCTFail("Missing first chunk")
+        }
+        guard case let .complete(result) = accumulator.accept(chunk("version_info_1", "request-1", ["buildNumber": "42"])) else {
+            return XCTFail("Both chunks arrived")
+        }
+        XCTAssertEqual(result.buildNumber, "42")
+        XCTAssertEqual(result.besFirmwareVersion, "new")
+    }
+
+    func testDuplicateDoesNotCountAsMissingChunk() {
+        let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+        let first = chunk("version_info_1", "request-1", ["buildNumber": "42"])
+        _ = accumulator.accept(first)
+        guard case .waiting = accumulator.accept(first) else { return XCTFail("Duplicate is not completion") }
+    }
+
+    func testRejectsMalformedModernMetadataAndMixedProcess() {
+        let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+        let first = chunk("version_info_1", "request-1", ["buildNumber": "42"])
+        for (key, value) in [
+            VersionInfoResponseAccumulator.responseCountKey: 2.5,
+            VersionInfoResponseAccumulator.responseIndexKey: true,
+            VersionInfoResponseAccumulator.responseFinalKey: true,
+            VersionInfoResponseAccumulator.responseRequestIdKey: "",
+        ] as [String: Any] {
+            var invalid = first
+            invalid[key] = value
+            guard case .ignored = accumulator.accept(invalid) else { return XCTFail("Invalid " + key) }
+        }
+        _ = accumulator.accept(first)
+        let last = chunk("version_info_3", "request-1", ["besFirmwareVersion": "new"])
+        var restarted = last
+        restarted[VersionInfoResponseAccumulator.responseSidKey] = "process-2"
+        guard case .ignored = accumulator.accept(restarted) else { return XCTFail("Mixed process") }
+        guard case .complete = accumulator.accept(last) else { return XCTFail("Matching final chunk") }
+    }
+
+    func testCorrelatedResponseWithoutCompletenessMetadataCannotComplete() {
+        let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+        let event: [String: Any] = [
+            VersionInfoResponseAccumulator.responseChunkKey: "version_info_3",
+            VersionInfoResponseAccumulator.responseRequestIdKey: "request-1",
+        ]
+        guard case .ignored = accumulator.accept(event) else { return XCTFail("Incomplete modern metadata") }
+    }
+
+    private func chunk(_ type: String, _ requestId: String?, _ values: [String: Any]) -> [String: Any] {
+        var event = values
+        event[VersionInfoResponseAccumulator.responseChunkKey] = type
+        if let requestId {
+            event[VersionInfoResponseAccumulator.responseRequestIdKey] = requestId
+            event[VersionInfoResponseAccumulator.responseIndexKey] = type == "version_info_1" ? 1 : 2
+            event[VersionInfoResponseAccumulator.responseCountKey] = 2
+            event[VersionInfoResponseAccumulator.responseFinalKey] = type == "version_info_3"
+            event[VersionInfoResponseAccumulator.responseSidKey] = "process-1"
+        }
+        return event
+    }
+}