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

package/ios/Tests/VersionInfoResponseAccumulatorTests.swift

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

package/ios/Tests/WifiRequestResolutionTests.swift

@@ -0,0 +1,320 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class WifiRequestResolutionTests: XCTestCase {
+    @MainActor
+    func testUnsupportedControllerDoesNotClaimWifiDispatch() {
+        let keys = ["fullyBooted", "connected", "connectionState", "micEnabled", "voiceActivityDetectionEnabled", "bluetoothClassicConnected"]
+        let snapshot = keys.compactMap { key in DeviceStore.shared.get("glasses", key).map { (key, $0) } }
+        defer { for (key, value) in snapshot {
+            DeviceStore.shared.apply("glasses", key, value)
+        } }
+        let controller: SGCManager = Simulated()
+        XCTAssertFalse(controller.forgetWifiNetwork("AP", requestId: nil, sid: nil))
+        XCTAssertFalse(controller.forgetWifiNetwork("AP", requestId: "request", sid: "sid"))
+        XCTAssertFalse(controller.requestSavedWifiNetworks(requestId: "request", sid: "sid"))
+    }
+
+    func testFutureFractionalAndMalformedCapabilitiesAreUnsupportedNotLegacy() {
+        for version in [0, 2, -1, 1.5, "1", true, NSNull()] as [Any] {
+            let capabilities = WifiSessionCapabilities()
+            capabilities.reset(sessionId: "sid")
+            capabilities.applyVersionInfo1(["wifiForgetResultVersion": version, "savedWifiNetworksVersion": version])
+            XCTAssertEqual(capabilities.forgetMode(), .unsupported)
+            XCTAssertEqual(capabilities.savedNetworksMode(), .unsupported)
+        }
+        let missingSession = WifiSessionCapabilities()
+        missingSession.applyVersionInfo1(["wifiForgetResultVersion": 1])
+        XCTAssertEqual(missingSession.forgetMode(), .unsupported)
+    }
+
+    func testRawResponseRejectsPartialTuplesAndCoercionBeforeNormalization() {
+        let tuple: [String: Any] = ["protocol_version": 1, "requestId": "request", "sid": "sid"]
+        XCTAssertTrue(wifiResponseEnvelopeIsValid(tuple, allowLegacy: false))
+        for key in tuple.keys {
+            XCTAssertFalse(wifiResponseEnvelopeIsValid(tuple.filter { $0.key != key }, allowLegacy: true))
+        }
+        for version in [0, 2, 1.5, "1", true, NSNull()] as [Any] {
+            var malformed = tuple
+            malformed["protocol_version"] = version
+            XCTAssertFalse(wifiResponseEnvelopeIsValid(malformed, allowLegacy: true))
+        }
+        XCTAssertFalse(wifiResponseEnvelopeIsValid(tuple.merging(["connected": 0]) { _, new in new }, allowLegacy: true))
+        XCTAssertFalse(wifiResponseEnvelopeIsValid(tuple.merging(["dispatched": true]) { _, new in new }, allowLegacy: true))
+        XCTAssertTrue(wifiResponseEnvelopeIsValid(["dispatched": true], allowLegacy: true))
+        XCTAssertFalse(wifiResponseEnvelopeIsValid(["requestId": "", "dispatched": true], allowLegacy: true))
+        XCTAssertFalse(wifiResponseEnvelopeIsValid([:], allowLegacy: false))
+    }
+
+    func testSemanticResultsOmitTransportMetadata() throws {
+        let data: [String: Any] = ["requestId": "request", "sid": "sid", "protocolVersion": 1,
+                                   "ssid": "AP", "outcome": "confirmed", "networks": ["AP"]]
+        let forbidden: Set = ["mode", "capabilityVersion", "requestId", "sid", "protocolVersion"]
+        let forget = try XCTUnwrap(parseWifiForgetResult(expectedRequestId: "request", expectedSid: "sid", expectedSsid: "AP", capabilityVersion: 1, data: data))
+        let saved = try XCTUnwrap(parseSavedWifiNetworks(expectedRequestId: "request", expectedSid: "sid", capabilityVersion: 1, data: data))
+        XCTAssertTrue(Set(forget.values.keys).isDisjoint(with: forbidden))
+        XCTAssertTrue(Set(saved.values.keys).isDisjoint(with: forbidden))
+        for version in [1.5, true] as [Any] {
+            var malformed = data
+            malformed["protocolVersion"] = version
+            XCTAssertNil(parseWifiForgetResult(expectedRequestId: "request", expectedSid: "sid", expectedSsid: "AP", capabilityVersion: 1, data: malformed))
+            XCTAssertNil(parseSavedWifiNetworks(expectedRequestId: "request", expectedSid: "sid", capabilityVersion: 1, data: malformed))
+        }
+    }
+
+    @MainActor
+    func testPendingResponseCancellationResumesExactlyOnceWithoutTimeout() async {
+        let pending = PendingResponse<Int>(operation: "WiFi capability negotiation")
+        let waiter = Task { @MainActor in
+            try await pending.wait(timeoutMs: nil)
+        }
+        await Task.yield()
+
+        waiter.cancel()
+
+        do {
+            _ = try await waiter.value
+            XCTFail("Expected cancellation")
+        } catch let error as BluetoothSdkError {
+            XCTAssertEqual(error.code, "request_cancelled")
+        } catch {
+            XCTFail("Unexpected error: \(error)")
+        }
+        pending.resolve(42)
+        do {
+            _ = try await pending.wait(timeoutMs: nil)
+            XCTFail("Late resolve must not replace the cancellation result")
+        } catch let error as BluetoothSdkError {
+            XCTAssertEqual(error.code, "request_cancelled")
+        } catch {
+            XCTFail("Unexpected error: \(error)")
+        }
+    }
+
+    func testCapabilitiesAreUnknownPerSessionUntilVersionInfoFinalizesThem() {
+        let capabilities = WifiSessionCapabilities()
+        capabilities.reset(sessionId: "sid-1")
+
+        XCTAssertEqual(capabilities.forgetResult, .unknown)
+        XCTAssertEqual(capabilities.savedNetworks, .unknown)
+        capabilities.applyVersionInfo1(["sid": "sid-1", "wifiForgetResultVersion": 1])
+
+        XCTAssertEqual(capabilities.forgetResult, .supported(version: 1))
+        XCTAssertEqual(capabilities.savedNetworks, .legacy)
+        XCTAssertEqual(capabilities.forgetMode(), .modern)
+        XCTAssertEqual(capabilities.savedNetworksMode(), .legacy)
+    }
+
+    func testNewSessionResetsCapabilitiesAndAdvancesEpoch() {
+        let capabilities = WifiSessionCapabilities()
+        capabilities.reset(sessionId: "sid-1")
+        capabilities.applyVersionInfo1([
+            "wifiForgetResultVersion": 1,
+            "savedWifiNetworksVersion": 1,
+        ])
+        let oldEpoch = capabilities.epoch
+
+        capabilities.reset(sessionId: "sid-2")
+
+        XCTAssertGreaterThan(capabilities.epoch, oldEpoch)
+        XCTAssertEqual(capabilities.sessionId, "sid-2")
+        XCTAssertEqual(capabilities.forgetResult, .unknown)
+        XCTAssertEqual(capabilities.savedNetworks, .unknown)
+    }
+
+    func testSsidValidationRejectsBlankInputWithoutChangingIdentity() {
+        XCTAssertFalse(wifiSsidIsValid("   "))
+        XCTAssertTrue(wifiSsidIsValid(" Field AP "))
+    }
+
+    func testForgetResultRequiresExactIdSessionSsidAndProtocol() {
+        let exact: [String: Any] = [
+            "requestId": "forget-1",
+            "sid": "sid-1",
+            "ssid": " Field AP ",
+            "protocolVersion": 1,
+            "outcome": "dispatched",
+            "connected": false,
+        ]
+
+        XCTAssertNil(parseWifiForgetResult(
+            expectedRequestId: "other", expectedSid: "sid-1", expectedSsid: " Field AP ",
+            capabilityVersion: 1, data: exact
+        ))
+        XCTAssertNil(parseWifiForgetResult(
+            expectedRequestId: "forget-1", expectedSid: "sid-1", expectedSsid: " Field AP ",
+            capabilityVersion: 1, data: exact.filter { $0.key != "requestId" }
+        ))
+        XCTAssertNil(parseWifiForgetResult(
+            expectedRequestId: "forget-1", expectedSid: "other", expectedSsid: " Field AP ",
+            capabilityVersion: 1, data: exact
+        ))
+        XCTAssertNil(parseWifiForgetResult(
+            expectedRequestId: "forget-1", expectedSid: "sid-1", expectedSsid: "Field AP",
+            capabilityVersion: 1, data: exact
+        ))
+        XCTAssertNil(parseWifiForgetResult(
+            expectedRequestId: "forget-1", expectedSid: "sid-1", expectedSsid: " Field AP ",
+            capabilityVersion: 2, data: exact
+        ))
+        XCTAssertEqual(
+            parseWifiForgetResult(
+                expectedRequestId: "forget-1", expectedSid: "sid-1", expectedSsid: " Field AP ",
+                capabilityVersion: 1, data: exact
+            )?.outcome,
+            .dispatched
+        )
+    }
+
+    func testForgetParserPreservesEveryHonestTerminalOutcome() {
+        for outcome in ["confirmed", "dispatched", "not_found", "unsupported", "failed"] {
+            let parsed = parseWifiForgetResult(
+                expectedRequestId: "forget-1",
+                expectedSid: "sid-1",
+                expectedSsid: "AP",
+                capabilityVersion: 1,
+                data: [
+                    "requestId": "forget-1",
+                    "sid": "sid-1",
+                    "ssid": "AP",
+                    "protocolVersion": 1,
+                    "outcome": outcome,
+                ]
+            )
+            XCTAssertEqual(parsed?.outcome.rawValue, outcome)
+        }
+    }
+
+    func testMissingConnectivitySnapshotRemainsUnknown() {
+        let parsed = parseWifiForgetResult(
+            expectedRequestId: "forget-1",
+            expectedSid: "sid-1",
+            expectedSsid: "AP",
+            capabilityVersion: 1,
+            data: [
+                "requestId": "forget-1",
+                "sid": "sid-1",
+                "ssid": "AP",
+                "protocolVersion": 1,
+                "outcome": "dispatched",
+            ]
+        )
+
+        XCTAssertNil(parsed?.connected)
+        XCTAssertNil(parsed?.values["connected"])
+    }
+
+    func testLegacyForgetIsExplicitlyUnverified() {
+        let result = legacyWifiForgetResult(
+            ssid: "AP"
+        )
+
+        XCTAssertTrue(Set(result.values.keys).isDisjoint(with: ["mode", "capabilityVersion", "requestId", "sid"]))
+        XCTAssertEqual(result.outcome, .legacyUnverified)
+        XCTAssertNil(result.connected)
+        XCTAssertNil(result.currentSsid)
+        XCTAssertNil(result.localIp)
+    }
+
+    func testSavedListPreservesIdentityAndRequiresCorrelationTuple() {
+        let exact: [String: Any] = [
+            "requestId": "saved-1",
+            "sid": "sid-1",
+            "protocolVersion": 1,
+            "outcome": "confirmed",
+            "networks": [" Field AP ", "", "Field AP", " Field AP "],
+        ]
+
+        XCTAssertNil(parseSavedWifiNetworks(
+            expectedRequestId: "other", expectedSid: "sid-1", capabilityVersion: 1, data: exact
+        ))
+        XCTAssertNil(parseSavedWifiNetworks(
+            expectedRequestId: "saved-1", expectedSid: "sid-1", capabilityVersion: 1,
+            data: exact.filter { $0.key != "requestId" }
+        ))
+        XCTAssertNil(parseSavedWifiNetworks(
+            expectedRequestId: "saved-1", expectedSid: "other", capabilityVersion: 1, data: exact
+        ))
+        XCTAssertNil(parseSavedWifiNetworks(
+            expectedRequestId: "saved-1", expectedSid: "sid-1", capabilityVersion: 2, data: exact
+        ))
+        XCTAssertEqual(
+            parseSavedWifiNetworks(
+                expectedRequestId: "saved-1", expectedSid: "sid-1", capabilityVersion: 1, data: exact
+            )?.networks,
+            [" Field AP ", "Field AP"]
+        )
+
+        var failure = exact
+        failure["outcome"] = "failed"
+        failure["error"] = "backend_failed"
+        failure["networks"] = [String]()
+        let parsedFailure = parseSavedWifiNetworks(
+            expectedRequestId: "saved-1",
+            expectedSid: "sid-1",
+            capabilityVersion: 1,
+            data: failure
+        )
+        XCTAssertEqual(parsedFailure?.outcome, .failed)
+        XCTAssertEqual(parsedFailure?.error, "backend_failed")
+    }
+
+
+    func testRawForgetEventPreservesModernAndLegacyWireTruth() {
+        let modern = normalizeWifiForgetResultEvent(
+            requestId: "forget-1",
+            sid: "sid-1",
+            ssid: "AP",
+            protocolVersion: 1,
+            outcome: "dispatched",
+            legacyDispatched: nil,
+            connected: false,
+            currentSsid: "",
+            localIp: "",
+            error: nil
+        )
+        let legacy = normalizeWifiForgetResultEvent(
+            requestId: "",
+            sid: "",
+            ssid: "AP",
+            protocolVersion: 0,
+            outcome: "",
+            legacyDispatched: true,
+            connected: false,
+            currentSsid: "",
+            localIp: "",
+            error: nil
+        )
+        let withoutSnapshot = normalizeWifiForgetResultEvent(
+            requestId: "forget-unknown",
+            sid: "sid-1",
+            ssid: "AP",
+            protocolVersion: 1,
+            outcome: "dispatched",
+            legacyDispatched: nil,
+            connected: nil,
+            currentSsid: "",
+            localIp: "",
+            error: nil
+        )
+
+        XCTAssertEqual(modern?["mode"] as? String, "modern")
+        XCTAssertEqual(modern?["outcome"] as? String, "dispatched")
+        XCTAssertEqual(legacy?["mode"] as? String, "legacy")
+        XCTAssertEqual(legacy?["dispatched"] as? Bool, true)
+        XCTAssertNil(legacy?["sid"])
+        XCTAssertNil(withoutSnapshot?["connected"])
+        XCTAssertNil(normalizeWifiForgetResultEvent(
+            requestId: "bad",
+            sid: "",
+            ssid: "AP",
+            protocolVersion: 0,
+            outcome: "",
+            legacyDispatched: nil,
+            connected: false,
+            currentSsid: "",
+            localIp: "",
+            error: nil
+        ))
+    }
+}

package/package.json

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

package/src/BluetoothSdk.types.ts

@@ -128,6 +128,68 @@ export type WifiStatusChangeEvent = WifiStatus & {
   error?: string
 }
 
+export type WifiForgetOutcome =
+  | "confirmed"
+  | "dispatched"
+  | "not_found"
+  | "unsupported"
+  | "failed"
+  | "legacy_unverified"
+
+export type WifiForgetResult = {
+  ssid: string
+  outcome: WifiForgetOutcome
+  connected?: boolean
+  currentSsid?: string
+  localIp?: string
+  error?: string
+}
+
+export type ModernWifiForgetResultEvent = {
+  type: "wifi_forget_result"
+  mode: "modern"
+  requestId: string
+  sid: string
+  ssid: string
+  protocolVersion: number
+  outcome: Exclude<WifiForgetOutcome, "legacy_unverified">
+  connected?: boolean
+  currentSsid?: string
+  localIp?: string
+  error?: string
+}
+
+export type LegacyWifiForgetResultEvent = {
+  type: "wifi_forget_result"
+  mode: "legacy"
+  ssid: string
+  dispatched: boolean
+  connected?: boolean
+  currentSsid?: string
+  localIp?: string
+  error?: string
+}
+
+export type WifiForgetResultEvent = ModernWifiForgetResultEvent | LegacyWifiForgetResultEvent
+
+export type SavedWifiNetworksOutcome = "confirmed" | "unsupported" | "failed"
+
+export type SavedWifiNetworksResult = {
+  outcome: SavedWifiNetworksOutcome
+  networks: string[]
+  error?: string
+}
+
+export type SavedWifiNetworksEvent = {
+  type: "saved_wifi_networks"
+  requestId: string
+  sid: string
+  protocolVersion: number
+  outcome: SavedWifiNetworksOutcome
+  networks: string[]
+  error?: string
+}
+
 export type HotspotStatus = {state: "disabled"} | {state: "enabled"; ssid: string; password: string; localIp: string}
 
 export type EnabledHotspotStatus = Extract<HotspotStatus, {state: "enabled"}>
@@ -147,6 +209,8 @@ export type HotspotErrorEvent = {
 }
 
 export type VersionInfoResult = {
+  versionInfoType?: string
+  sid?: string
   androidVersion: string
   firmwareVersion: string
   besFirmwareVersion: string
@@ -169,6 +233,10 @@ export type VersionInfoResult = {
   packageName?: string
   /** Phone-served hotspot OTA protocol version; 0 means unsupported/legacy glasses. */
   hotspotOtaVersion: number
+  /** Session-correlated WiFi forget result protocol; absent/0 means unsupported. */
+  wifiForgetResultVersion?: number
+  /** Session-correlated saved-network listing protocol; absent/0 means unsupported. */
+  savedWifiNetworksVersion?: number
 }
 
 export type VersionInfoEvent = VersionInfoResult & {
@@ -930,6 +998,8 @@ export type BluetoothSdkModuleEvents = {
   phone_notification_dismissed: (event: PhoneNotificationDismissedEvent) => void
   wifi_status_change: (event: WifiStatusChangeEvent) => void
   wifi_scan_result: (event: WifiScanResultEvent) => void
+  wifi_forget_result: (event: WifiForgetResultEvent) => void
+  saved_wifi_networks: (event: SavedWifiNetworksEvent) => void
   hotspot_status_change: (event: HotspotStatusChangeEvent) => void
   hotspot_error: (event: HotspotErrorEvent) => void
   photo_response: (event: PhotoResponseEvent) => void
@@ -1090,6 +1160,8 @@ export type BluetoothSdkEventMap = {
   local_transcription: LocalTranscriptionEvent
   wifi_status_change: WifiStatusChangeEvent
   wifi_scan_result: WifiScanResultEvent
+  wifi_forget_result: WifiForgetResultEvent
+  saved_wifi_networks: SavedWifiNetworksEvent
   hotspot_status_change: HotspotStatusChangeEvent
   hotspot_error: HotspotErrorEvent
   photo_response: PhotoResponseEvent
@@ -1182,8 +1254,11 @@ export interface BluetoothSdkPublicModule {
   ping(): Promise<void>
 
   requestWifiScan(): Promise<WifiSearchResult[]>
+  /** List exact WiFi SSIDs from glasses that support reliable saved-network enumeration. */
+  getSavedWifiNetworks(): Promise<SavedWifiNetworksResult>
   sendWifiCredentials(ssid: string, password: string): Promise<WifiStatusChangeEvent>
-  forgetWifiNetwork(ssid: string): Promise<WifiStatusChangeEvent>
+  /** Forget a saved network and return its correlated semantic outcome. */
+  forgetWifiNetwork(ssid: string): Promise<WifiForgetResult>
   setHotspotState(enabled: boolean): Promise<HotspotStatusChangeEvent>
   /** Set the glasses clock from the phone after an OTA clock-skew failure. */
   setSystemTime(timestampMs: number): Promise<void>

package/src/_private/BluetoothSdkModule.ts

@@ -55,6 +55,8 @@ import {
   VideoRecordingStatusEvent,
   VersionInfoResult,
   WarmUpCameraParams,
+  SavedWifiNetworksResult,
+  WifiForgetResult,
   WifiSearchResult,
   WifiStatusChangeEvent,
 } from "../BluetoothSdk.types"
@@ -125,8 +127,9 @@ declare class BluetoothSdkNativeModule extends NativeModule<BluetoothSdkModuleEv
 
   // WiFi Commands
   requestWifiScan(): Promise<WifiSearchResult[]>
+  getSavedWifiNetworks(): Promise<SavedWifiNetworksResult>
   sendWifiCredentials(ssid: string, password: string): Promise<WifiStatusChangeEvent>
-  forgetWifiNetwork(ssid: string): Promise<WifiStatusChangeEvent>
+  forgetWifiNetwork(ssid: string): Promise<WifiForgetResult>
   setHotspotState(enabled: boolean): Promise<HotspotStatusChangeEvent>
   /** Enable or disable Wi-Fi ADB on Mentra Live (no-op on other devices). */
   setWifiAdbState(enabled: boolean): Promise<void>

package/src/generated/changelogCatalog.ts

@@ -3,7 +3,7 @@ export const GENERATED_RELEASE_CHANGELOGS = Object.freeze(
 [
   {
     "version": "3.2.0",
-    "markdown": "This release is under active development. User-facing changes will be documented as they land."
+    "markdown": "This release is under active development. User-facing changes will be documented as they land.\n\n- Breaking Bluetooth SDK change: `forgetWifiNetwork(ssid)` now returns `WifiForgetResult` instead of `WifiStatusChangeEvent`. Migrate status-only consumers to the semantic `outcome`; the requested network remains `ssid`, while optional post-command connectivity is reported by `connected`, `currentSsid`, and `localIp`."
   },
   {
     "version": "3.1.0",

package/src/generated/releaseMetadata.ts

@@ -12,9 +12,9 @@ export interface BluetoothSdkReleaseMetadata {
 export const BLUETOOTH_SDK_RELEASE_METADATA: Readonly<BluetoothSdkReleaseMetadata> = Object.freeze({
   "schemaVersion": 1,
   "familyBaseVersion": "3.2.0",
-  "releaseIdentity": "3.2.0-dev.195",
-  "releaseSetId": "mentra-3.2.0-dev.195",
-  "sourceCommit": "321202ca96ec1852be19a7230ebcc3593fe87e54",
-  "otaManifestUrl": "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.195.json",
-  "otaManifestSha256": "70f26063b2c281b9b046965f6f6d7ca22f8b53242c6c5be02030c5a04c7115e4"
+  "releaseIdentity": "3.2.0-dev.203",
+  "releaseSetId": "mentra-3.2.0-dev.203",
+  "sourceCommit": "7eb4deefff27d498c2b4562d628607f399aa1f40",
+  "otaManifestUrl": "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.203.json",
+  "otaManifestSha256": "0ae026238c8e70970be4e181cc1ae73dd905418292edebddb610012f4f0a9b6f"
 })