@mentra/bluetooth-sdk 3.2.1-beta.476 → 3.2.1-beta.481

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.2.1"
-    const val RELEASE_IDENTITY: String = "3.2.1-beta.476"
-    const val RELEASE_SET_ID: String = "mentra-3.2.1-beta.476"
-    const val SOURCE_COMMIT: String = "19a7b950cfb00d6a988c174a9206d553a1b7b766"
-    const val OTA_MANIFEST_URL: String = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.476.json"
-    const val OTA_MANIFEST_SHA256: String = "7124ab690088031a8ab55eb8b56c0d3074bdf4acc15197e5ddf07e37a77122c2"
+    const val RELEASE_IDENTITY: String = "3.2.1-beta.481"
+    const val RELEASE_SET_ID: String = "mentra-3.2.1-beta.481"
+    const val SOURCE_COMMIT: String = "c3269f1bc026d0b1967e8f18cae271c0ef396c11"
+    const val OTA_MANIFEST_URL: String = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.481.json"
+    const val OTA_MANIFEST_SHA256: String = "be95e7f2ec85c32d385f66ed8d1c319320e1b5f61f59ea3d1d76199f269834ea"
 }

package/android/src/main/java/com/mentra/bluetoothsdk/sgcs/SerializedGattCallback.kt

@@ -4,6 +4,7 @@ import android.bluetooth.BluetoothGatt
 import android.bluetooth.BluetoothGattCallback
 import android.bluetooth.BluetoothGattCharacteristic
 import android.bluetooth.BluetoothGattDescriptor
+import android.os.Build
 
 /**
  * Binder callbacks only capture their arguments. Session validation and all callback effects run
@@ -45,6 +46,10 @@ internal abstract class SerializedGattCallback(
     final override fun onCharacteristicChanged(
         gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic,
     ) {
+        // Android 13 introduced the value callback; some framework versions also call
+        // this deprecated overload for the same notification. Decoding both replays
+        // each LC3 packet and doubles recorded audio. Older Android uses this path.
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) return
         val value = characteristic.value?.copyOf() ?: return
         dispatch(gatt) { handleCharacteristicChanged(gatt, characteristic, value) }
     }

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

@@ -78,6 +78,39 @@ class MentraLiveGattCallbackTest {
         assertArrayEquals(byteArrayOf(3, 2), callback.packets[1])
     }
 
+    @Test
+    @Config(sdk = [33])
+    @Suppress("DEPRECATION")
+    fun `modern and legacy callbacks for one notification deliver one packet`() {
+        val queue = ArrayDeque<() -> Unit>()
+        val callback = RecordingCallback({ work -> queue.addLast(work) })
+        val gatt = gatt()
+        val characteristic = BluetoothGattCharacteristic(UUID.randomUUID(), 0, 0)
+        val value = byteArrayOf(0xf1.toByte(), 7, 1, 2)
+        characteristic.value = value
+        callback.onCharacteristicChanged(gatt, characteristic, value)
+        callback.onCharacteristicChanged(gatt, characteristic)
+        value[2] = 9
+        while (queue.isNotEmpty()) queue.removeFirst().invoke()
+        assertEquals(1, callback.packets.size)
+        assertArrayEquals(byteArrayOf(0xf1.toByte(), 7, 1, 2), callback.packets.single())
+    }
+
+    @Test
+    @Config(sdk = [33])
+    fun `separate modern notifications retain identical payloads`() {
+        val queue = ArrayDeque<() -> Unit>()
+        val callback = RecordingCallback({ work -> queue.addLast(work) })
+        val gatt = gatt()
+        val characteristic = BluetoothGattCharacteristic(UUID.randomUUID(), 0, 0)
+        val value = byteArrayOf(1, 2)
+        repeat(2) { callback.onCharacteristicChanged(gatt, characteristic, value) }
+        value[0] = 9
+        while (queue.isNotEmpty()) queue.removeFirst().invoke()
+        assertEquals(2, callback.packets.size)
+        callback.packets.forEach { assertArrayEquals(byteArrayOf(1, 2), it) }
+    }
+
     @Test
     fun `replacement invalidates callbacks already waiting on the lifecycle queue`() {
         val queue = ArrayDeque<() -> Unit>()

package/build/generated/releaseMetadata.js

@@ -1,10 +1,10 @@
 export const BLUETOOTH_SDK_RELEASE_METADATA = Object.freeze({
     "schemaVersion": 1,
     "familyBaseVersion": "3.2.1",
-    "releaseIdentity": "3.2.1-beta.476",
-    "releaseSetId": "mentra-3.2.1-beta.476",
-    "sourceCommit": "19a7b950cfb00d6a988c174a9206d553a1b7b766",
-    "otaManifestUrl": "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.476.json",
-    "otaManifestSha256": "7124ab690088031a8ab55eb8b56c0d3074bdf4acc15197e5ddf07e37a77122c2"
+    "releaseIdentity": "3.2.1-beta.481",
+    "releaseSetId": "mentra-3.2.1-beta.481",
+    "sourceCommit": "c3269f1bc026d0b1967e8f18cae271c0ef396c11",
+    "otaManifestUrl": "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.481.json",
+    "otaManifestSha256": "be95e7f2ec85c32d385f66ed8d1c319320e1b5f61f59ea3d1d76199f269834ea"
 });
 //# 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,gBAAgB;IACnC,cAAc,EAAE,uBAAuB;IACvC,cAAc,EAAE,0CAA0C;IAC1D,gBAAgB,EAAE,kIAAkI;IACpJ,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.1\",\n  \"releaseIdentity\": \"3.2.1-beta.476\",\n  \"releaseSetId\": \"mentra-3.2.1-beta.476\",\n  \"sourceCommit\": \"19a7b950cfb00d6a988c174a9206d553a1b7b766\",\n  \"otaManifestUrl\": \"https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.476.json\",\n  \"otaManifestSha256\": \"7124ab690088031a8ab55eb8b56c0d3074bdf4acc15197e5ddf07e37a77122c2\"\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,gBAAgB;IACnC,cAAc,EAAE,uBAAuB;IACvC,cAAc,EAAE,0CAA0C;IAC1D,gBAAgB,EAAE,kIAAkI;IACpJ,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.1\",\n  \"releaseIdentity\": \"3.2.1-beta.481\",\n  \"releaseSetId\": \"mentra-3.2.1-beta.481\",\n  \"sourceCommit\": \"c3269f1bc026d0b1967e8f18cae271c0ef396c11\",\n  \"otaManifestUrl\": \"https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.481.json\",\n  \"otaManifestSha256\": \"be95e7f2ec85c32d385f66ed8d1c319320e1b5f61f59ea3d1d76199f269834ea\"\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.2.1-beta.476"
+    private static let swiftPackageSdkVersion = "3.2.1-beta.481"
     private static let swiftPackageSdkVersionPlaceholder = "__MENTRA" + "_BLUETOOTH_SDK_VERSION__"
 
     private static func normalizedSdkVersion(_ value: String?) -> String? {

package/ios/Source/DeviceManager.swift

@@ -330,7 +330,7 @@ struct ViewState {
 
     /// STT:
     #if !os(macOS) && (!SWIFT_PACKAGE || MENTRA_FEATURE_LOCAL_STT)
-    private var transcriber: SherpaOnnxTranscriber?
+    private let transcriber = SherpaOnnxTranscriber()
     #endif
 
     var viewStates: [ViewState] = [
@@ -383,24 +383,6 @@ struct ViewState {
         // Start memory monitoring (logs every 30s to help detect leaks)
         // MemoryMonitor.start()
 
-        // Initialize SherpaOnnx Transcriber
-        #if !os(macOS) && (!SWIFT_PACKAGE || MENTRA_FEATURE_LOCAL_STT)
-        if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
-           let window = windowScene.windows.first,
-           let rootViewController = window.rootViewController
-        {
-            transcriber = SherpaOnnxTranscriber(context: rootViewController)
-        } else {
-            Bridge.log("Failed to create SherpaOnnxTranscriber - no root view controller found")
-        }
-
-        // Initialize the transcriber
-        if let transcriber = transcriber {
-            transcriber.initialize()
-            Bridge.log("SherpaOnnxTranscriber fully initialized")
-        }
-        #endif
-
         // Initialize persistent LC3 converter for unified audio encoding
         lc3Converter = PcmConverter()
         Bridge.log("LC3 converter initialized for unified audio encoding")
@@ -542,7 +524,7 @@ struct ViewState {
         // Send PCM to local transcriber.
 #if !os(macOS) && (!SWIFT_PACKAGE || MENTRA_FEATURE_LOCAL_STT)
         if shouldSendTranscript || localSttFallbackActive {
-            transcriber?.acceptAudio(pcm16le: pcmData)
+            transcriber.acceptAudio(pcm16le: pcmData)
         }
 #endif
     }
@@ -984,7 +966,7 @@ struct ViewState {
     func restartTranscriber() {
         #if !os(macOS) && (!SWIFT_PACKAGE || MENTRA_FEATURE_LOCAL_STT)
         Bridge.log("MAN: Restarting SherpaOnnxTranscriber via command")
-        transcriber?.restart()
+        transcriber.restart()
         #else
         Bridge.log("MAN: Local STT is not included in this SwiftPM build")
         #endif
@@ -1762,6 +1744,9 @@ struct ViewState {
     func setMicState() {
         let willSendPcm = shouldSendPcm || shouldSendLc3
         let willSendTranscript = shouldSendTranscript || localSttFallbackActive
+        #if !os(macOS) && (!SWIFT_PACKAGE || MENTRA_FEATURE_LOCAL_STT)
+        transcriber.setActive(willSendTranscript)
+        #endif
         micEnabled = willSendPcm || willSendTranscript
         updateMicState()
     }
@@ -2080,8 +2065,7 @@ struct ViewState {
         #endif
         // Clean up transcriber resources
 #if !os(macOS) && (!SWIFT_PACKAGE || MENTRA_FEATURE_LOCAL_STT)
-        transcriber?.shutdown()
-        transcriber = nil
+        transcriber.shutdown()
 #endif
 
         // Clean up LC3 converter

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.1"
-    static let releaseIdentity = "3.2.1-beta.476"
-    static let releaseSetId = "mentra-3.2.1-beta.476"
-    static let sourceCommit = "19a7b950cfb00d6a988c174a9206d553a1b7b766"
-    static let otaManifestUrl = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.476.json"
-    static let otaManifestSha256 = "7124ab690088031a8ab55eb8b56c0d3074bdf4acc15197e5ddf07e37a77122c2"
+    static let releaseIdentity = "3.2.1-beta.481"
+    static let releaseSetId = "mentra-3.2.1-beta.481"
+    static let sourceCommit = "c3269f1bc026d0b1967e8f18cae271c0ef396c11"
+    static let otaManifestUrl = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.481.json"
+    static let otaManifestSha256 = "be95e7f2ec85c32d385f66ed8d1c319320e1b5f61f59ea3d1d76199f269834ea"
 }

package/ios/Source/sgcs/Nimo.swift

@@ -20,10 +20,6 @@ enum NimoBLE {
     static let CHAR_RX = CBUUID(string: "00002022-0000-1000-8000-00805F9B34FB")
     static let CHAR_MIC = CBUUID(string: "00002025-0000-1000-8000-00805F9B34FB")
 
-    static let NAME_PREFIX = "nimo"
-    /// iOS ANCS side-channel devices advertise "<name>_ble" — never the data channel.
-    static let BLE_NAME_SUFFIX = "_ble"
-
     static let CHUNK_SIZE = 501
     static let INTER_FRAME_DELAY_MS = 5
 }
@@ -591,6 +587,27 @@ class Nimo: NSObject, SGCManager {
     private var rxChar: CBCharacteristic?
     private var micChar: CBCharacteristic?
     private var isDisconnecting = false
+    private var scanRequested = false
+    private lazy var discovery = NimoDiscovery<CBPeripheral>(
+        register: { [weak self] in
+            #if os(iOS)
+                self?.centralManager?.registerForConnectionEvents(options: [.serviceUUIDs: [NimoBLE.SERVICE_UUID]])
+            #endif
+        }, connected: { [weak self] in
+            self?.centralManager?.retrieveConnectedPeripherals(withServices: [NimoBLE.SERVICE_UUID]) ?? []
+        }, scan: { [weak self] in
+            self?.centralManager?.scanForPeripherals(
+                withServices: nil, options: [CBCentralManagerScanOptionAllowDuplicatesKey: false]
+            )
+        }, stop: { [weak self] in
+            self?.centralManager?.stopScan()
+            #if os(iOS)
+                self?.centralManager?.registerForConnectionEvents(options: [:])
+            #endif
+        }, name: { $0.name }, found: { [weak self] peripheral, name, rssi in
+            self?.onDeviceFound(peripheral, name: name, rssi: rssi)
+        }
+    )
 
     /// Device search
     private var DEVICE_SEARCH_ID = "NOT_SET"
@@ -680,6 +697,8 @@ class Nimo: NSObject, SGCManager {
     func findCompatibleDevices() {
         Bridge.log("NIMO: findCompatibleDevices()")
         DEVICE_SEARCH_ID = "NOT_SET"
+        isDisconnecting = false
+        scanRequested = true
         DeviceStore.shared.apply("glasses", "connectionState", ConnTypes.SCANNING)
         startScan()
     }
@@ -687,6 +706,7 @@ class Nimo: NSObject, SGCManager {
     func connectById(_ id: String) {
         Bridge.log("NIMO: connectById(\(id))")
         DEVICE_SEARCH_ID = id
+        scanRequested = true
         DeviceStore.shared.apply("glasses", "connectionState", ConnTypes.CONNECTING)
         isDisconnecting = false
         startPairingTimeout()
@@ -694,7 +714,8 @@ class Nimo: NSObject, SGCManager {
     }
 
     func stopScan() {
-        centralManager?.stopScan()
+        scanRequested = false
+        discovery.cancel()
     }
 
     func disconnect() {
@@ -1061,13 +1082,9 @@ class Nimo: NSObject, SGCManager {
 
     // MARK: - BLE Scanning
 
-    private func isNimoMainDevice(_ name: String) -> Bool {
-        let lower = name.lowercased()
-        return lower.hasPrefix(NimoBLE.NAME_PREFIX) && !lower.hasSuffix(NimoBLE.BLE_NAME_SUFFIX)
-    }
-
     @discardableResult
     private func startScan() -> Bool {
+        guard scanRequested, !isDisconnecting else { return false }
         Bridge.log("NIMO: startScan()")
         if centralManager == nil {
             centralManager = CBCentralManager(
@@ -1083,17 +1100,32 @@ class Nimo: NSObject, SGCManager {
 
         // Fast path: reconnect to the cached peripheral UUID.
         if connectByUUID() {
+            stopScan()
             return true
         }
 
-        centralManager!.scanForPeripherals(
-            withServices: nil,
-            options: [CBCentralManagerScanOptionAllowDuplicatesKey: false]
-        )
+        // NIMO's Companion service is GATT over BR/EDR. The main device must
+        // first be paired in Settings; it does not appear in a BLE-only scan.
+        discovery.start()
         return true
     }
 
+    private func onDeviceFound(_ peripheral: CBPeripheral, name: String, rssi: Int?) {
+        Bridge.log("NIMO: found Companion device: \(name)")
+        Bridge.sendDiscoveredDevice(DeviceTypes.NIMO, name, rssi: rssi)
+        guard DEVICE_SEARCH_ID != "NOT_SET", name == DEVICE_SEARCH_ID,
+              self.peripheral == nil else { return }
+        Bridge.log("NIMO: Connecting to \(name)")
+        stopScan()
+        lastDeviceName = name
+        lastDeviceUUID = peripheral.identifier.uuidString
+        self.peripheral = peripheral
+        peripheral.delegate = self
+        centralManager?.connect(peripheral, options: nil)
+    }
+
     private func connectByUUID() -> Bool {
+        guard peripheral == nil else { return false }
         guard DEVICE_SEARCH_ID != "NOT_SET", !DEVICE_SEARCH_ID.isEmpty else { return false }
         guard lastDeviceName == DEVICE_SEARCH_ID,
               let uuidString = lastDeviceUUID,
@@ -1299,7 +1331,8 @@ class Nimo: NSObject, SGCManager {
                 }
                 Bridge.log("NIMO: Attempting reconnection...")
                 await MainActor.run {
-                    self.isDisconnecting = false
+                    guard !self.isDisconnecting else { return }
+                    self.scanRequested = true
                     self.startScan()
                 }
                 return false
@@ -1564,37 +1597,29 @@ extension Nimo: CBCentralManagerDelegate {
     }
 
     nonisolated func centralManager(
-        _ central: CBCentralManager,
+        _: CBCentralManager,
         didDiscover peripheral: CBPeripheral,
         advertisementData: [String: Any],
         rssi: NSNumber
     ) {
-        guard
-            let name = peripheral.name
-            ?? advertisementData[CBAdvertisementDataLocalNameKey] as? String
-        else { return }
+        let advertisedName = advertisementData[CBAdvertisementDataLocalNameKey] as? String
         let rssiValue = rssi.intValue
-
         DispatchQueue.main.async { [weak self] in
-            guard let self else { return }
-            guard self.isNimoMainDevice(name) else { return }
-
-            Bridge.sendDiscoveredDevice(DeviceTypes.NIMO, name, rssi: rssiValue)
-
-            guard self.DEVICE_SEARCH_ID != "NOT_SET" else { return }
-            guard name == self.DEVICE_SEARCH_ID else { return }
-            guard self.peripheral == nil else { return }
-
-            Bridge.log("NIMO: Connecting to \(name)")
-            self.stopScan()
-            self.lastDeviceName = name
-            self.lastDeviceUUID = peripheral.identifier.uuidString
-            self.peripheral = peripheral
-            peripheral.delegate = self
-            central.connect(peripheral, options: nil)
+            self?.discovery.receive(peripheral, advertisedName: advertisedName, rssi: rssiValue)
         }
     }
 
+    #if os(iOS)
+        nonisolated func centralManager(
+            _: CBCentralManager, connectionEventDidOccur event: CBConnectionEvent, for peripheral: CBPeripheral
+        ) {
+            guard event == .peerConnected else { return }
+            DispatchQueue.main.async { [weak self] in
+                self?.discovery.receive(peripheral)
+            }
+        }
+    #endif
+
     nonisolated func centralManager(_: CBCentralManager, didConnect peripheral: CBPeripheral) {
         DispatchQueue.main.async { [weak self] in
             guard let self else { return }

package/ios/Source/sgcs/NimoDiscovery.swift

@@ -0,0 +1,49 @@
+import Foundation
+
+/// Combines system-connected classic devices with incoming CoreBluetooth discoveries.
+/// Kept independent of the radio so discovery can be exercised without hardware.
+@MainActor
+final class NimoDiscovery<Peripheral> {
+    private(set) var active = false
+    private let register: () -> Void
+    private let connected: () -> [Peripheral]
+    private let scan: () -> Void
+    private let stop: () -> Void
+    private let name: (Peripheral) -> String?
+    private let found: (Peripheral, String, Int?) -> Void
+
+    init(register: @escaping () -> Void, connected: @escaping () -> [Peripheral],
+         scan: @escaping () -> Void, stop: @escaping () -> Void,
+         name: @escaping (Peripheral) -> String?, found: @escaping (Peripheral, String, Int?) -> Void)
+    {
+        self.register = register
+        self.connected = connected
+        self.scan = scan
+        self.stop = stop
+        self.name = name
+        self.found = found
+    }
+
+    func start() {
+        active = true
+        // Register first so pairing in Settings cannot race the connected snapshot.
+        register()
+        for peripheral in connected() {
+            receive(peripheral)
+        }
+        if active { scan() }
+    }
+
+    func cancel() {
+        active = false
+        stop()
+    }
+
+    func receive(_ peripheral: Peripheral, advertisedName: String? = nil, rssi: Int? = nil) {
+        guard active, let name = advertisedName ?? name(peripheral) else { return }
+        let lower = name.lowercased()
+        // The separate ANCS peripheral does not host the Companion data service.
+        guard lower.hasPrefix("nimo"), !lower.hasSuffix("_ble") else { return }
+        found(peripheral, name, rssi)
+    }
+}

package/ios/Source/stt/SherpaOnnxTranscriber.swift

@@ -1,5 +1,4 @@
 import Foundation
-import UIKit
 
 /**
  * SherpaOnnxTranscriber handles real-time audio transcription using Sherpa-ONNX.
@@ -11,24 +10,30 @@ class SherpaOnnxTranscriber {
     private static let TAG = "SherpaOnnxTranscriber"
 
     private static let SAMPLE_RATE = 16000 // Sherpa-ONNX model's required sample rate
-    private static let QUEUE_CAPACITY = 100 // Max number of audio buffers to keep in queue
+    private final class Session {
+        let recognizer: SherpaOnnxRecognizer
+        var lastPartialResult = ""
 
-    private let pcmQueue = DispatchQueue(label: "com.augmentos.sherpaonnx.pcmQueue", qos: .userInteractive)
-    private var pcmBuffers = [Data]()
-    private var isRunning = false
-    private var processingQueue: DispatchQueue?
-    private var processingTask: DispatchWorkItem?
-
-    /// The underlying Sherpa-ONNX objects
-    private var recognizer: SherpaOnnxRecognizer?
+        init(_ recognizer: SherpaOnnxRecognizer) {
+            self.recognizer = recognizer
+        }
+    }
 
-    private var lastPartialResult = ""
+    private lazy var worker = DemandDrivenAudioWorker<Session>(
+        makeProcessor: { Self.makeRecognizer().map(Session.init) },
+        process: { [weak self] session, data, generation in
+            self?.process(session, data: data, generation: generation)
+        }
+    )
 
-    /// Parent context
-    private weak var context: UIViewController?
+    /// Construct the worker on the manager's actor before audio can arrive.
+    init() {
+        _ = worker
+    }
 
-    /// Session start time for relative timestamps
-    private var transcriptionSessionStart: Date
+    func setActive(_ active: Bool) {
+        worker.setActive(active)
+    }
 
     /// Dynamic model path support
     private static var customModelPath: String? {
@@ -65,23 +70,9 @@ class SherpaOnnxTranscriber {
         return nil
     }
 
-    /**
-     * Constructor that accepts a UIViewController to load model assets.
-     */
-    init(context: UIViewController) {
-        self.context = context
-        transcriptionSessionStart = Date()
-    }
-
-    deinit {
-        shutdown()
-    }
-
-    /**
-     * Initialize the Sherpa-ONNX recognizer.
-     * Loads models and configuration, sets up processing thread.
-     */
-    func initialize() {
+    /// Runs exclusively on the worker queue, never on the main/audio delivery thread.
+    private static func makeRecognizer() -> SherpaOnnxRecognizer? {
+        var recognizer: SherpaOnnxRecognizer?
         do {
             var tokensPath: String
             var modelType = "unknown"
@@ -201,30 +192,26 @@ class SherpaOnnxTranscriber {
                 Bridge.log("No Sherpa ONNX model available. Transcription will be disabled.")
                 Bridge.log("Please download a model using the model downloader in settings.")
                 recognizer = nil
-                isRunning = false
-                return
+                return nil
             }
 
             if recognizer == nil {
                 throw NSError(domain: "SherpaOnnxTranscriber", code: 2, userInfo: [NSLocalizedDescriptionKey: "Failed to create recognizer"])
             }
 
-            startProcessingTask()
-            isRunning = true
-
             Bridge.log("Sherpa-ONNX ASR initialized successfully with \(modelType) model")
+            return recognizer
 
         } catch {
             Bridge.log("Failed to initialize Sherpa-ONNX: \(error.localizedDescription)")
+            return nil
         }
     }
 
-    /**
-     * Handle transcription results - send only to delegate
-     */
-    private func handleTranscriptionResult(text: String, isFinal: Bool) {
-        // Forward to delegate if set
+    private func handleTranscriptionResult(text: String, isFinal: Bool, generation: UInt64) {
         DispatchQueue.main.async { [weak self] in
+            // A decode or main-queue delivery may finish after stop/model replacement.
+            guard let self, self.worker.isCurrent(generation) else { return }
             if isFinal {
                 STTTools.didReceiveFinalTranscription(text)
             } else {
@@ -233,123 +220,30 @@ class SherpaOnnxTranscriber {
         }
     }
 
-    /**
-     * Feed PCM audio data (16-bit little endian) into the transcriber.
-     * This method should be called continuously with short chunks (e.g., 100-300ms).
-     *
-     * Audio is queued directly; microphone VAD gating is not applied in the SDK.
-     */
     func acceptAudio(pcm16le: Data) {
-        guard isRunning else {
-            return
-        }
-
-        queueAudioData(pcm16le)
-    }
-
-    private func queueAudioData(_ pcm16le: Data) {
-        pcmQueue.async { [weak self] in
-            guard let self = self else { return }
-
-            let queueSizeBefore = self.pcmBuffers.count
-            self.pcmBuffers.append(pcm16le)
-
-            // Keep queue size manageable
-            if self.pcmBuffers.count > Self.QUEUE_CAPACITY {
-                let removedBuffer = self.pcmBuffers.removeFirst()
-                Bridge.log("⚠️ Audio queue overflow - dropped buffer of \(removedBuffer.count) bytes")
-            }
-        }
+        worker.accept(pcm16le)
     }
 
-    /**
-     * Start a background task to continuously consume audio and decode using Sherpa.
-     */
-    private func startProcessingTask() {
-        Bridge.log("🚀 Starting Sherpa-ONNX processing task...")
-
-        processingQueue = DispatchQueue(label: "com.augmentos.sherpaonnx.processor", qos: .userInitiated)
-
-        let workItem = DispatchWorkItem { [weak self] in
-            self?.runLoop()
+    private func process(_ session: Session, data: Data, generation: UInt64) {
+        guard worker.isCurrent(generation) else { return }
+        let recognizer = session.recognizer
+        recognizer.acceptWaveform(samples: toFloatArray(from: data), sampleRate: Self.SAMPLE_RATE)
+        while recognizer.isReady() {
+            guard worker.isCurrent(generation) else { return }
+            recognizer.decode()
         }
-
-        processingTask = workItem
-        processingQueue?.async(execute: workItem)
-    }
-
-    /**
-     * Main processing loop that handles transcription in real-time.
-     * Pulls audio from queue, feeds into Sherpa, emits partial/final results.
-     */
-    private func runLoop() {
-        Bridge.log("🔄 Sherpa-ONNX processing loop started")
-
-        while isRunning {
-            // Pull data from queue
-            var audioData: Data?
-
-            pcmQueue.sync {
-                if !self.pcmBuffers.isEmpty {
-                    audioData = self.pcmBuffers.removeFirst()
-                }
-            }
-
-            if let data = audioData {
-                // Synchronize access to recognizer to prevent race conditions
-                objc_sync_enter(self)
-                defer { objc_sync_exit(self) }
-
-                guard let recognizer = recognizer else {
-                    Bridge.log("⚠️ Recognizer not available, skipping audio chunk")
-                    continue
-                }
-
-                do {
-                    // Convert PCM to float [-1.0, 1.0]
-                    let floatBuf = toFloatArray(from: data)
-
-                    // Pass audio data to the Sherpa-ONNX stream
-                    recognizer.acceptWaveform(samples: floatBuf, sampleRate: Self.SAMPLE_RATE)
-
-                    // Decode continuously while model is ready
-                    var decodeCount = 0
-                    while recognizer.isReady() {
-                        recognizer.decode()
-                        decodeCount += 1
-                    }
-
-                    // If utterance endpoint detected
-                    if recognizer.isEndpoint() {
-                        let result = recognizer.getResult()
-                        let finalText = result.text.trimmingCharacters(in: .whitespacesAndNewlines)
-
-                        if !finalText.isEmpty {
-                            handleTranscriptionResult(text: finalText, isFinal: true)
-                        }
-
-                        recognizer.reset() // Start new utterance
-                        lastPartialResult = ""
-                    } else {
-                        // Emit partial results if changed
-                        let result = recognizer.getResult()
-                        let partial = result.text.trimmingCharacters(in: .whitespacesAndNewlines)
-
-                        if partial != lastPartialResult, !partial.isEmpty {
-                            handleTranscriptionResult(text: partial, isFinal: false)
-                            lastPartialResult = partial
-                        }
-                    }
-                } catch {
-                    Bridge.log("❌ Error processing audio: \(error.localizedDescription)")
-                }
-            } else {
-                // Sleep briefly to avoid tight CPU loop if no audio is available
-                Thread.sleep(forTimeInterval: 0.01)
+        guard worker.isCurrent(generation) else { return }
+        let text = recognizer.getResult().text.trimmingCharacters(in: .whitespacesAndNewlines)
+        if recognizer.isEndpoint() {
+            if !text.isEmpty {
+                handleTranscriptionResult(text: text, isFinal: true, generation: generation)
             }
+            recognizer.reset()
+            session.lastPartialResult = ""
+        } else if !text.isEmpty, text != session.lastPartialResult {
+            handleTranscriptionResult(text: text, isFinal: false, generation: generation)
+            session.lastPartialResult = text
         }
-
-        Bridge.log("ASR processing thread stopped")
     }
 
     /**
@@ -377,45 +271,11 @@ class SherpaOnnxTranscriber {
         return samples
     }
 
-    /**
-     * Stop transcription processing.
-     * This shuts down the processing thread and releases Sherpa-ONNX resources.
-     */
     func shutdown() {
-        Bridge.log("🛑 Shutting down SherpaOnnxTranscriber...")
-
-        isRunning = false
-        processingTask?.cancel()
-
-        // Synchronize access to recognizer during shutdown
-        objc_sync_enter(self)
-        defer { objc_sync_exit(self) }
-
-        // The recognizer will be automatically cleaned up by ARC when set to nil
-        if recognizer != nil {
-            Bridge.log("🧹 Cleaning up Sherpa-ONNX recognizer")
-            recognizer = nil
-        }
-
-        // Clear any remaining audio buffers
-        pcmQueue.sync {
-            let remainingBuffers = self.pcmBuffers.count
-            if remainingBuffers > 0 {
-                Bridge.log("🗑️ Clearing \(remainingBuffers) remaining audio buffers")
-            }
-            self.pcmBuffers.removeAll()
-        }
-
-        Bridge.log("✅ SherpaOnnxTranscriber shutdown complete")
+        worker.setActive(false)
     }
 
-    /**
-     * Restarts the transcriber after a model change.
-     * Shuts down existing resources, clears buffers, and reinitializes the recognizer.
-     */
     func restart() {
-        Bridge.log("♻️ Restarting SherpaOnnxTranscriber...")
-        shutdown()
-        initialize()
+        worker.restart()
     }
 }

package/ios/Source/utils/DemandDrivenAudioWorker.swift

@@ -0,0 +1,150 @@
+import Foundation
+
+/// Owns a processor on one serial queue. Empty queues schedule no recurring work.
+/// Demand changes invalidate queued audio/results immediately; creation, processing,
+/// and destruction finish in order without blocking the caller (including the UI).
+final class DemandDrivenAudioWorker<Processor> {
+    struct Snapshot {
+        let active: Bool
+        let initialized: Bool
+        let processing: Bool
+        let queuedBuffers: Int
+        let processedBuffers: UInt64
+        let droppedBuffers: UInt64
+    }
+
+    private let lock = NSLock()
+    private let queue: DispatchQueue
+    private let capacity: Int
+    private let makeProcessor: () -> Processor?
+    private let process: (Processor, Data, UInt64) -> Void
+    private var active = false
+    private var generation: UInt64 = 0
+    private var buffers = [Data]()
+    private var scheduled = false
+    private var initialized = false
+    private var processing = false
+    private var processedBuffers: UInt64 = 0
+    private var droppedBuffers: UInt64 = 0
+
+    // Accessed only on queue, including release of the previous processor.
+    private var processor: Processor?
+    private var processorGeneration: UInt64?
+    private var attemptedInitialization = false
+
+    init(capacity: Int = 100,
+         queue: DispatchQueue = DispatchQueue(label: "com.mentra.speech.processor", qos: .userInitiated),
+         makeProcessor: @escaping () -> Processor?,
+         process: @escaping (Processor, Data, UInt64) -> Void)
+    {
+        precondition(capacity > 0)
+        self.capacity = capacity
+        self.queue = queue
+        self.makeProcessor = makeProcessor
+        self.process = process
+    }
+
+    func setActive(_ value: Bool) {
+        lock.lock()
+        defer { lock.unlock() }
+        guard active != value else { return }
+        active = value
+        invalidateLocked()
+    }
+
+    /// Reload a changed model only if there is still local-transcription demand.
+    func restart() {
+        lock.lock()
+        defer { lock.unlock() }
+        invalidateLocked()
+    }
+
+    private func invalidateLocked() {
+        generation &+= 1
+        buffers.removeAll(keepingCapacity: true)
+        initialized = false
+        scheduleLocked()
+    }
+
+    func accept(_ data: Data) {
+        guard !data.isEmpty else { return }
+        lock.lock()
+        defer { lock.unlock() }
+        guard active else { return }
+        // Bound even audio arriving while model loading or decoding is blocked.
+        if buffers.count == capacity {
+            buffers.removeFirst()
+            droppedBuffers &+= 1
+        }
+        buffers.append(data)
+        scheduleLocked()
+    }
+
+    func isCurrent(_ token: UInt64) -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        return active && generation == token
+    }
+
+    func snapshot() -> Snapshot {
+        lock.lock()
+        defer { lock.unlock() }
+        return Snapshot(active: active, initialized: initialized, processing: processing,
+                        queuedBuffers: buffers.count, processedBuffers: processedBuffers,
+                        droppedBuffers: droppedBuffers)
+    }
+
+    private func scheduleLocked() {
+        guard !scheduled else { return }
+        scheduled = true
+        queue.async { self.drain() }
+    }
+
+    private func drain() {
+        while true {
+            lock.lock()
+            let token = generation
+            if processorGeneration != token {
+                lock.unlock()
+                // ARC destruction stays serialized with inference and model loading.
+                processor = nil
+                processorGeneration = token
+                attemptedInitialization = false
+                continue
+            }
+            guard active else {
+                scheduled = false
+                lock.unlock()
+                return
+            }
+            if !attemptedInitialization {
+                attemptedInitialization = true
+                lock.unlock()
+                processor = makeProcessor()
+                lock.lock()
+                if generation == token { initialized = processor != nil }
+                lock.unlock()
+                continue
+            }
+            guard let processor else {
+                buffers.removeAll(keepingCapacity: true)
+                scheduled = false
+                lock.unlock()
+                return // Missing model: retry on a demand transition or model restart.
+            }
+            guard !buffers.isEmpty else {
+                scheduled = false
+                lock.unlock()
+                return
+            }
+            let data = buffers.removeFirst()
+            processing = true
+            lock.unlock()
+            process(processor, data, token)
+            lock.lock()
+            processedBuffers &+= 1
+            processing = false
+            lock.unlock()
+        }
+    }
+}

package/ios/Tests/DemandDrivenAudioWorkerTests.swift

@@ -0,0 +1,157 @@
+import Foundation
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class DemandDrivenAudioWorkerTests: XCTestCase {
+    private final class Processor {
+        let onRelease: () -> Void
+        init(onRelease: @escaping () -> Void = {}) {
+            self.onRelease = onRelease
+        }
+
+        deinit { onRelease() }
+    }
+
+    func testNoDemandAndEmptyActiveQueueScheduleNoRecurringWork() {
+        let queue = DispatchQueue(label: "test.speech")
+        var creations = 0
+        var processed = [Data]()
+        let worker = DemandDrivenAudioWorker(queue: queue, makeProcessor: {
+            creations += 1
+            return Processor()
+        }, process: { _, data, _ in processed.append(data) })
+        worker.accept(Data([1]))
+        queue.sync {}
+        XCTAssertEqual(creations, 0)
+        worker.setActive(true)
+        worker.setActive(true)
+        queue.sync {}
+        XCTAssertEqual(creations, 1)
+        XCTAssertTrue(worker.snapshot().initialized)
+        XCTAssertFalse(worker.snapshot().processing)
+        // A serial barrier completes with an empty queue; no sleeping consumer holds it.
+        queue.sync {}
+        XCTAssertTrue(processed.isEmpty)
+        worker.setActive(false)
+        queue.sync {}
+        XCTAssertFalse(worker.snapshot().initialized)
+    }
+
+    func testFirstAudioIsRetainedDuringAsynchronousInitializationAndBounded() {
+        let queue = DispatchQueue(label: "test.speech")
+        let loading = DispatchSemaphore(value: 0)
+        let release = DispatchSemaphore(value: 0)
+        var processed = [Data]()
+        let worker = DemandDrivenAudioWorker(capacity: 3, queue: queue, makeProcessor: {
+            XCTAssertFalse(Thread.isMainThread)
+            loading.signal()
+            release.wait()
+            return Processor()
+        }, process: { _, data, _ in processed.append(data) })
+        worker.setActive(true)
+        XCTAssertEqual(loading.wait(timeout: .now() + 2), .success)
+        worker.accept(Data([1]))
+        worker.accept(Data([2]))
+        XCTAssertEqual(worker.snapshot().queuedBuffers, 2)
+        release.signal()
+        queue.sync {}
+        XCTAssertEqual(processed, [Data([1]), Data([2])])
+        worker.setActive(false)
+        queue.sync {}
+    }
+
+    func testStopDuringLoadingDropsOldAudioAndCannotResurrectProcessor() {
+        let queue = DispatchQueue(label: "test.speech")
+        let loading = DispatchSemaphore(value: 0)
+        let release = DispatchSemaphore(value: 0)
+        var released = 0
+        var processed = 0
+        let worker = DemandDrivenAudioWorker(capacity: 2, queue: queue, makeProcessor: {
+            loading.signal()
+            release.wait()
+            return Processor { released += 1 }
+        }, process: { _, _, _ in processed += 1 })
+        worker.setActive(true)
+        XCTAssertEqual(loading.wait(timeout: .now() + 2), .success)
+        for byte: UInt8 in 1 ... 10 {
+            worker.accept(Data([byte]))
+        }
+        XCTAssertEqual(worker.snapshot().queuedBuffers, 2)
+        XCTAssertEqual(worker.snapshot().droppedBuffers, 8)
+        worker.setActive(false)
+        XCTAssertEqual(worker.snapshot().queuedBuffers, 0)
+        release.signal()
+        queue.sync {}
+        XCTAssertEqual(processed, 0)
+        XCTAssertEqual(released, 1)
+        XCTAssertFalse(worker.snapshot().initialized)
+    }
+
+    func testRestartAndRapidDemandChangesSerializeOldAndNewProcessors() {
+        let queue = DispatchQueue(label: "test.speech")
+        let processing = DispatchSemaphore(value: 0)
+        let release = DispatchSemaphore(value: 0)
+        var creations = 0
+        var destructions = 0
+        var tokens = [UInt64]()
+        var dataSeen = [Data]()
+        let worker = DemandDrivenAudioWorker(queue: queue, makeProcessor: {
+            XCTAssertEqual(creations, destructions)
+            creations += 1
+            return Processor { destructions += 1 }
+        }, process: { _, data, token in
+            dataSeen.append(data)
+            tokens.append(token)
+            if data == Data([1]) {
+                processing.signal()
+                release.wait()
+            }
+        })
+        worker.setActive(true)
+        worker.accept(Data([1]))
+        XCTAssertEqual(processing.wait(timeout: .now() + 2), .success)
+        worker.accept(Data([2]))
+        worker.restart()
+        worker.setActive(false)
+        worker.setActive(true)
+        worker.accept(Data([3]))
+        release.signal()
+        queue.sync {}
+        XCTAssertEqual(dataSeen, [Data([1]), Data([3])])
+        XCTAssertFalse(worker.isCurrent(tokens[0]))
+        XCTAssertTrue(worker.isCurrent(tokens[1]))
+        XCTAssertEqual(creations, 2)
+        worker.setActive(false)
+        queue.sync {}
+        XCTAssertEqual(destructions, 2)
+        XCTAssertFalse(worker.isCurrent(tokens[1]))
+    }
+
+    func testMissingModelDoesNotRetryEveryFrameAndRestartWithoutDemandDoesNotLoad() {
+        let queue = DispatchQueue(label: "test.speech")
+        var attempts = 0
+        let worker = DemandDrivenAudioWorker<Processor>(queue: queue, makeProcessor: {
+            attempts += 1
+            return nil
+        }, process: { _, _, _ in XCTFail("Missing processor") })
+        worker.restart()
+        queue.sync {}
+        XCTAssertEqual(attempts, 0)
+        worker.setActive(true)
+        for _ in 0 ..< 5 {
+            worker.accept(Data([1]))
+            queue.sync {}
+        }
+        XCTAssertEqual(attempts, 1)
+        XCTAssertEqual(worker.snapshot().queuedBuffers, 0)
+        worker.restart()
+        queue.sync {}
+        XCTAssertEqual(attempts, 2)
+        worker.setActive(false)
+        worker.setActive(true)
+        queue.sync {}
+        XCTAssertEqual(attempts, 3)
+        worker.setActive(false)
+        queue.sync {}
+    }
+}

package/ios/Tests/NimoDiscoveryTests.swift

@@ -0,0 +1,79 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+@MainActor
+final class NimoDiscoveryTests: XCTestCase {
+    @MainActor
+    private final class Radio {
+        var connected: [String] = []
+        var events: [String] = []
+        var found: [String] = []
+        var selected: String?
+        lazy var discovery: NimoDiscovery<String> = NimoDiscovery(
+            register: { [unowned self] in self.events.append("register") },
+            connected: { [unowned self] in self.events.append("retrieve"); return self.connected },
+            scan: { [unowned self] in self.events.append("scan") },
+            stop: { [unowned self] in self.events.append("stop") },
+            name: { $0 },
+            found: { [unowned self] _, name, _ in
+                found.append(name)
+                if selected == name { discovery.cancel() }
+            }
+        )
+    }
+
+    func testAlreadyConnectedClassicDeviceIsFoundWithoutAdvertisement() {
+        let radio = Radio()
+        radio.connected = ["NIMO_1234", "NIMO_1234_BLE", "Unrelated"]
+        radio.discovery.start()
+        XCTAssertEqual(radio.events, ["register", "retrieve", "scan"])
+        XCTAssertEqual(radio.found, ["NIMO_1234"])
+    }
+
+    func testPairingInSettingsAfterScanStartedDeliversDevice() {
+        let radio = Radio()
+        radio.discovery.start()
+        XCTAssertTrue(radio.found.isEmpty)
+        // Same entry point as connectionEventDidOccur(.peerConnected).
+        radio.discovery.receive("NIMO_5678")
+        XCTAssertEqual(radio.found, ["NIMO_5678"])
+    }
+
+    func testSelectionFromConnectedSnapshotStopsBeforeStartingBleScan() {
+        let radio = Radio()
+        radio.selected = "NIMO_5678"
+        radio.connected = ["NIMO_1234", "NIMO_5678", "NIMO_9999"]
+        radio.discovery.start()
+        XCTAssertEqual(radio.found, ["NIMO_1234", "NIMO_5678"])
+        XCTAssertEqual(radio.events, ["register", "retrieve", "stop"])
+        XCTAssertFalse(radio.discovery.active)
+    }
+
+    func testCancelledDiscoveryIgnoresQueuedEventsAndCanRestart() {
+        let radio = Radio()
+        radio.discovery.start()
+        radio.discovery.cancel()
+        radio.discovery.receive("NIMO_1234")
+        XCTAssertTrue(radio.found.isEmpty)
+        radio.connected = ["NIMO_1234"]
+        radio.discovery.start()
+        XCTAssertEqual(radio.found, ["NIMO_1234"])
+    }
+
+    func testBleFallbackUsesAdvertisementNameAndPreservesSignalStrength() {
+        var found: [String] = []
+        var signal: Int?
+        let discovery = NimoDiscovery<String>(
+            register: {}, connected: { [] }, scan: {}, stop: {}, name: { _ in nil },
+            found: { _, name, rssi in found.append(name); signal = rssi }
+        )
+        discovery.start()
+        discovery.receive("uuid", advertisedName: "NiMo_1234_bLe", rssi: -60)
+        discovery.receive("uuid", advertisedName: "Unrelated", rssi: -60)
+        discovery.receive("uuid")
+        XCTAssertTrue(found.isEmpty)
+        discovery.receive("uuid", advertisedName: "NiMo_1234", rssi: -55)
+        XCTAssertEqual(found, ["NiMo_1234"])
+        XCTAssertEqual(signal, -55)
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/bluetooth-sdk",
-  "version": "3.2.1-beta.476",
+  "version": "3.2.1-beta.481",
   "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.2.1-beta.476"
+    "@mentra/cloud-protocol": "3.2.1-beta.481"
   },
   "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.2.1",
-  "releaseIdentity": "3.2.1-beta.476",
-  "releaseSetId": "mentra-3.2.1-beta.476",
-  "sourceCommit": "19a7b950cfb00d6a988c174a9206d553a1b7b766",
-  "otaManifestUrl": "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.476.json",
-  "otaManifestSha256": "7124ab690088031a8ab55eb8b56c0d3074bdf4acc15197e5ddf07e37a77122c2"
+  "releaseIdentity": "3.2.1-beta.481",
+  "releaseSetId": "mentra-3.2.1-beta.481",
+  "sourceCommit": "c3269f1bc026d0b1967e8f18cae271c0ef396c11",
+  "otaManifestUrl": "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.481.json",
+  "otaManifestSha256": "be95e7f2ec85c32d385f66ed8d1c319320e1b5f61f59ea3d1d76199f269834ea"
 })