@mentra/bluetooth-sdk 3.4.0-dev.979 → 3.4.0-dev.980

package/android/src/main/java/com/mentra/bluetoothsdk/GeneratedReleaseMetadata.kt

@@ -3,9 +3,9 @@ package com.mentra.bluetoothsdk
 /** Generated by release CI. Do not edit in a release checkout. */
 internal object GeneratedReleaseMetadata {
     const val FAMILY_BASE_VERSION: String = "3.4.0"
-    const val RELEASE_IDENTITY: String = "3.4.0-dev.979"
-    const val RELEASE_SET_ID: String = "mentra-3.4.0-dev.979"
-    const val SOURCE_COMMIT: String = "cec2dff0b77fc7963d63602bba43556c690daf9d"
-    const val OTA_MANIFEST_URL: String = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.4.0/mentra-live-ota-3.4.0-dev.979.json"
-    const val OTA_MANIFEST_SHA256: String = "667fffda403d22a07c60a0029ef602c556d13ddfa4bf8161fda5f56f54f50f13"
+    const val RELEASE_IDENTITY: String = "3.4.0-dev.980"
+    const val RELEASE_SET_ID: String = "mentra-3.4.0-dev.980"
+    const val SOURCE_COMMIT: String = "d43a82b42eddeee824f4c8f003415bc65dbd5aab"
+    const val OTA_MANIFEST_URL: String = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.4.0/mentra-live-ota-3.4.0-dev.980.json"
+    const val OTA_MANIFEST_SHA256: String = "3121c2acd957c5f554b36d8260c4a3550c85bd50cee3d11a27a53b407e27b6d0"
 }

package/build/generated/releaseMetadata.js

@@ -1,10 +1,10 @@
 export const BLUETOOTH_SDK_RELEASE_METADATA = Object.freeze({
     "schemaVersion": 1,
     "familyBaseVersion": "3.4.0",
-    "releaseIdentity": "3.4.0-dev.979",
-    "releaseSetId": "mentra-3.4.0-dev.979",
-    "sourceCommit": "cec2dff0b77fc7963d63602bba43556c690daf9d",
-    "otaManifestUrl": "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.4.0/mentra-live-ota-3.4.0-dev.979.json",
-    "otaManifestSha256": "667fffda403d22a07c60a0029ef602c556d13ddfa4bf8161fda5f56f54f50f13"
+    "releaseIdentity": "3.4.0-dev.980",
+    "releaseSetId": "mentra-3.4.0-dev.980",
+    "sourceCommit": "d43a82b42eddeee824f4c8f003415bc65dbd5aab",
+    "otaManifestUrl": "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.4.0/mentra-live-ota-3.4.0-dev.980.json",
+    "otaManifestSha256": "3121c2acd957c5f554b36d8260c4a3550c85bd50cee3d11a27a53b407e27b6d0"
 });
 //# 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,iIAAiI;IACnJ,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.4.0\",\n  \"releaseIdentity\": \"3.4.0-dev.979\",\n  \"releaseSetId\": \"mentra-3.4.0-dev.979\",\n  \"sourceCommit\": \"cec2dff0b77fc7963d63602bba43556c690daf9d\",\n  \"otaManifestUrl\": \"https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.4.0/mentra-live-ota-3.4.0-dev.979.json\",\n  \"otaManifestSha256\": \"667fffda403d22a07c60a0029ef602c556d13ddfa4bf8161fda5f56f54f50f13\"\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,iIAAiI;IACnJ,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.4.0\",\n  \"releaseIdentity\": \"3.4.0-dev.980\",\n  \"releaseSetId\": \"mentra-3.4.0-dev.980\",\n  \"sourceCommit\": \"d43a82b42eddeee824f4c8f003415bc65dbd5aab\",\n  \"otaManifestUrl\": \"https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.4.0/mentra-live-ota-3.4.0-dev.980.json\",\n  \"otaManifestSha256\": \"3121c2acd957c5f554b36d8260c4a3550c85bd50cee3d11a27a53b407e27b6d0\"\n})\n"]}

package/ios/Source/BluetoothSdkDefaults.swift

@@ -16,7 +16,7 @@ enum BluetoothSdkDefaults {
     /// silently disable it on every pair the app touches.
     static let autoPowerOffEnabled = false
     private static let infoSdkVersionKey = "MentraBluetoothSdkVersion"
-    private static let swiftPackageSdkVersion = "3.4.0-dev.979"
+    private static let swiftPackageSdkVersion = "3.4.0-dev.980"
     private static let swiftPackageSdkVersionPlaceholder = "__MENTRA" + "_BLUETOOTH_SDK_VERSION__"
 
     private static func normalizedSdkVersion(_ value: String?) -> String? {

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.4.0"
-    static let releaseIdentity = "3.4.0-dev.979"
-    static let releaseSetId = "mentra-3.4.0-dev.979"
-    static let sourceCommit = "cec2dff0b77fc7963d63602bba43556c690daf9d"
-    static let otaManifestUrl = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.4.0/mentra-live-ota-3.4.0-dev.979.json"
-    static let otaManifestSha256 = "667fffda403d22a07c60a0029ef602c556d13ddfa4bf8161fda5f56f54f50f13"
+    static let releaseIdentity = "3.4.0-dev.980"
+    static let releaseSetId = "mentra-3.4.0-dev.980"
+    static let sourceCommit = "d43a82b42eddeee824f4c8f003415bc65dbd5aab"
+    static let otaManifestUrl = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.4.0/mentra-live-ota-3.4.0-dev.980.json"
+    static let otaManifestSha256 = "3121c2acd957c5f554b36d8260c4a3550c85bd50cee3d11a27a53b407e27b6d0"
 }

package/ios/Source/sgcs/NimoResourceFixture.swift

@@ -1,4 +1,5 @@
 import Foundation
+import CoreBluetooth
 
 /// One process-local authority shared by the typed Expo bridge and the Mac
 /// fixture socket. Neither accepts packets, connection addresses or file paths.
@@ -16,6 +17,14 @@ final class NimoResourceFixture {
     let process = NimoResourceProcess(pid: ProcessInfo.processInfo.processIdentifier, instanceId: UUID().uuidString.lowercased())
     private(set) var session: NimoResourceSession?
     private(set) var owner: Nimo?
+    private var acceptedPair: NimoResourceSelection?
+    private var captureNonce: String?
+    private var armedElapsedMs: UInt64?
+    private var discovery: NimoResourceConnectedDiscovery?
+    private var discoveryRequestNonce: String?
+    private var discoveryReleaseNonce: String?
+    private var discoveryReleaseStartedElapsedMs: UInt64?
+    private var discoveryCancelled = false
     private var completed: [String: (Data, Data)] = [:]
     private var pending: [String: (Data, Task<Data, Error>)] = [:]
     private var transport: NimoMacResourceTransport?
@@ -33,7 +42,16 @@ final class NimoResourceFixture {
     #else
     private let requested = false
     #endif
-    var enabled: Bool { requested }
+    #if SWIFT_PACKAGE
+    private var packageEnabled = false
+    #endif
+    var enabled: Bool {
+        #if SWIFT_PACKAGE
+        return requested || packageEnabled
+        #else
+        return requested
+        #endif
+    }
 
     func start() {
         guard enabled, transport == nil, startupError == nil else { return }
@@ -44,7 +62,7 @@ final class NimoResourceFixture {
         guard enabled else { return true }
         // A different manager can clean up the captured Nimo object. Permit it
         // only after the original resource has actually completed teardown.
-        guard wearable.contains("NIMO") else { return NimoResourceManagerState.allowsReplacement(fixtureEnabled: enabled, originalClosed: originalClosed && session?.errors.isEmpty == true && session?.connected == false) }
+        guard wearable.contains("NIMO") else { return NimoResourceManagerState.allowsReplacement(fixtureEnabled: enabled, originalClosed: originalClosed && (session == nil || session?.errors.isEmpty == true && session?.connected == false)) }
         guard let session, !session.cancelled, session.releaseNonce == nil, session.original == nil,
               name == nil || name == session.pair.name else { return false }
         return true
@@ -108,14 +126,15 @@ final class NimoResourceFixture {
         if let (original, task) = pending[request.requestNonce] {
             guard original == bytes else { throw failure("request-nonce-reused") }; return try await task.value
         }
-        if request.operation != .arm {
-            guard let session, session.captureNonce == request.captureNonce, session.pair == request.expectedPair else { throw failure("capture-mismatch") }
-            let observed = session.original ?? session.instanceId.map { NimoResourceOriginal(instanceId: $0, peripheralUuid: session.pair.peripheralUuid, sessionGeneration: 0) }
+        if request.operation != .arm && request.operation != .discover {
+            guard captureNonce == request.captureNonce, acceptedPair == request.expectedPair else { throw failure("capture-mismatch") }
+            let session = self.session
+            let observed = session?.original ?? session?.instanceId.map { NimoResourceOriginal(instanceId: $0, peripheralUuid: session!.pair.peripheralUuid, sessionGeneration: 0) }
             if let expected = request.original { guard expected == observed else { throw failure("original-session-mismatch") } }
-            if request.operation == .release, session.hasOwner, request.original == nil { throw failure("release-requires-original") }
-            if request.operation == .release, let release = session.releaseNonce, release != request.requestNonce { throw failure("original-release-nonce-required") }
+            if request.operation == .release, session?.hasOwner == true, request.original == nil { throw failure("release-requires-original") }
+            if request.operation == .release, let release = session?.releaseNonce ?? discoveryReleaseNonce, release != request.requestNonce { throw failure("original-release-nonce-required") }
         }
-        let recovery = request.operation == .release || request.operation == .cancel || session?.releaseNonce != nil
+        let recovery = request.operation == .release || request.operation == .cancel || session?.releaseNonce != nil || discoveryReleaseNonce != nil
         guard completed.count + pending.count < (recovery ? 256 : 192) else { throw failure("request-budget-exhausted") }
         // Intent is persisted before ANY capture or release mutation. No caller
         // path is used; replay compares the exact original request bytes.
@@ -140,11 +159,46 @@ final class NimoResourceFixture {
     }
 
     private func perform(_ request: NimoResourceRequest, received: UInt64) async throws -> [String: Any] {
+        if request.operation == .discover {
+            guard request.expectedPair.peripheralSelection == NimoResourceSelection.connectedService,
+                  captureNonce == nil, request.original == nil, DeviceManager.shared.sgc == nil, pendingManagerEntries == 0 else { throw failure("discover-requires-unowned-manager") }
+            acceptedPair = request.expectedPair; captureNonce = request.captureNonce; armedElapsedMs = NimoResourceClock.now()
+            let observer = NimoResourceConnectedDiscovery(name: request.expectedPair.name, startedElapsedMs: armedElapsedMs!)
+            discovery = observer; discoveryRequestNonce = request.requestNonce
+            await observer.discoverConnected()
+        }
         if request.operation == .arm {
             guard session == nil, request.original == nil, DeviceManager.shared.sgc == nil, pendingManagerEntries == 0 else { throw failure("arm-requires-unowned-manager") }
-            session = NimoResourceSession(captureNonce: request.captureNonce, pair: request.expectedPair)
+            let uuid: String
+            if let observed = request.expectedPair.peripheralUuid {
+                guard captureNonce == nil else { throw failure("capture-already-exists") }
+                acceptedPair = request.expectedPair; captureNonce = request.captureNonce
+                uuid = observed
+            } else {
+                guard captureNonce == request.captureNonce, acceptedPair == request.expectedPair,
+                      !discoveryCancelled, discoveryReleaseNonce == nil,
+                      let discoveryRequestNonce, completed[discoveryRequestNonce] != nil,
+                      let discovery, discovery.ledger.settledElapsedMs != nil, discovery.callbacksPending == 0,
+                      discovery.ledger.errors.isEmpty, let selected = discovery.ledger.selectedPeripheralUuid else { throw failure("discovery-not-admissible") }
+                uuid = selected
+            }
+            if armedElapsedMs == nil { armedElapsedMs = NimoResourceClock.now() }
+            session = NimoResourceSession(captureNonce: request.captureNonce, pair: NimoResourcePair(name: request.expectedPair.name, peripheralUuid: uuid), armedElapsedMs: armedElapsedMs!)
         }
-        guard let session, session.captureNonce == request.captureNonce, session.pair == request.expectedPair else { throw failure("capture-mismatch") }
+        guard captureNonce == request.captureNonce, acceptedPair == request.expectedPair else { throw failure("capture-mismatch") }
+        if session == nil {
+            guard request.original == nil else { throw failure("original-session-mismatch") }
+            if request.operation == .release || request.operation == .cancel {
+                if let original = discoveryReleaseNonce, request.operation == .release, original != request.requestNonce { throw failure("original-release-nonce-required") }
+                if discoveryReleaseNonce == nil {
+                    discoveryReleaseNonce = request.requestNonce; discoveryReleaseStartedElapsedMs = NimoResourceClock.now()
+                    discoveryCancelled = request.operation == .cancel
+                    await discovery?.stopDiscovery(cancel: true)
+                }
+            }
+            return discoveryOnlyReceipt(request, received: received)
+        }
+        guard let session, session.captureNonce == request.captureNonce, acceptedPair == request.expectedPair else { throw failure("capture-mismatch") }
         if let expected = request.original {
             let observed = session.original ?? session.instanceId.map { NimoResourceOriginal(instanceId: $0, peripheralUuid: session.pair.peripheralUuid, sessionGeneration: 0) }
             guard expected == observed else { throw failure("original-session-mismatch") }
@@ -171,17 +225,160 @@ final class NimoResourceFixture {
         let manager = DeviceManager.shared.sgc
         let managerId = (manager as? Nimo)?.resourceInstanceId
         let current: [String: Any] = ["type": nullable(manager?.type), "instanceId": nullable(managerId)]
-        return ["version": 1, "protocol": "nimo-macos-resource-v1", "operation": request.operation.rawValue,
+        var result: [String: Any] = ["version": 1, "protocol": "nimo-macos-resource-v1", "operation": request.operation.rawValue,
                 "requestNonce": request.requestNonce, "captureNonce": request.captureNonce,
                 "planSha256": request.planSha256, "grantSha256": request.grantSha256,
                 "process": ["pid": process.pid, "instanceId": process.instanceId],
                 "clock": ["kind": "darwin-continuous-time-v1", "receivedElapsedMs": received, "observedElapsedMs": NimoResourceClock.now()],
                 "capture": ["armedElapsedMs": session.armedElapsedMs, "admittedElapsedMs": nullable(session.admittedElapsedMs), "cancelled": session.cancelled,
-                            "expectedPair": ["name": session.pair.name, "peripheralUuid": session.pair.peripheralUuid]],
+                            "expectedPair": request.expectedPair.dictionary],
                 "currentManager": current, "session": nullable(session.sessionDictionary()),
                 "release": session.releaseDictionary(producers: producers), "producers": producers.dictionary, "errors": session.errors]
+        if let discovery { result["discovery"] = discovery.ledger.dictionary(callbacksPending: discovery.callbacksPending) }
+        return result
     }
 
+    private func discoveryOnlyReceipt(_ request: NimoResourceRequest, received: UInt64) -> [String: Any] {
+        let settled = discovery?.ledger.settledElapsedMs != nil && discovery?.callbacksPending == 0
+        let manager = DeviceManager.shared.sgc
+        let managerSafe = manager == nil || originalClosed && !(manager?.type.contains("NIMO") ?? false)
+        let closed = discoveryReleaseNonce != nil && settled && pendingOriginalManagerEntries == 0 && managerSafe
+        originalClosed = closed
+        var producers = NimoResourceProducers()
+        producers.postedCallbacks = pendingOriginalManagerEntries + (discovery?.callbacksPending ?? 0)
+        producers.timers = settled ? 0 : 1
+        let release: [String: Any] = ["nonce": nullable(discoveryReleaseNonce), "startedElapsedMs": nullable(discoveryReleaseStartedElapsedMs),
+            "micStopRequired": false, "displayExitRequired": false, "micStopStartedElapsedMs": NSNull(), "micStopWrittenElapsedMs": NSNull(), "micStopMarkerElapsedMs": NSNull(),
+            "exitStatusCode": NSNull(), "exitAckElapsedMs": NSNull(), "disconnectRequestedElapsedMs": NSNull(), "disconnectCallbackElapsedMs": NSNull(), "disconnectError": NSNull(),
+            "connectionFailedElapsedMs": NSNull(), "noTransport": closed, "settled": closed]
+        return ["version": 1, "protocol": "nimo-macos-resource-v1", "operation": request.operation.rawValue,
+            "requestNonce": request.requestNonce, "captureNonce": request.captureNonce, "planSha256": request.planSha256, "grantSha256": request.grantSha256,
+            "process": ["pid": process.pid, "instanceId": process.instanceId],
+            "clock": ["kind": "darwin-continuous-time-v1", "receivedElapsedMs": received, "observedElapsedMs": NimoResourceClock.now()],
+            "capture": ["armedElapsedMs": armedElapsedMs!, "admittedElapsedMs": NSNull(), "cancelled": discoveryCancelled, "expectedPair": request.expectedPair.dictionary],
+            "currentManager": ["type": nullable(DeviceManager.shared.sgc?.type), "instanceId": nullable((DeviceManager.shared.sgc as? Nimo)?.resourceInstanceId)],
+            "session": NSNull(), "release": release, "producers": producers.dictionary, "errors": [],
+            "discovery": discovery!.ledger.dictionary(callbacksPending: discovery!.callbacksPending)]
+    }
+
+    #if SWIFT_PACKAGE
+    /// Test-only original discovery seed; no CoreBluetooth object is created.
+    /// Tests still execute the real perform/status/cancel/arm authority branches.
+    func packageSeedDiscovery(name: String, capture: String, discoveryOperation: String, candidates: [(String, String?)], persisted: Bool) {
+        packageEnabled = true
+        acceptedPair = NimoResourceSelection(name: name, peripheralSelection: NimoResourceSelection.connectedService)
+        captureNonce = capture; armedElapsedMs = NimoResourceClock.now()
+        let observer = NimoResourceConnectedDiscovery(name: name, startedElapsedMs: armedElapsedMs!)
+        discovery = observer; discoveryRequestNonce = discoveryOperation
+        for (uuid, candidateName) in candidates { observer.ledger.observe(uuid: uuid, name: candidateName) }
+        observer.ledger.finish(at: NimoResourceClock.now(), callbacksPending: 0)
+        if persisted { completed[discoveryOperation] = (Data(), Data()) }
+    }
+    func packagePerform(_ bytes: Data) async throws -> [String: Any] {
+        try await perform(try decode(bytes), received: NimoResourceClock.now())
+    }
+    #endif
+
     private func decode(_ bytes: Data) throws -> NimoResourceRequest { try NimoResourceRequest.decode(bytes) }
     private func failure(_ code: String) -> Error { NSError(domain: "NimoResourceFixture", code: 1, userInfo: [NSLocalizedDescriptionKey: code]) }
 }
+
+
+/// Retrieval only: no scan, connection, peripheral delegate, service discovery or
+/// writes. The serial state-delegate queue drains before candidate commitment.
+@MainActor
+final class NimoResourceConnectedDiscovery: NSObject, CBCentralManagerDelegate {
+    let ledger: NimoResourceDiscovery
+    private let queue = DispatchQueue(label: "com.mentra.nimo.resource.connected-discovery")
+    private var central: CBCentralManager?
+    private var stopped = false
+    private var running = false
+    private var now: () -> UInt64 = NimoResourceClock.now
+    private var pause: () async throws -> Void = { try await Task.sleep(nanoseconds: 50_000_000) }
+    #if SWIFT_PACKAGE
+    private var packageSample: (() -> (CBManagerState, [(String, String?)]))?
+    func packageConfigureObserver(now: @escaping () -> UInt64, pause: @escaping () async throws -> Void,
+                                  sample: @escaping () -> (CBManagerState, [(String, String?)])) {
+        precondition(!running && central == nil)
+        self.now = now; self.pause = pause; packageSample = sample
+    }
+    #endif
+    nonisolated private let callbacks = NimoResourceCallbackCounter()
+    var callbacksPending: Int { callbacks.value }
+    init(name: String, startedElapsedMs: UInt64) {
+        ledger = NimoResourceDiscovery(name: name, startedElapsedMs: startedElapsedMs); super.init()
+    }
+    nonisolated func centralManagerDidUpdateState(_ central: CBCentralManager) {
+        callbacks.add(1)
+        defer { callbacks.add(-1) }
+        // No deferred work. State is sampled by the owned bounded Main loop.
+    }
+    @inline(never)
+    private func retrieveConnected(_ central: CBCentralManager) -> [CBPeripheral] {
+        central.retrieveConnectedPeripherals(withServices: [CBUUID(string: "00007033-0000-1000-8000-00805F9B34FB")])
+    }
+    @inline(never)
+    func discoverConnected() async {
+        guard !running, !stopped else { return }
+        running = true
+        #if SWIFT_PACKAGE
+        if packageSample == nil {
+            central = CBCentralManager(delegate: self, queue: queue, options: [CBCentralManagerOptionShowPowerAlertKey: false])
+        }
+        #else
+        central = CBCentralManager(delegate: self, queue: queue, options: [CBCentralManagerOptionShowPowerAlertKey: false])
+        #endif
+        let deadline = ledger.startedElapsedMs + 5_000
+        while !stopped {
+            // A post-sleep final powered-on retrieval replaces earlier facts.
+            let finalSample = now() >= deadline
+            var state = central?.state ?? .unknown
+            #if SWIFT_PACKAGE
+            let simulated = packageSample?()
+            if let simulated { state = simulated.0 }
+            #endif
+            switch state {
+            case .poweredOn:
+                #if SWIFT_PACKAGE
+                if let simulated { ledger.observeConnectedSnapshot(simulated.1) }
+                else if let central { ledger.observeConnectedSnapshot(retrieveConnected(central).map { ($0.identifier.uuidString.lowercased(), $0.name) }) }
+                else { ledger.observeConnectedSnapshot([]) }
+                #else
+                if let central { ledger.observeConnectedSnapshot(retrieveConnected(central).map { ($0.identifier.uuidString.lowercased(), $0.name) }) }
+                else { ledger.observeConnectedSnapshot([]) }
+                #endif
+            case .unsupported, .unauthorized:
+                ledger.observeConnectedSnapshot([])
+                ledger.recordError("connected-service-observer-unavailable"); finishDiscovery(); return
+            default:
+                // Radio loss invalidates the current snapshot, not history.
+                ledger.observeConnectedSnapshot([])
+            }
+            if finalSample { break }
+            do { try await pause() }
+            catch { ledger.recordError("discovery-task-cancelled"); ledger.cancel(); finishDiscovery(); return }
+        }
+        finishDiscovery()
+    }
+    @inline(never)
+    func stopDiscovery(cancel: Bool) async {
+        if cancel { ledger.cancel() }
+        stopped = true
+        let deadline = NimoResourceClock.now() + 1_000
+        while running, NimoResourceClock.now() < deadline {
+            do { try await Task.sleep(nanoseconds: 1_000_000) } catch { await Task.yield() }
+        }
+        guard !running else { ledger.recordError("discovery-loop-not-settled"); return }
+        finishDiscovery()
+    }
+    @inline(never)
+    private func finishDiscovery() {
+        stopped = true
+        central?.delegate = nil
+        // Callback contains no Main work; the queue barrier cannot deadlock.
+        queue.sync {}
+        central = nil
+        ledger.finish(at: now(), callbacksPending: callbacksPending)
+        running = false
+    }
+}

package/ios/Source/sgcs/NimoResourceSession.swift

@@ -65,8 +65,64 @@ struct NimoResourcePair: Codable, Equatable {
     let peripheralUuid: String
 }
 
+/// Accepted selection remains immutable even after connected-service discovery.
+struct NimoResourceSelection: Codable, Equatable {
+    static let connectedService = "connected-service-exact-name-v1"
+    let name: String
+    let peripheralUuid: String?
+    let peripheralSelection: String?
+    init(name: String, peripheralUuid: String? = nil, peripheralSelection: String? = nil) { self.name = name; self.peripheralUuid = peripheralUuid; self.peripheralSelection = peripheralSelection }
+    init(pair: NimoResourcePair) { name = pair.name; peripheralUuid = pair.peripheralUuid; peripheralSelection = nil }
+    var dictionary: [String: Any] {
+        if let peripheralUuid { return ["name": name, "peripheralUuid": peripheralUuid] }
+        return ["name": name, "peripheralSelection": peripheralSelection ?? ""]
+    }
+}
+
+/// Pure candidate ledger. Selection is committed only once, after the bounded
+/// observer has stopped; a later callback cannot replace its physical identity.
+final class NimoResourceDiscovery {
+    static let serviceUuid = "00007033-0000-1000-8000-00805f9b34fb"
+    let name: String
+    let startedElapsedMs: UInt64
+    private(set) var settledElapsedMs: UInt64?
+    private(set) var selectedPeripheralUuid: String?
+    private(set) var candidates: [String: String] = [:]
+    private var currentlyConnected: Set<String> = []
+    private(set) var errors: [String] = []
+    private(set) var cancelled = false
+    init(name: String, startedElapsedMs: UInt64) { self.name = name; self.startedElapsedMs = startedElapsedMs }
+    func observe(uuid: String, name: String?) {
+        guard settledElapsedMs == nil, !cancelled, name == self.name else { return }
+        guard UUID(uuidString: uuid)?.uuidString.lowercased() == uuid else { recordError("invalid-discovery-uuid"); return }
+        if candidates.count >= 16, candidates[uuid] == nil { recordError("discovery-candidate-budget"); return }
+        candidates[uuid] = name
+        currentlyConnected.insert(uuid)
+        if candidates.count > 1 { recordError("ambiguous-connected-service-peer") }
+    }
+    func observeConnectedSnapshot(_ peers: [(String, String?)]) {
+        guard settledElapsedMs == nil, !cancelled else { return }
+        currentlyConnected.removeAll()
+        for (uuid, name) in peers { observe(uuid: uuid, name: name) }
+    }
+    func recordError(_ error: String) { guard settledElapsedMs == nil else { return }; if errors.count < 16, !errors.contains(error) { errors.append(error) } }
+    func cancel() { guard settledElapsedMs == nil else { return }; cancelled = true }
+    func finish(at: UInt64, callbacksPending: Int) {
+        guard settledElapsedMs == nil, callbacksPending == 0, at >= startedElapsedMs else { return }
+        if !cancelled, errors.isEmpty, candidates.count == 1, currentlyConnected.count == 1 { selectedPeripheralUuid = candidates.keys.first }
+        else if !cancelled, currentlyConnected.isEmpty { recordError("no-connected-service-peer") }
+        settledElapsedMs = at
+    }
+    func dictionary(callbacksPending: Int) -> [String: Any] {
+        ["kind": NimoResourceSelection.connectedService, "selectedPeripheralUuid": nullable(selectedPeripheralUuid),
+         "candidates": candidates.keys.sorted().map { ["peripheralUuid": $0, "name": candidates[$0]!, "source": "connected-service", "serviceUuid": Self.serviceUuid] },
+         "startedElapsedMs": startedElapsedMs, "settledElapsedMs": nullable(settledElapsedMs),
+         "settled": settledElapsedMs != nil && callbacksPending == 0, "callbacksPending": callbacksPending, "errors": errors]
+    }
+}
+
 struct NimoResourceRequest: Codable, Equatable {
-    enum Operation: String, Codable { case arm, status, release, cancel }
+    enum Operation: String, Codable { case discover, arm, status, release, cancel }
     let version: Int
     let operation: Operation
     let requestNonce: String
@@ -74,7 +130,7 @@ struct NimoResourceRequest: Codable, Equatable {
     let planSha256: String
     let grantSha256: String
     let expectedProcess: NimoResourceProcess
-    let expectedPair: NimoResourcePair
+    let expectedPair: NimoResourceSelection
     let original: NimoResourceOriginal?
 }
 
@@ -130,9 +186,9 @@ final class NimoResourceSession {
     private var peripheral: AnyObject?
     private let now: () -> UInt64
 
-    init(captureNonce: String, pair: NimoResourcePair, now: @escaping () -> UInt64 = NimoResourceClock.now) {
+    init(captureNonce: String, pair: NimoResourcePair, now: @escaping () -> UInt64 = NimoResourceClock.now, armedElapsedMs: UInt64? = nil) {
         self.captureNonce = captureNonce; self.pair = pair; self.now = now
-        armedElapsedMs = now()
+        self.armedElapsedMs = armedElapsedMs ?? now()
     }
 
     func isOwner(_ candidate: AnyObject) -> Bool { owner === candidate }
@@ -320,18 +376,28 @@ extension NimoResourceRequest {
         guard bytes.count <= 16_384, let value = try JSONSerialization.jsonObject(with: bytes) as? [String: Any],
               Set(value.keys) == Set(["version","operation","requestNonce","captureNonce","planSha256","grantSha256","expectedProcess","expectedPair","original"]),
               let process = value["expectedProcess"] as? [String: Any], Set(process.keys) == Set(["pid","instanceId"]),
-              let pair = value["expectedPair"] as? [String: Any], Set(pair.keys) == Set(["name","peripheralUuid"]) else { throw failure("invalid-request-schema") }
+              let pair = value["expectedPair"] as? [String: Any],
+              Set(pair.keys) == Set(["name","peripheralUuid"]) || Set(pair.keys) == Set(["name","peripheralSelection"]) else { throw failure("invalid-request-schema") }
         if let original = value["original"] as? [String: Any], Set(original.keys) != Set(["instanceId","peripheralUuid","sessionGeneration"]) { throw failure("invalid-original-schema") }
         let result = try JSONDecoder().decode(NimoResourceRequest.self, from: bytes)
-        let ids = [result.requestNonce, result.captureNonce, result.expectedProcess.instanceId, result.expectedPair.peripheralUuid] +
+        let ids = [result.requestNonce, result.captureNonce, result.expectedProcess.instanceId] + (result.expectedPair.peripheralUuid.map { [$0] } ?? []) +
             (result.original.map { [$0.instanceId, $0.peripheralUuid] } ?? [])
         for id in ids {
             guard UUID(uuidString: id)?.uuidString.lowercased() == id else { throw failure("invalid-uuid") }
         }
+        if result.operation == .discover {
+            guard result.expectedPair.peripheralSelection == NimoResourceSelection.connectedService,
+                  result.requestNonce == result.captureNonce, result.original == nil else { throw failure("invalid-discovery-identity") }
+        }
+        if result.operation == .arm {
+            guard result.original == nil,
+                  (result.expectedPair.peripheralUuid != nil ? result.requestNonce == result.captureNonce : result.requestNonce != result.captureNonce) else { throw failure("invalid-arm-identity") }
+        }
         if let original = result.original {
-            guard original.sessionGeneration <= 1, original.peripheralUuid == result.expectedPair.peripheralUuid else { throw failure("invalid-original-identity") }
+            guard original.sessionGeneration <= 1, (result.expectedPair.peripheralUuid == nil || original.peripheralUuid == result.expectedPair.peripheralUuid) else { throw failure("invalid-original-identity") }
         }
-        guard result.expectedProcess.pid > 1, result.version == 1, !result.expectedPair.name.isEmpty, result.expectedPair.name.utf8.count <= 128,
+        guard (result.expectedPair.peripheralUuid != nil && result.expectedPair.peripheralSelection == nil || result.expectedPair.peripheralUuid == nil && result.expectedPair.peripheralSelection == NimoResourceSelection.connectedService),
+              result.expectedProcess.pid > 1, result.version == 1, !result.expectedPair.name.isEmpty, result.expectedPair.name.utf8.count <= 128,
               result.planSha256.range(of: "^[0-9a-f]{64}$", options: .regularExpression) != nil,
               result.grantSha256.range(of: "^[0-9a-f]{64}$", options: .regularExpression) != nil else { throw failure("invalid-request-identity") }
         return result

package/ios/Tests/NimoResourceSessionTests.swift

@@ -1,8 +1,136 @@
 import Foundation
+import CoreBluetooth
 @testable import MentraBluetoothSDK
 import XCTest
 
 final class NimoResourceSessionTests: XCTestCase {
+    func testConnectedDiscoverySelectionRequiresExactUniquePeerAndCannotChangeAfterSettlement() {
+        let model = NimoResourceDiscovery(name: "NIMO exact", startedElapsedMs: 10)
+        model.observe(uuid: uuid, name: "NIMO exact_BLE")
+        XCTAssertTrue(model.candidates.isEmpty)
+        model.observe(uuid: uuid, name: "NIMO exact")
+        model.observe(uuid: uuid, name: "NIMO exact")
+        model.finish(at: 20, callbacksPending: 1)
+        XCTAssertNil(model.settledElapsedMs)
+        XCTAssertNil(model.selectedPeripheralUuid)
+        model.finish(at: 21, callbacksPending: 0)
+        XCTAssertEqual(model.selectedPeripheralUuid, uuid)
+        model.observe(uuid: "00000000-0000-4000-8000-000000000002", name: "NIMO exact")
+        model.cancel(); model.finish(at: 30, callbacksPending: 0)
+        XCTAssertEqual(model.selectedPeripheralUuid, uuid)
+        XCTAssertEqual(model.settledElapsedMs, 21)
+        XCTAssertEqual(model.candidates.count, 1)
+    }
+    func testConnectedDiscoveryAmbiguityCancellationAndMissingPeerNeverSelect() {
+        for scenario in 0..<3 {
+            let model = NimoResourceDiscovery(name: "NIMO exact", startedElapsedMs: 10)
+            if scenario != 2 { model.observe(uuid: uuid, name: "NIMO exact") }
+            if scenario == 0 { model.observe(uuid: "00000000-0000-4000-8000-000000000002", name: "NIMO exact") }
+            if scenario == 1 { model.cancel() }
+            model.finish(at: 20, callbacksPending: 0)
+            XCTAssertNil(model.selectedPeripheralUuid)
+            XCTAssertEqual(model.settledElapsedMs, 20)
+            if scenario != 1 { XCTAssertFalse(model.errors.isEmpty) }
+        }
+    }
+    func testConnectedDiscoveryDoesNotSelectPeerThatDisappearedBeforeFinalObservation() {
+        let model = NimoResourceDiscovery(name: "NIMO exact", startedElapsedMs: 10)
+        model.observeConnectedSnapshot([(uuid, "NIMO exact")])
+        model.observeConnectedSnapshot([])
+        model.finish(at: 20, callbacksPending: 0)
+        XCTAssertNil(model.selectedPeripheralUuid)
+        XCTAssertEqual(model.candidates.count, 1)
+        XCTAssertFalse(model.errors.isEmpty)
+    }
+    private func discoveryRequest(operation: String, capture: String, nonce: String, extraPair: [String: Any] = [:]) throws -> Data {
+        var pair: [String: Any] = ["name": "NIMO exact", "peripheralSelection": "connected-service-exact-name-v1"]
+        for (key, value) in extraPair { pair[key] = value }
+        return try JSONSerialization.data(withJSONObject: ["version": 1, "operation": operation, "requestNonce": nonce, "captureNonce": capture,
+            "planSha256": String(repeating: "a", count: 64), "grantSha256": String(repeating: "b", count: 64),
+            "expectedProcess": ["pid": 123, "instanceId": uuid], "expectedPair": pair, "original": NSNull()])
+    }
+    func testDiscoveryWireRejectsMixedOrUnknownSelectionRatherThanPlaceholderUuid() throws {
+        let data = try discoveryRequest(operation: "discover", capture: uuid, nonce: uuid)
+        XCTAssertEqual(try NimoResourceRequest.decode(data).expectedPair.peripheralSelection, NimoResourceSelection.connectedService)
+        XCTAssertThrowsError(try NimoResourceRequest.decode(discoveryRequest(operation: "discover", capture: uuid, nonce: uuid, extraPair: ["peripheralUuid": uuid])))
+        XCTAssertThrowsError(try NimoResourceRequest.decode(discoveryRequest(operation: "discover", capture: uuid, nonce: uuid, extraPair: ["peripheralSelection": "name-only"])))
+        XCTAssertThrowsError(try NimoResourceRequest.decode(discoveryRequest(operation: "discover", capture: uuid, nonce: uuid, extraPair: ["peripheralSelection": NSNull()])))
+    }
+    @MainActor
+    func testActualFixtureDiscoveryCannotAdmitManagerUntilSeparateArmAndPersistedDiscoveryReceipt() async throws {
+        let discoveryId = "00000000-0000-4000-8000-000000000002"
+        for persisted in [false, true] {
+            let fixture = NimoResourceFixture()
+            fixture.packageSeedDiscovery(name: "NIMO exact", capture: uuid, discoveryOperation: discoveryId, candidates: [(uuid, "NIMO exact")], persisted: persisted)
+            XCTAssertNil(fixture.session)
+            XCTAssertFalse(fixture.allowsManager("NIMO", name: "NIMO exact"))
+            let status = try await fixture.packagePerform(discoveryRequest(operation: "status", capture: uuid, nonce: discoveryId))
+            XCTAssertTrue(status["session"] is NSNull)
+            let anchor = (status["capture"] as! [String: Any])["armedElapsedMs"] as! UInt64
+            do {
+                let armed = try await fixture.packagePerform(discoveryRequest(operation: "arm", capture: uuid, nonce: "00000000-0000-4000-8000-000000000003"))
+                XCTAssertTrue(persisted)
+                XCTAssertEqual(fixture.session?.pair.peripheralUuid, uuid)
+                XCTAssertEqual((armed["capture"] as! [String: Any])["armedElapsedMs"] as? UInt64, anchor)
+                XCTAssertTrue(fixture.allowsManager("NIMO", name: "NIMO exact"))
+            } catch { XCTAssertFalse(persisted) }
+        }
+    }
+    @MainActor
+    func testActualFixtureDiscoveryOnlyCancelClosesObserverWithoutSessionOrFakeDisconnectAndForbidsLaterArm() async throws {
+        let fixture = NimoResourceFixture(), discoveryId = "00000000-0000-4000-8000-000000000002"
+        fixture.packageSeedDiscovery(name: "NIMO exact", capture: uuid, discoveryOperation: discoveryId, candidates: [(uuid, "NIMO exact")], persisted: true)
+        let result = try await fixture.packagePerform(discoveryRequest(operation: "cancel", capture: uuid, nonce: discoveryId))
+        XCTAssertNil(fixture.session)
+        let release = result["release"] as! [String: Any]
+        XCTAssertEqual(release["noTransport"] as? Bool, true)
+        XCTAssertEqual(release["settled"] as? Bool, true)
+        XCTAssertTrue(release["disconnectCallbackElapsedMs"] is NSNull)
+        XCTAssertTrue(fixture.allowsManager("G2", name: "G2"))
+        do { _ = try await fixture.packagePerform(discoveryRequest(operation: "arm", capture: uuid, nonce: "00000000-0000-4000-8000-000000000003")); XCTFail("cancelled discovery admitted arm") }
+        catch { XCTAssertNil(fixture.session) }
+    }
+    @MainActor
+    func testActualObserverLoopRequiresFreshFinalRetrievalAndRejectsRadioStateLossWithoutRadio() async {
+        for finalState in [CBManagerState.poweredOn, .poweredOff, .resetting] {
+            for finalPeerPresent in [false, true] {
+                var clock: UInt64 = 100, samples = 0, pauses = 0
+                let observer = NimoResourceConnectedDiscovery(name: "NIMO exact", startedElapsedMs: clock)
+                observer.packageConfigureObserver(now: { clock }, pause: {
+                    pauses += 1; clock += 5_000
+                }, sample: {
+                    samples += 1
+                    if samples == 1 { return (.poweredOn, [(self.uuid, "NIMO exact")]) }
+                    return (finalState, finalPeerPresent ? [(self.uuid, "NIMO exact")] : [])
+                })
+                await observer.discoverConnected()
+                XCTAssertEqual(samples, 2)
+                XCTAssertEqual(pauses, 1)
+                XCTAssertEqual(observer.callbacksPending, 0)
+                XCTAssertEqual(observer.ledger.settledElapsedMs, 5_100)
+                XCTAssertEqual(observer.ledger.selectedPeripheralUuid, finalState == .poweredOn && finalPeerPresent ? uuid : nil)
+                XCTAssertEqual(observer.ledger.candidates.count, 1)
+            }
+        }
+    }
+    @MainActor
+    func testActualObserverInvalidatesIntermediateRadioLossAndCancellationCannotReusePreviousSample() async {
+        var clock: UInt64 = 100, samples = 0
+        let observer = NimoResourceConnectedDiscovery(name: "NIMO exact", startedElapsedMs: clock)
+        observer.packageConfigureObserver(now: { clock }, pause: {
+            clock += 2_500
+            if clock == 5_100 { throw CancellationError() }
+        }, sample: {
+            samples += 1
+            return samples == 1 ? (.poweredOn, [(self.uuid, "NIMO exact")]) : (.resetting, [])
+        })
+        await observer.discoverConnected()
+        XCTAssertEqual(samples, 2)
+        XCTAssertNil(observer.ledger.selectedPeripheralUuid)
+        XCTAssertEqual(observer.ledger.settledElapsedMs, 5_100)
+        XCTAssertTrue(observer.ledger.cancelled)
+        XCTAssertTrue(observer.ledger.errors.contains("discovery-task-cancelled"))
+    }
     private let uuid = "00000000-0000-4000-8000-000000000001"
     private final class Clock { var value: UInt64 = 100; func next() -> UInt64 { value += 1; return value } }
     private func fixture() -> (NimoResourceSession, NSObject, NSObject, Clock) {

package/package.json

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

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.4.0",
-  "releaseIdentity": "3.4.0-dev.979",
-  "releaseSetId": "mentra-3.4.0-dev.979",
-  "sourceCommit": "cec2dff0b77fc7963d63602bba43556c690daf9d",
-  "otaManifestUrl": "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.4.0/mentra-live-ota-3.4.0-dev.979.json",
-  "otaManifestSha256": "667fffda403d22a07c60a0029ef602c556d13ddfa4bf8161fda5f56f54f50f13"
+  "releaseIdentity": "3.4.0-dev.980",
+  "releaseSetId": "mentra-3.4.0-dev.980",
+  "sourceCommit": "d43a82b42eddeee824f4c8f003415bc65dbd5aab",
+  "otaManifestUrl": "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.4.0/mentra-live-ota-3.4.0-dev.980.json",
+  "otaManifestSha256": "3121c2acd957c5f554b36d8260c4a3550c85bd50cee3d11a27a53b407e27b6d0"
 })