@mentra/bluetooth-sdk 3.2.0-dev.266 → 3.2.1-beta.312

package/ios/Source/utils/AudioRouteObservation.swift

@@ -0,0 +1,54 @@
+import Combine
+import Foundation
+
+/// Keeps audio readiness observable before microphone capture has been started.
+final class AudioRouteObservation {
+    private var subscriptions = Set<AnyCancellable>()
+    private var pendingRecheck: DispatchWorkItem?
+    private var generation = 0
+    private let settlingDelays: [TimeInterval]
+    private let onChange: () -> Void
+
+    init(
+        center: NotificationCenter = .default,
+        names: [Notification.Name],
+        settlingDelays: [TimeInterval] = [0.2, 0.3, 0.5],
+        onChange: @escaping () -> Void
+    ) {
+        self.settlingDelays = settlingDelays
+        self.onChange = onChange
+        for name in names {
+            center.publisher(for: name)
+                .receive(on: DispatchQueue.main)
+                .sink { [weak self] _ in self?.refresh() }
+                .store(in: &subscriptions)
+        }
+    }
+
+    deinit {
+        pendingRecheck?.cancel()
+    }
+
+    /// Start a new settling window for a route, foreground, or selected-device
+    /// change. The callback must read the current target and route each time.
+    func refresh() {
+        dispatchPrecondition(condition: .onQueue(.main))
+        pendingRecheck?.cancel()
+        generation += 1
+        reconcile(generation: generation, nextDelay: 0)
+    }
+
+    private func reconcile(generation: Int, nextDelay: Int) {
+        guard generation == self.generation else { return }
+        onChange()
+        // availableInputs can lag the notification, including after removal.
+        // Reconcile at 200, 500, and 1000 ms even if the first read was ready.
+        // A reentrant refresh also supersedes this window.
+        guard generation == self.generation, nextDelay < settlingDelays.count else { return }
+        let recheck = DispatchWorkItem { [weak self] in
+            self?.reconcile(generation: generation, nextDelay: nextDelay + 1)
+        }
+        pendingRecheck = recheck
+        DispatchQueue.main.asyncAfter(deadline: .now() + settlingDelays[nextDelay], execute: recheck)
+    }
+}

package/ios/Source/utils/AudioSessionMonitor.swift

@@ -6,9 +6,10 @@
 //  Used to detect when Mentra Live glasses are paired/connected for audio
 //
 
+import Foundation
+
 #if !os(macOS)
 import AVFoundation
-import Foundation
 import UIKit
 
 class AudioSessionMonitor {
@@ -57,11 +58,14 @@ class AudioSessionMonitor {
         Bridge.log("AudioMonitor: Checking active route, output count: \(outputs.count)")
         for output in outputs {
             Bridge.log("AudioMonitor:   - \(output.portName) (type: \(output.portType.rawValue))")
-            if output.portType == .bluetoothHFP || output.portType == .bluetoothA2DP {
-                if output.portName.localizedCaseInsensitiveContains(devicePattern) {
-                    Bridge.log("AudioMonitor: ✅ Found active audio device: \(output.portName)")
-                    return true
-                }
+            if BluetoothAudioRoute.matches(
+                name: output.portName,
+                portType: output.portType.rawValue,
+                target: devicePattern,
+                isIOSAppOnMac: ProcessInfo.processInfo.isiOSAppOnMac
+            ) {
+                Bridge.log("AudioMonitor: ✅ Found active audio device: \(output.portName)")
+                return true
             }
         }
 
@@ -283,3 +287,13 @@ class AudioSessionMonitor {
     }
 }
 #endif
+
+/// AVAudioSession preserves the route name on iOS-on-Mac but reports the
+/// CoreAudio transport "Bluetooth" instead of iPhone's profile-specific port.
+enum BluetoothAudioRoute {
+    static func matches(name: String, portType: String, target: String, isIOSAppOnMac: Bool) -> Bool {
+        guard !target.isEmpty, name.localizedCaseInsensitiveContains(target) else { return false }
+        return portType == "BluetoothHFP" || portType == "BluetoothA2DPOutput"
+            || (isIOSAppOnMac && portType == "Bluetooth")
+    }
+}

package/ios/Tests/AudioRouteObservationTests.swift

@@ -0,0 +1,142 @@
+import Foundation
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class AudioRouteObservationTests: XCTestCase {
+    @MainActor
+    func testInputsBecomingAvailableAfterNotificationAreReconciled() async {
+        let center = NotificationCenter()
+        let route = Notification.Name("test.audio.route")
+        var inputAvailable = false
+        var ready = false
+        let initialRead = expectation(description: "Initial unavailable input observed")
+        let changed = expectation(description: "Delayed input becomes ready without another event")
+        var firstRead = true
+        let observer = AudioRouteObservation(center: center, names: [route]) {
+            if firstRead {
+                firstRead = false
+                initialRead.fulfill()
+            }
+            if inputAvailable, !ready { changed.fulfill() }
+            ready = inputAvailable
+        }
+
+        center.post(name: route, object: nil)
+        await fulfillment(of: [initialRead], timeout: 2)
+        XCTAssertFalse(ready)
+        inputAvailable = true
+        await fulfillment(of: [changed], timeout: 1)
+        XCTAssertTrue(ready)
+        withExtendedLifetime(observer) {}
+    }
+
+    @MainActor
+    func testInitiallyReadyInputCanDisappearDuringSettling() async {
+        var inputAvailable = true
+        var ready = false
+        let disappeared = expectation(description: "Input removal observed during settling")
+        let observer = AudioRouteObservation(names: [], settlingDelays: [0.05, 0.05]) {
+            if ready, !inputAvailable { disappeared.fulfill() }
+            ready = inputAvailable
+        }
+        observer.refresh()
+        XCTAssertTrue(ready)
+        inputAvailable = false
+        await fulfillment(of: [disappeared], timeout: 2)
+        XCTAssertFalse(ready)
+        withExtendedLifetime(observer) {}
+    }
+
+    @MainActor
+    func testDeviceChangeReplacesPendingChecksAndReadsOnlyCurrentTarget() async {
+        var target = "first"
+        var availableInputs = Set<String>()
+        var observations: [(String, Bool)] = []
+        var secondChecks = 0
+        let settled = expectation(description: "Replacement window completed")
+        let observer = AudioRouteObservation(names: [], settlingDelays: [0.05, 0.05, 0.1]) {
+            observations.append((target, availableInputs.contains(target)))
+            if target == "second" {
+                secondChecks += 1
+                if secondChecks == 2 {
+                    // The old target is available, but its readiness must not leak.
+                    XCTAssertFalse(observations.contains { $0.1 })
+                    availableInputs.insert("second")
+                }
+                if secondChecks == 4 { settled.fulfill() }
+            }
+        }
+        observer.refresh()
+        target = "second"
+        observer.refresh() // Same entry point used by DeviceStore's device_name change.
+        availableInputs.insert("first")
+        await fulfillment(of: [settled], timeout: 2)
+        XCTAssertEqual(observations.filter { $0.0 == "first" }.count, 1)
+        XCTAssertEqual(observations.filter { $0.0 == "second" }.count, 4)
+        XCTAssertEqual(observations.last?.0, "second")
+        XCTAssertEqual(observations.last?.1, true)
+        withExtendedLifetime(observer) {}
+    }
+
+    @MainActor
+    func testUnavailableInputStopsRecheckingAfterBoundedWindow() async {
+        var checks = 0
+        let settled = expectation(description: "Immediate read and two scheduled rechecks completed")
+        let extraCheck = expectation(description: "No rechecks beyond the configured window")
+        extraCheck.isInverted = true
+        let observer = AudioRouteObservation(names: [], settlingDelays: [0.02, 0.02]) {
+            checks += 1
+            if checks == 3 { settled.fulfill() }
+            if checks > 3 { extraCheck.fulfill() }
+        }
+        observer.refresh()
+        await fulfillment(of: [settled], timeout: 2)
+        XCTAssertEqual(checks, 3)
+        await fulfillment(of: [extraCheck], timeout: 0.1)
+        XCTAssertEqual(checks, 3)
+        withExtendedLifetime(observer) {}
+    }
+
+    @MainActor
+    func testReleasingObserverCancelsPendingRechecks() async throws {
+        var checks = 0
+        var observer: AudioRouteObservation? = AudioRouteObservation(names: [], settlingDelays: [0.02]) {
+            checks += 1
+        }
+        observer?.refresh()
+        XCTAssertEqual(checks, 1)
+        observer = nil
+        try await Task.sleep(nanoseconds: 100_000_000)
+        XCTAssertEqual(checks, 1)
+    }
+
+    func testObservesRouteAndForegroundWithoutStartingAMicrophone() async {
+        let center = NotificationCenter()
+        let route = Notification.Name("test.audio.route")
+        let foreground = Notification.Name("test.audio.foreground")
+        let changed = expectation(description: "Both readiness events delivered")
+        changed.expectedFulfillmentCount = 2
+        let observer = AudioRouteObservation(center: center, names: [route, foreground]) {
+            XCTAssertTrue(Thread.isMainThread)
+            changed.fulfill()
+        }
+        center.post(name: route, object: nil)
+        center.post(name: foreground, object: nil)
+        await fulfillment(of: [changed], timeout: 1)
+        withExtendedLifetime(observer) {}
+    }
+
+    func testReleasingObserverStopsReadinessCallbacks() async {
+        let center = NotificationCenter()
+        let route = Notification.Name("test.audio.route")
+        let changed = expectation(description: "Released observer is silent")
+        changed.isInverted = true
+        var observer: AudioRouteObservation? = AudioRouteObservation(center: center, names: [route]) {
+            changed.fulfill()
+        }
+        XCTAssertNotNil(observer)
+        observer = nil
+        center.post(name: route, object: nil)
+        await fulfillment(of: [changed], timeout: 0.1)
+    }
+}

package/ios/Tests/BluetoothAudioRouteTests.swift

@@ -0,0 +1,37 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class BluetoothAudioRouteTests: XCTestCase {
+    func testRecognizesIPhoneProfiles() {
+        for port in ["BluetoothHFP", "BluetoothA2DPOutput"] {
+            XCTAssertTrue(BluetoothAudioRoute.matches(
+                name: "Mentra_Live_03BE", portType: port, target: "03BE", isIOSAppOnMac: false
+            ))
+        }
+    }
+
+    func testRecognizesObservedMacTransportOnlyOnMac() {
+        XCTAssertTrue(BluetoothAudioRoute.matches(
+            name: "Mentra_Live_03BE", portType: "Bluetooth", target: "mentra_live_03be", isIOSAppOnMac: true
+        ))
+        XCTAssertFalse(BluetoothAudioRoute.matches(
+            name: "Mentra_Live_03BE", portType: "Bluetooth", target: "03BE", isIOSAppOnMac: false
+        ))
+    }
+
+    func testRejectsDifferentGlassesAndMissingIdentity() {
+        for target in ["023B", ""] {
+            XCTAssertFalse(BluetoothAudioRoute.matches(
+                name: "Mentra_Live_03BE", portType: "Bluetooth", target: target, isIOSAppOnMac: true
+            ))
+        }
+    }
+
+    func testRejectsNonBluetoothDeviceWithMatchingName() {
+        for port in ["Speaker", "USBAudio", "BuiltInMic", ""] {
+            XCTAssertFalse(BluetoothAudioRoute.matches(
+                name: "Mentra_Live_03BE", portType: port, target: "03BE", isIOSAppOnMac: true
+            ))
+        }
+    }
+}

package/ios/Tests/GalleryServerCommandTests.swift

@@ -0,0 +1,87 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+/// Replace only the radio handoff; exercise the public SDK, device dispatch,
+/// command serialization, receive parser, event bridge, and pending request resolver.
+@MainActor
+private final class GalleryCommandTransport: MentraLive {
+    var respond: (([String: Any]) -> [[String: Any]])?
+    var requestIds: [String] = []
+
+    override func sendJson(_ jsonOriginal: [String: Any], wakeUp: Bool, requireAck: Bool) {
+        XCTAssertEqual(jsonOriginal["type"] as? String, "set_gallery_server_enabled")
+        XCTAssertTrue(wakeUp)
+        XCTAssertTrue(requireAck)
+        do {
+            let bytes = try JSONSerialization.data(withJSONObject: jsonOriginal)
+            let command = try XCTUnwrap(JSONSerialization.jsonObject(with: bytes) as? [String: Any])
+            try requestIds.append(XCTUnwrap(command["request_id"] as? String))
+            for response in respond?(command) ?? [] {
+                try processReceivedData(JSONSerialization.data(withJSONObject: response))
+            }
+        } catch {
+            XCTFail("Could not replay gallery command: \(error)")
+        }
+    }
+}
+
+@MainActor
+final class GalleryServerCommandTests: XCTestCase {
+    func testEnableOfflineEnableAndDisableRoundTripThroughNativeBridge() async throws {
+        let previous = DeviceManager.shared.sgc
+        let transport = GalleryCommandTransport()
+        DeviceManager.shared.sgc = transport
+        let sdk = MentraBluetoothSDK()
+        defer {
+            sdk.invalidate()
+            DeviceManager.shared.sgc = previous
+        }
+
+        for (enabled, listening) in [(true, true), (true, false), (false, false)] {
+            transport.respond = { command in
+                XCTAssertEqual(command["enabled"] as? Bool, enabled)
+                var response: [String: Any] = [
+                    "type": "settings_ack", "setting": "gallery_server", "status": "applied",
+                    "request_id": command["request_id"]!, "timestamp": 123,
+                    "enabled": enabled, "listening": listening,
+                ]
+                if listening { response["url"] = "http://10.1.2.3:8089" }
+                // A response to another request must not resolve this call.
+                var unrelated = response
+                unrelated["request_id"] = "unrelated-request"
+                unrelated["enabled"] = !enabled
+                return [unrelated, response]
+            }
+            let ack = try await sdk.setGalleryServerEnabled(enabled)
+            XCTAssertEqual(ack.enabled, enabled)
+            XCTAssertEqual(ack.listening, listening)
+            XCTAssertEqual(ack.url, listening ? "http://10.1.2.3:8089" : nil)
+            XCTAssertEqual(ack.requestId, transport.requestIds.last)
+        }
+        XCTAssertEqual(Set(transport.requestIds).count, 3)
+    }
+
+    func testStorageErrorRejectsThePublicSdkRequest() async {
+        let previous = DeviceManager.shared.sgc
+        let transport = GalleryCommandTransport()
+        DeviceManager.shared.sgc = transport
+        let sdk = MentraBluetoothSDK()
+        defer {
+            sdk.invalidate()
+            DeviceManager.shared.sgc = previous
+        }
+        transport.respond = { command in
+            [["type": "settings_ack", "setting": "gallery_server", "status": "error",
+              "request_id": command["request_id"]!, "error_code": "settings_unavailable",
+              "error_message": "Could not persist the gallery server setting."]]
+        }
+        do {
+            _ = try await sdk.setGalleryServerEnabled(true)
+            XCTFail("A failed save must reject the SDK request")
+        } catch let error as BluetoothSdkError {
+            XCTAssertEqual(error.code, "settings_unavailable")
+        } catch {
+            XCTFail("Unexpected error: \(error)")
+        }
+    }
+}

package/ios/Tests/WearTuningDispatchTests.swift

@@ -0,0 +1,51 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+/// Recording subclass used to prove wear methods dispatched through an
+/// `SGCManager?` hit MentraLive, not the extension no-op.
+@MainActor
+private final class RecordingMentraLive: MentraLive {
+    private(set) var calls: [String] = []
+
+    override func queryWearState() {
+        calls.append("queryWearState")
+    }
+
+    override func setWearReporting(_ enabled: Bool) {
+        calls.append("setWearReporting:\(enabled)")
+    }
+
+    override func setWearTuning(intervalMs: Int, count: Int, majority: Int) {
+        calls.append("setWearTuning:\(intervalMs),\(count),\(majority)")
+    }
+
+    override func requestWearTuning() {
+        calls.append("requestWearTuning")
+    }
+
+    override func resetWearTuning() {
+        calls.append("resetWearTuning")
+    }
+}
+
+@MainActor
+final class WearTuningDispatchTests: XCTestCase {
+    func testWearMethodsDispatchThroughSGCManagerReference() {
+        let live = RecordingMentraLive()
+        let sgc: (any SGCManager)? = live
+
+        sgc?.queryWearState()
+        sgc?.setWearReporting(true)
+        sgc?.setWearTuning(intervalMs: 300, count: 5, majority: 4)
+        sgc?.requestWearTuning()
+        sgc?.resetWearTuning()
+
+        XCTAssertEqual(live.calls, [
+            "queryWearState",
+            "setWearReporting:true",
+            "setWearTuning:300,5,4",
+            "requestWearTuning",
+            "resetWearTuning",
+        ])
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/bluetooth-sdk",
-  "version": "3.2.0-dev.266",
+  "version": "3.2.1-beta.312",
   "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.0-dev.266"
+    "@mentra/cloud-protocol": "3.2.1-beta.312"
   },
   "devDependencies": {
     "@types/node": "^25.9.3",

package/src/BluetoothSdk.types.ts

@@ -481,6 +481,84 @@ export type SwitchStatusEvent = {
   timestamp: number
 }
 
+/**
+ * Mentra Live center-mic gate + ADC gain overrides. Internal SDK surface: this
+ * is a super-mode tuning aid, not a public capability.
+ *
+ * Every field is optional; an omitted field keeps the firmware default. The
+ * glasses hold these in RAM only and drop them on disconnect, so the phone
+ * re-sends on every connect.
+ */
+export type MicTuning = {
+  /** codec_adc_vol index, 0-15. 15 is +32 dB, the top of the table. */
+  gain?: number
+  /** Gate open / close thresholds, linear RMS on int16 samples. */
+  open?: number
+  close?: number
+  /** Frames of 10 ms. */
+  attack?: number
+  hang?: number
+  /** Thresholds used while the speaker is active or within its hold-off. */
+  sp_open?: number
+  sp_close?: number
+  sp_hold?: number
+}
+
+/**
+ * What the glasses report as actually in force, after their own clamping. Use
+ * this rather than the requested value when showing applied settings.
+ */
+export type MicTuningStateEvent = MicTuning & {
+  type: "mic_tuning_state"
+  /** Tuning revision; increments on every accepted set or reset. */
+  generation: number
+  /** True when any override is in force. */
+  overridden: boolean
+}
+
+/** Live center-mic level. Disposable: samples are dropped under any pressure. */
+export type MicRmsEvent = {
+  type: "mic_rms"
+  rms: number
+  gateOpen: boolean
+  speakerElevated: boolean
+  /** Tuning revision the sample was measured under. */
+  generation: number
+}
+
+/**
+ * Mentra Live wear-detection vote. Internal SDK surface: Super Mode only.
+ * Values live in RAM on the glasses and reset on disconnect.
+ */
+export type WearTuning = {
+  /** Poll period in milliseconds. Firmware clamp: 50–2000. */
+  interval?: number
+  /** Sliding-window length. Firmware clamp: 3–15. */
+  count?: number
+  /** Votes needed to flip, either direction. Must be > count/2 and ≤ count. */
+  majority?: number
+}
+
+/** Current wear vote from sr_wrst, or an unsolicited wear transition. */
+export type WearStateEvent = {
+  type: "wear_state"
+  worn: boolean
+}
+
+/**
+ * What the wear poll loop is actually running. A rejected patch echoes the
+ * unchanged values with `accepted: false`.
+ */
+export type WearTuningEvent = WearTuning & {
+  type: "wear_tuning"
+  enabled: boolean
+  interval: number
+  count: number
+  majority: number
+  generation: number
+  accepted: boolean
+}
+
 export type RgbLedControlResponseEvent =
   | {
       type: "rgb_led_control_response"
@@ -499,6 +577,7 @@ export type RgbLedControlSuccessResponseEvent = Extract<RgbLedControlResponseEve
 export type SettingsAckStatus = "applied" | "ready" | "error" | "failed" | "failure" | "rejected"
 
 export type SettingsAckSetting =
+  | "gallery_server"
   | "gallery_mode"
   | "button_photo"
   | "button_video_recording"
@@ -524,6 +603,10 @@ export type SettingsAckEvent = {
   fps?: number
   enabled?: boolean
   minutes?: number
+  /** Current site-network listener state; present for gallery_server acknowledgements. */
+  listening?: boolean
+  /** Current HTTP base URL; present for gallery_server only while listening. */
+  url?: string
   /** ANR enabled flag; present when setting === "camera_tuning" */
   anr?: boolean
   /** Stock-gain flag; present when setting === "camera_tuning" */
@@ -1066,6 +1149,10 @@ export type BluetoothSdkModuleEvents = {
   heartbeat_received: (event: HeartbeatReceivedEvent) => void
   swipe_volume_status: (event: SwipeVolumeStatusEvent) => void
   switch_status: (event: SwitchStatusEvent) => void
+  mic_tuning_state: (event: MicTuningStateEvent) => void
+  mic_rms: (event: MicRmsEvent) => void
+  wear_state: (event: WearStateEvent) => void
+  wear_tuning: (event: WearTuningEvent) => void
   rgb_led_control_response: (event: RgbLedControlResponseEvent) => void
   settings_ack: (event: SettingsAckEvent) => void
   pair_failure: (event: PairFailureEvent) => void
@@ -1226,6 +1313,10 @@ export type BluetoothSdkEventMap = {
   compatible_glasses_search_stop: CompatibleGlassesSearchStopEvent
   swipe_volume_status: SwipeVolumeStatusEvent
   switch_status: SwitchStatusEvent
+  mic_tuning_state: MicTuningStateEvent
+  mic_rms: MicRmsEvent
+  wear_state: WearStateEvent
+  wear_tuning: WearTuningEvent
   rgb_led_control_response: RgbLedControlResponseEvent
   settings_ack: SettingsAckEvent
   pair_failure: PairFailureEvent
@@ -1317,6 +1408,12 @@ export interface BluetoothSdkPublicModule {
   /** Enable or disable Wi-Fi ADB on Mentra Live (no-op on other devices). */
   setWifiAdbState(enabled: boolean): Promise<void>
 
+  /**
+   * Persistently enable/disable unauthenticated HTTP gallery access on the glasses' Wi-Fi.
+   * Default off; survives reconnects/restarts until disabled. Only use on trusted networks.
+   * Returns saved enabled state plus current listening/url. No Wi-Fi means listening=false.
+   */
+  setGalleryServerEnabled(enabled: boolean): Promise<SettingsAckSuccessEvent>
   setGalleryModeEnabled(enabled: boolean): Promise<SettingsAckSuccessEvent>
   setVoiceActivityDetectionEnabled(enabled: boolean): Promise<void>
   setLoudnessGateEnabled(enabled: boolean): Promise<void>
@@ -1701,6 +1798,8 @@ export type BluetoothSettingsUpdate = Partial<{
   gallery_mode: boolean
   voice_activity_detection_enabled: boolean
   loudness_gate_enabled: boolean
+  /** Effective mic tuning only. `{}` means "reset to firmware defaults". */
+  mic_tuning: MicTuning
   button_photo_size: ButtonPhotoSize
   button_video_settings: {width: number; height: number; fps: number}
   button_video_width: number

package/src/_private/BluetoothSdkModule.ts

@@ -33,6 +33,7 @@ import {
   NativePhoneNotification,
   NativeNotificationConfig,
   NativeNotificationStatus,
+  MicTuning,
   ObservableStoreCategory,
   OtaQueryResult,
   OtaStartAckEvent,
@@ -139,10 +140,41 @@ declare class BluetoothSdkNativeModule extends NativeModule<BluetoothSdkModuleEv
   logCurrentWifiFrequency(): Promise<void>
 
   // Gallery Commands
+  setGalleryServerEnabled(enabled: boolean): Promise<SettingsAckSuccessEvent>
   setGalleryModeEnabled(enabled: boolean): Promise<SettingsAckSuccessEvent>
   setVoiceActivityDetectionEnabled(enabled: boolean): Promise<void>
   /** Mentra Live center-mic loudness / Barrier gate (cs_swit type 10). */
   setLoudnessGateEnabled(enabled: boolean): Promise<void>
+  /**
+   * Mentra Live mic tuning. `null` clears every override and returns the
+   * glasses to firmware defaults.
+   *
+   * Deliberately absent from the public SDK surface: it is a super-mode
+   * calibration aid whose values only make sense next to a live RMS readout.
+   */
+  setMicTuning(tuning: MicTuning | null): Promise<void>
+  /**
+   * Ask the glasses to report the tuning they are actually running. The answer
+   * arrives as a `mic_tuning_state` event, which is also emitted unprompted
+   * after every set, so a screen that subscribes on mount and calls this on
+   * focus never has to guess.
+   */
+  requestMicTuningState(): Promise<void>
+  /** Enable or disable the `mic_rms` readout. Auto-disabled on disconnect. */
+  setMicRmsTelemetry(enabled: boolean): Promise<void>
+  /**
+   * Mentra Live wear detection. Internal / Super Mode only.
+   *
+   * Reporting is RAM-only on the glasses and must not go through `cs_swit`
+   * type 1 (that bit is NV-backed). `resetWearTuning` both restores the
+   * firmware vote defaults and turns reporting off.
+   */
+  queryWearState(): Promise<void>
+  setWearReporting(enabled: boolean): Promise<void>
+  /** Negative values leave that field unchanged. */
+  setWearTuning(intervalMs: number, count: number, majority: number): Promise<void>
+  requestWearTuning(): Promise<void>
+  resetWearTuning(): Promise<void>
   /**
    * @deprecated Sticky action-button photo presets are deprecated. Prefer per-request
    * `requestPhoto(...)` options (e.g. `mode: "text"` for text sensor size/crop).
@@ -546,6 +578,22 @@ NativeBluetoothSdkModule.setLoudnessGateEnabled = function (enabled: boolean) {
   return this.updateBluetoothSettings({loudness_gate_enabled: enabled})
 }
 
+NativeBluetoothSdkModule.setMicTuning = function (tuning: MicTuning | null) {
+  // `{}` rather than null: the store drops null writes, and the native side
+  // reads an empty object as "no overrides" and sends an explicit reset.
+  return this.updateBluetoothSettings({mic_tuning: tuning ?? {}})
+}
+
+const nativeMicModule = NativeBluetoothSdkModule as unknown as Record<string, unknown>
+NativeBluetoothSdkModule.requestMicTuningState = bindNativeMethod<() => Promise<void>>(
+  nativeMicModule,
+  "requestMicTuningState",
+)
+NativeBluetoothSdkModule.setMicRmsTelemetry = bindNativeMethod<(enabled: boolean) => Promise<void>>(
+  nativeMicModule,
+  "setMicRmsTelemetry",
+)
+
 const nativeSetCameraFov = bindNativeMethod<(fov: CameraFovSetting) => MaybePromise<CameraFovResult>>(
   NativeBluetoothSdkModule as unknown as Record<string, unknown>,
   "setCameraFov",
@@ -630,7 +678,7 @@ const nativeStopScan = NativeBluetoothSdkModule.stopScan.bind(NativeBluetoothSdk
 const activeScanCancellations = new Set<() => Promise<void>>()
 NativeBluetoothSdkModule.stopScan = async function () {
   if (activeScanCancellations.size === 0) return nativeStopScan()
-  await Promise.all([...activeScanCancellations].map(cancel => cancel()))
+  await Promise.all([...activeScanCancellations].map((cancel) => cancel()))
 }
 
 NativeBluetoothSdkModule.scan = async function (modelOrOptions: DeviceModel | ScanOptions, options?: ScanModelOptions) {
@@ -678,5 +726,20 @@ NativeBluetoothSdkModule.startStream = function (params: StreamStartRequest) {
   return nativeStartStream(streamRequestParamsForNative(params) as unknown as StreamStartRequest)
 }
 
+const nativeWearModule = NativeBluetoothSdkModule as unknown as Record<string, unknown>
+NativeBluetoothSdkModule.queryWearState = bindNativeMethod<() => Promise<void>>(nativeWearModule, "queryWearState")
+NativeBluetoothSdkModule.setWearReporting = bindNativeMethod<(enabled: boolean) => Promise<void>>(
+  nativeWearModule,
+  "setWearReporting",
+)
+NativeBluetoothSdkModule.setWearTuning = bindNativeMethod<
+  (intervalMs: number, count: number, majority: number) => Promise<void>
+>(nativeWearModule, "setWearTuning")
+NativeBluetoothSdkModule.requestWearTuning = bindNativeMethod<() => Promise<void>>(
+  nativeWearModule,
+  "requestWearTuning",
+)
+NativeBluetoothSdkModule.resetWearTuning = bindNativeMethod<() => Promise<void>>(nativeWearModule, "resetWearTuning")
+
 export default NativeBluetoothSdkModule
 export const BluetoothSdk = NativeBluetoothSdkModule as BluetoothSdkInternalModule