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

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.193"
-    static let releaseSetId = "mentra-3.2.0-dev.193"
-    static let sourceCommit = "ca3b4bd4109d80253a3369cbf1ca8f9e86236fba"
-    static let otaManifestUrl = "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.193.json"
-    static let otaManifestSha256 = "b5201e1a9d926df220adfbf26cba934948d3f09ed81453c3600770a7618dd997"
+    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.
@@ -191,6 +202,7 @@ public final class MentraBluetoothSDK {
     private var bluetoothAvailabilityListenerId: UUID?
     private var shouldRestoreGlassesOnBluetoothRestore = false
     private var shouldRestoreControllerOnBluetoothRestore = false
+    private var requiresAncsForBluetoothRestore = true
     private var bridgeEventSinkId: String?
     private var storeListenerId: String?
     private let defaultDeviceKeys: Set<String> = ["default_wearable", "device_name", "device_address", "project_name"]
@@ -218,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) {
@@ -408,6 +420,9 @@ public final class MentraBluetoothSDK {
             try BluetoothAvailability.shared.requirePoweredOn(operation: "connect to glasses")
         }
         let isController = ControllerTypes.ALL.contains(device.model.deviceType)
+        if !isController {
+            requiresAncsForBluetoothRestore = options.requiresAncs
+        }
         if options.cancelExistingConnectionAttempt {
             if isController {
                 DeviceManager.shared.disconnectController()
@@ -427,11 +442,12 @@ public final class MentraBluetoothSDK {
             )
         }
         DeviceStore.shared.apply(ObservableStore.bluetoothCategory, "pending_wearable", device.model.deviceType)
-        DeviceManager.shared.connectByName(device.name)
+        DeviceManager.shared.connectByName(device.name, requiresAncs: options.requiresAncs)
     }
 
     public func connectDefault(options: ConnectOptions = ConnectOptions()) throws {
         clearBluetoothRestoreIntent()
+        requiresAncsForBluetoothRestore = options.requiresAncs
         guard let device = currentDefaultDevice() else {
             throw BluetoothSdkError(
                 code: "default_device_missing",
@@ -444,7 +460,7 @@ public final class MentraBluetoothSDK {
         if options.cancelExistingConnectionAttempt {
             cancelConnectionAttempt()
         }
-        DeviceManager.shared.connectDefault()
+        DeviceManager.shared.connectDefault(requiresAncs: options.requiresAncs)
     }
 
     public func cancelConnectionAttempt() {
@@ -1237,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
@@ -1552,7 +1570,9 @@ public final class MentraBluetoothSDK {
         clearBluetoothRestoreIntent()
 
         if restoreGlasses, !glassesStatus.connected, glassesStatus.connectionState == .disconnected {
-            DeviceManager.shared.connectDefault() // also restores the controller
+            DeviceManager.shared.connectDefault(
+                requiresAncs: requiresAncsForBluetoothRestore
+            ) // also restores the controller
         } else if restoreController, !glassesStatus.controllerConnected {
             DeviceManager.shared.connectDefaultController()
         }
@@ -2168,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":
@@ -2300,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

@@ -1384,6 +1384,17 @@ enum MentraLiveConnectionState {
     case connected
 }
 
+enum MentraLiveConnectionOptions {
+    static func coreBluetoothOptions(requiresAncs: Bool) -> [String: Any]? {
+        #if os(macOS)
+            return nil
+        #else
+            guard requiresAncs else { return nil }
+            return [CBConnectPeripheralOptionRequiresANCS: true]
+        #endif
+    }
+}
+
 /// Type aliases for compatibility
 typealias JSONObject = [String: Any]
 
@@ -1743,6 +1754,7 @@ class MentraLive: NSObject, SGCManager {
 
     private var connectionTimeoutTimer: Timer?
     private var reconnectionWorkItem: DispatchWorkItem?
+    private var requiresAncs = true
 
     // MARK: - Initialization
 
@@ -1775,6 +1787,10 @@ class MentraLive: NSObject, SGCManager {
         destroy()
     }
 
+    func setRequiresAncs(_ requiresAncs: Bool) {
+        self.requiresAncs = requiresAncs
+    }
+
     // MARK: - React Native Interface
 
     private var discoveredPeripherals = [String: CBPeripheral]() // name -> peripheral
@@ -2448,11 +2464,12 @@ class MentraLive: NSObject, SGCManager {
         centralManager?.connect(peripheral, options: nil)
         #else
         // ANCS is hosted by iOS and is only exposed to authorized accessories.
-        // Requiring it at connect time lets the system complete that authorization
-        // flow before the glasses subscribe to the ANCS characteristics.
+        // The default requirement lets the system complete that authorization flow
+        // before the glasses subscribe; apps that do not relay notifications can opt out.
+        Bridge.log("LIVE: ANCS connection requirement \(requiresAncs ? "enabled" : "disabled")")
         centralManager?.connect(
             peripheral,
-            options: [CBConnectPeripheralOptionRequiresANCS: true]
+            options: MentraLiveConnectionOptions.coreBluetoothOptions(requiresAncs: requiresAncs)
         )
         #endif
     }
@@ -3140,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)")
             }
@@ -5009,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/Source/types/DeviceModels.swift

@@ -169,9 +169,17 @@ public struct Device: Identifiable, Equatable, CustomStringConvertible {
 public struct ConnectOptions {
     public let saveAsDefault: Bool
     public let cancelExistingConnectionAttempt: Bool
+    /// Mentra Live on iOS only. Whether CoreBluetooth should require ANCS
+    /// authorization while establishing the connection.
+    public let requiresAncs: Bool
 
-    public init(saveAsDefault: Bool = true, cancelExistingConnectionAttempt: Bool = true) {
+    public init(
+        saveAsDefault: Bool = true,
+        cancelExistingConnectionAttempt: Bool = true,
+        requiresAncs: Bool = true
+    ) {
         self.saveAsDefault = saveAsDefault
         self.cancelExistingConnectionAttempt = cancelExistingConnectionAttempt
+        self.requiresAncs = requiresAncs
     }
 }

package/ios/Tests/MentraLiveConnectionOptionsTests.swift

@@ -0,0 +1,30 @@
+import CoreBluetooth
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class MentraLiveConnectionOptionsTests: XCTestCase {
+    func testConnectOptionsRequireAncsByDefault() {
+        XCTAssertTrue(ConnectOptions().requiresAncs)
+    }
+
+    func testConnectOptionsCanDisableAncsRequirement() {
+        XCTAssertFalse(ConnectOptions(requiresAncs: false).requiresAncs)
+    }
+
+    #if os(macOS)
+        func testCoreBluetoothOptionsOmitAncsOnMacOS() {
+            XCTAssertNil(MentraLiveConnectionOptions.coreBluetoothOptions(requiresAncs: true))
+        }
+    #else
+        func testCoreBluetoothOptionsRequireAncsWhenEnabled() {
+            let options = MentraLiveConnectionOptions.coreBluetoothOptions(requiresAncs: true)
+
+            XCTAssertEqual(options?.count, 1)
+            XCTAssertEqual(options?[CBConnectPeripheralOptionRequiresANCS] as? Bool, true)
+        }
+    #endif
+
+    func testCoreBluetoothOptionsAreOmittedWhenAncsIsDisabled() {
+        XCTAssertNil(MentraLiveConnectionOptions.coreBluetoothOptions(requiresAncs: false))
+    }
+}

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/bluetooth-sdk",
-  "version": "3.2.0-dev.193",
+  "version": "3.2.0-dev.200",
   "description": "SDK for communicating with smart glasses",
   "main": "build/index.js",
   "react-native": "src/index.ts",

package/src/BluetoothSdk.types.ts

@@ -1485,6 +1485,13 @@ export interface Device {
 export interface ConnectOptions {
   saveAsDefault?: boolean
   cancelExistingConnectionAttempt?: boolean
+  /**
+   * iOS Mentra Live only. When true, CoreBluetooth requires ANCS authorization
+   * as part of the connection. Set false when the app does not use notification
+   * relay and must avoid the system ANCS authorization flow. Defaults to true.
+   * Android accepts this option as a no-op.
+   */
+  requiresAncs?: boolean
 }
 
 export type ScanResultsCallback = (devices: Device[]) => void

package/src/_private/BluetoothSdkModule.ts

@@ -295,6 +295,7 @@ installNativeLogConsole(NativeBluetoothSdkModule, Platform.OS)
 const DEFAULT_CONNECT_OPTIONS: Required<ConnectOptions> = {
   saveAsDefault: true,
   cancelExistingConnectionAttempt: true,
+  requiresAncs: true,
 }
 
 const DEFAULT_SCAN_TIMEOUT_MS = 15_000

package/src/generated/releaseMetadata.ts

@@ -12,9 +12,9 @@ export interface BluetoothSdkReleaseMetadata {
 export const BLUETOOTH_SDK_RELEASE_METADATA: Readonly<BluetoothSdkReleaseMetadata> = Object.freeze({
   "schemaVersion": 1,
   "familyBaseVersion": "3.2.0",
-  "releaseIdentity": "3.2.0-dev.193",
-  "releaseSetId": "mentra-3.2.0-dev.193",
-  "sourceCommit": "ca3b4bd4109d80253a3369cbf1ca8f9e86236fba",
-  "otaManifestUrl": "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.193.json",
-  "otaManifestSha256": "b5201e1a9d926df220adfbf26cba934948d3f09ed81453c3600770a7618dd997"
+  "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"
 })