@mentra/bluetooth-sdk 3.3.0-dev.517 → 3.3.0-dev.523

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/android/src/test/java/com/mentra/bluetoothsdk/sgcs/NimoCanvasCoordinatorTest.kt

@@ -51,6 +51,46 @@ class NimoCanvasCoordinatorTest {
         fun finishUpdate(frame: ByteArray) { repeat(NimoCanvasCodec.frames(4, frame, 20).size) { written() }; ack(4) }
     }
 
+    @Test fun notReadyRetriesLaunchPromptlyButStopsAfterThreeProbes() {
+        val f = Fixture(); f.canvas.activate(); f.canvas.readiness(true)
+        repeat(4) { attempt ->
+            f.written(); f.ack(1, 7)
+            val before = f.writes.size
+            f.clock.advance(999)
+            assertEquals(before, f.writes.size)
+            f.clock.advance(1)
+            assertEquals(before + if (attempt < 3) 1 else 0, f.writes.size)
+        }
+        f.clock.advance(60_000)
+        assertEquals(4, f.writes.size)
+        assertTrue(f.failures.isEmpty())
+    }
+
+    @Test fun pendingReadinessRetryIsCancelledOnDisconnectExitAndKnownReadinessLoss() {
+        for (stop in listOf("disconnect", "exit", "notReady")) {
+            val f = Fixture(); f.canvas.activate(); f.canvas.readiness(true)
+            f.written(); f.ack(1, 7)
+            when (stop) {
+                "disconnect" -> f.canvas.disconnected()
+                "exit" -> f.canvas.exit()
+                else -> f.canvas.readiness(false)
+            }
+            f.clock.advance(2_000)
+            assertEquals(1, f.writes.size)
+            assertTrue(f.failures.isEmpty())
+        }
+    }
+
+    @Test fun readinessHeartbeatCancelsPendingProbeAndDoesNotDuplicateLaunch() {
+        val f = Fixture(); f.canvas.activate(); f.canvas.readiness(true)
+        f.written(); f.ack(1, 7)
+        f.canvas.confirmedReadiness(true)
+        f.clock.advance(1_000)
+        assertEquals(2, f.writes.size)
+        f.written(); f.ack(1); f.finishUpdate(byteArrayOf(0, 0, 1))
+        assertTrue(f.failures.isEmpty())
+    }
+
     @Test fun bothNotificationDescriptorsGateCharacteristicWrites() {
         val f = Fixture()
         val rx = Any(); val mic = Any()
@@ -184,7 +224,7 @@ class NimoCanvasCoordinatorTest {
         val f = Fixture(); f.launch(); f.finishUpdate(byteArrayOf(0, 0, 1))
         f.canvas.exit()
         f.canvas.offer(byteArrayOf(1, 0, 1), "two:1")
-        assertFalse(f.canvas.nativeApp(0xFD, false))
+        f.canvas.nativeApp(0xFD, false)
         f.written()
         val before = f.writes.size
         f.ack(3)
@@ -192,15 +232,15 @@ class NimoCanvasCoordinatorTest {
         assertArrayEquals(NimoCanvasCodec.frames(1, writeCapacity = 20).single(), f.writes.last())
     }
 
-    @Test fun actualNativeTakeoverDuringExitInvalidatesEncodingAndDoesNotRelaunch() {
+    @Test fun nativeTakeoverDuringExitRetainsNewerSceneUntilExitAck() {
         val f = Fixture(); f.launch(); f.finishUpdate(byteArrayOf(0, 0, 1))
         f.canvas.exit()
         f.canvas.offer(byteArrayOf(1, 0, 1), "two:1")
-        assertTrue(f.canvas.nativeApp(0, true))
+        f.canvas.nativeApp(0, true)
         f.written()
         val before = f.writes.size
         f.ack(3)
-        assertEquals(before, f.writes.size)
+        assertEquals(before + 1, f.writes.size)
         assertTrue(f.failures.isEmpty())
     }
 

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

@@ -210,31 +210,100 @@ class NimoCanvasSessionTest {
     assertArrayEquals(frameB, send(success(session, 1)).frame)
   }
 
-  @Test fun actualNativeTakeoverDuringExitDiscardsNewerScene() {
+  @Test fun nativeReportDuringExitPreservesNewerHostScene() {
     val session = NimoCanvasSession()
     launched(session); success(session, 4)
     assertEquals(3, send(session.exit()).key)
     session.offer(frameB, "two:1")
     assertTrue(session.nativeApp(0, true).isEmpty())
-    assertTrue(success(session, 3).isEmpty())
+    assertEquals(1, send(success(session, 3)).key)
+    assertArrayEquals(frameB, send(success(session, 1)).frame)
+  }
+
+  @Test fun nativeTakeoverRestoresLatestSceneWithoutAnotherHostOffer() {
+    for (app in listOf(0, 0xFD)) {
+      val session = NimoCanvasSession()
+      launched(session); success(session, 4)
+      assertEquals(1, send(session.nativeApp(app, app != 0xFD)).key)
+      assertArrayEquals(frameA, send(success(session, 1)).frame)
+    }
+  }
+
+  @Test fun nativeTakeoverWaitsForCurrentAckInsteadOfOverlappingCommands() {
+    val session = NimoCanvasSession(); launched(session)
+    assertTrue(session.nativeApp(0, true).isEmpty())
+    session.offer(frameB, "one:1")
+    assertEquals(1, send(success(session, 4)).key)
+    assertTrue(session.nativeApp(0, true).isEmpty()) // Startup report during Launch.
+    assertArrayEquals(frameB, send(success(session, 1)).frame)
+  }
+
+  @Test fun takeoverDuringUpdateReplaysIdenticalFrameAfterRelaunch() {
+    val session = NimoCanvasSession(); launched(session)
+    assertTrue(session.nativeApp(0, true).isEmpty())
+    // The old Update ACK must not deduplicate the same scene on a new canvas.
+    assertEquals(1, send(success(session, 4)).key)
+    assertArrayEquals(frameA, send(success(session, 1)).frame)
+    assertTrue(success(session, 4).isEmpty())
+    assertTrue(session.offer(frameA, "one:1").isEmpty())
+  }
+
+  @Test fun startupStockUiDoesNotDiscardRetainedSceneBeforeReadiness() {
+    val session = NimoCanvasSession(); launched(session); success(session, 4)
     session.disconnected()
-    assertTrue(session.readiness(true).isEmpty())
+    assertTrue(session.nativeApp(0, true).isEmpty())
+    session.activate()
+    assertEquals(1, send(session.readiness(true)).key)
+    assertArrayEquals(frameA, send(success(session, 1)).frame)
   }
 
-  @Test fun nativeTakeoverSuppressesReplayUntilNewHostFrame() {
-    val session = NimoCanvasSession()
-    launched(session); success(session, 4)
+  @Test fun explicitExitStillReturnsControlToStockUiUntilNextConnection() {
+    val session = NimoCanvasSession(); launched(session); success(session, 4)
+    assertEquals(3, send(session.exit()).key)
     assertTrue(session.nativeApp(0, true).isEmpty())
-    assertTrue(session.readiness(true).isEmpty())
-    assertEquals(1, send(session.offer(frameA, "one:1")).key)
+    assertTrue(success(session, 3).isEmpty())
+    assertTrue(session.nativeApp(0, true).isEmpty())
+    session.disconnected(); session.activate()
+    assertEquals(1, send(session.readiness(true)).key)
+    assertArrayEquals(byteArrayOf(0, 0, 1), send(success(session, 1)).frame)
   }
 
-  @Test fun nativeTakeoverOrReadinessLossDuringCommandResets() {
-    for (takeover in listOf(true, false)) {
-      val session = NimoCanvasSession(); launched(session)
-      val actions = if (takeover) session.nativeApp(0, true) else session.readiness(false)
-      assertTrue(actions.single() is NimoCanvasSession.Action.Reconnect)
+  @Test fun activationLaunchesBlankCanvasWithoutAnyMiniapp() {
+    val session = NimoCanvasSession()
+    assertTrue(session.activate().isEmpty())
+    assertEquals(1, send(session.readiness(true)).key)
+    assertArrayEquals(byteArrayOf(0, 0, 1), send(success(session, 1)).frame)
+  }
+
+  @Test fun successfulUpdateRestoresProbeBudgetForNextRecovery() {
+    val session = NimoCanvasSession(); session.activate(); session.readiness(true)
+    repeat(2) { episode ->
+      if (episode > 0) assertEquals(1, send(session.nativeApp(0, true)).key)
+      repeat(3) {
+        session.response(1, byteArrayOf(7))
+        assertEquals(1, send(session.retryNotReady()).key)
+      }
+      assertEquals(4, send(success(session, 1)).key)
+      assertTrue(success(session, 4).isEmpty())
+    }
+  }
+
+  @Test fun notReadyProbesAreBoundedAndFreshHeartbeatStillRecovers() {
+    val session = NimoCanvasSession(); session.activate(); session.readiness(true)
+    repeat(3) {
+      session.response(1, byteArrayOf(7))
+      assertEquals(1, send(session.retryNotReady()).key)
     }
+    session.response(1, byteArrayOf(7))
+    repeat(5) { assertTrue(session.retryNotReady().isEmpty()) }
+    assertEquals(1, send(session.confirmedReadiness(true)).key)
+    assertEquals(4, send(success(session, 1)).key)
+  }
+
+  @Test fun lostReadinessDuringCommandStillResets() {
+    val session = NimoCanvasSession(); launched(session)
+    assertTrue(session.readiness(false).single() is NimoCanvasSession.Action.Reconnect)
+    assertTrue(session.retryNotReady().isEmpty())
   }
 
   @Test fun offersCopyMutableInputAndRejectOversizedFrame() {

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

@@ -0,0 +1,93 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import android.bluetooth.BluetoothGattCharacteristic
+import androidx.test.core.app.ApplicationProvider
+import com.mentra.bluetoothsdk.Bridge
+import com.mentra.bluetoothsdk.DeviceManager
+import com.mentra.bluetoothsdk.DeviceStore
+import org.junit.Assert.*
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.LooperMode
+import java.util.UUID
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33])
+@LooperMode(LooperMode.Mode.PAUSED)
+class NimoMicReconnectTest {
+    private val requests = listOf("should_send_lc3", "should_send_pcm", "should_send_transcript", "local_stt_fallback_active")
+
+    @Test fun sameAdapterReconnectRestartsTheStoppedAudioClientForRetainedConsumers() {
+        for (request in requests) withNimo { manager, device ->
+            DeviceStore.apply("bluetooth", request, true)
+            assertTrue(audioStarted(device))
+            repeat(3) {
+                resetLink(device)
+                assertFalse(audioStarted(device))
+                assertEquals(true, DeviceStore.get("bluetooth", request))
+                // This is the same adapter, not the replacement fake used by the manager tests.
+                DeviceStore.apply("glasses", "fullyBooted", true)
+                assertSame(device, manager.sgc)
+                assertTrue("Readiness must restart Nimo decoding without waiting for the watchdog", audioStarted(device))
+            }
+        }
+    }
+
+    @Test fun consumerStoppingDuringLinkLossDoesNotRestartAudio() = withNimo { _, device ->
+        DeviceStore.apply("bluetooth", "should_send_pcm", true)
+        assertTrue(audioStarted(device))
+        resetLink(device)
+        DeviceStore.apply("bluetooth", "should_send_pcm", false)
+        DeviceStore.apply("glasses", "fullyBooted", true)
+        assertFalse(audioStarted(device))
+        assertEquals(false, DeviceStore.get("glasses", "micEnabled"))
+    }
+
+    private fun resetLink(device: Nimo) {
+        // Exercise the production reset called by the GATT disconnect callback.
+        Nimo::class.java.getDeclaredMethod("resetSessionState").apply { isAccessible = true }.invoke(device)
+        DeviceStore.apply("glasses", "fullyBooted", false)
+    }
+
+    private fun audioStarted(device: Nimo): Boolean {
+        val audio = Nimo::class.java.getDeclaredField("audioClient").apply { isAccessible = true }.get(device)
+        return audio.javaClass.getDeclaredField("started").apply { isAccessible = true }.getBoolean(audio)
+    }
+
+    private fun withNimo(block: (DeviceManager, Nimo) -> Unit) {
+        Bridge.initialize(ApplicationProvider.getApplicationContext())
+        val singleton = DeviceManager::class.java.getDeclaredField("_instance").apply { isAccessible = true }
+        val previous = singleton.get(null)
+        val saved = listOf("bluetooth", "glasses").associateWith { DeviceStore.store.getCategory(it) }
+        val manager = DeviceManager(initializeHardware = false)
+        singleton.set(null, manager)
+        val device = Nimo()
+        manager.sgc = device
+        // No radio/firmware: supply the discovered mic characteristic and inspect the real
+        // audio-client lifecycle. Codec output and BLE delivery still require a device test.
+        Nimo::class.java.getDeclaredField("micChar").apply { isAccessible = true }.set(
+            device, BluetoothGattCharacteristic(UUID.randomUUID(), BluetoothGattCharacteristic.PROPERTY_WRITE, 0)
+        )
+        requests.forEach { DeviceStore.set("bluetooth", it, false) }
+        DeviceStore.set("bluetooth", "micEnabled", false)
+        DeviceStore.set("bluetooth", "micRanking", listOf("glasses"))
+        DeviceStore.set("glasses", "micEnabled", false)
+        DeviceStore.set("glasses", "fullyBooted", false)
+        try {
+            block(manager, device)
+        } finally {
+            device.cleanup()
+            manager.sgc = null
+            manager.cleanup()
+            singleton.set(null, previous)
+            saved.forEach { (category, values) ->
+                DeviceStore.store.getCategory(category).keys.filter { it !in values }.forEach {
+                    DeviceStore.store.remove(category, it)
+                }
+                values.forEach { (key, value) -> DeviceStore.set(category, key, value) }
+            }
+        }
+    }
+}

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

@@ -19,6 +19,17 @@ class NimoCrc16Test {
 }
 
 class NimoFrameCodecTest {
+    @Test
+    fun `system English and factory reset match firmware wire commands`() {
+        fun hex(bytes: ByteArray) = bytes.joinToString("") { "%02X".format(it.toInt() and 255) }
+        assertThat(hex(NimoFrameCodec.encodeFrame(NimoProtocol.CMD_SET_PARAMETER,
+            NimoProtocol.SET_SYSTEM_LANGUAGE, byteArrayOf(NimoProtocol.LANGUAGE_ENGLISH.toByte()))))
+            .isEqualTo("BF020500702500000324010001")
+        assertThat(hex(NimoFrameCodec.encodeFrame(NimoProtocol.CMD_CONTROL_FACTORY,
+            NimoProtocol.FACTORY_RECOVER, byteArrayOf())))
+            .isEqualTo("BF0204005358000008030000")
+    }
+
 
     @Test
     fun `transport header layout`() {

package/android/src/testDebug/java/com/mentra/bluetoothsdk/sgcs/NimoLifecycleTest.kt

@@ -1,5 +1,8 @@
 package com.mentra.bluetoothsdk.sgcs
 
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothGattCharacteristic
+import org.robolectric.shadows.ShadowBluetoothGatt
 import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.ContextWrapper
@@ -134,6 +137,97 @@ class NimoLifecycleTest {
     assertEquals(1, writes)
   }
 
+  @Test fun resetForUnpairOfflineDoesNotSendFactoryCommand() {
+    val results = mutableListOf<Boolean>()
+    nimo.resetForUnpair { results.add(it) }
+    assertEquals(listOf(false), results)
+  }
+
+  @Test fun explicitResetWaitsForMatchingAckAndCompletesOnlyOnce() {
+    val frames = readyForReset()
+    val results = mutableListOf<Boolean>()
+    nimo.resetForUnpair { results.add(it) }
+    Shadows.shadowOf(Looper.getMainLooper()).idle()
+    assertTrue(results.isEmpty())
+    assertArrayEquals(byteArrayOf(8, 3, 0, 0), frames.single().drop(8).toByteArray())
+    assertEquals(2, frames.single()[1].toInt())
+    respond(3, 1, 0)
+    assertTrue(results.isEmpty())
+    respond(8, 3, 0)
+    respond(8, 3, 0)
+    assertEquals(listOf(true), results)
+    Shadows.shadowOf(Looper.getMainLooper()).idleFor(6, TimeUnit.SECONDS)
+    assertEquals(listOf(true), results)
+  }
+
+  @Test fun resetTimeoutCompletesRatherThanLeavingUnpairWaitingForever() {
+    readyForReset()
+    val results = mutableListOf<Boolean>()
+    nimo.resetForUnpair { results.add(it) }
+    Shadows.shadowOf(Looper.getMainLooper()).idleFor(6, TimeUnit.SECONDS)
+    assertEquals(listOf(false), results)
+    respond(8, 3, 0)
+    assertEquals(listOf(false), results)
+  }
+
+  @Test fun passiveForgetNeverSendsFactoryReset() {
+    val frames = readyForReset()
+    nimo.forget()
+    assertTrue(frames.isEmpty())
+  }
+
+  @Test fun unbondTargetsOnlyTheSelectedNimo() {
+    val adapter = BluetoothAdapter.getDefaultAdapter()
+    val selected = adapter.getRemoteDevice("00:11:22:33:44:55")
+    val other = adapter.getRemoteDevice("00:11:22:33:44:66")
+    Shadows.shadowOf(selected).setCreatedBond(true)
+    Shadows.shadowOf(other).setCreatedBond(true)
+    Nimo.removeBluetoothBond(selected.address)
+    // Robolectric tracks removeBond through this flag, independently of bondState.
+    assertFalse(selected.createBond())
+    assertTrue(other.createBond())
+  }
+
+  private fun readyForReset(): MutableList<ByteArray> {
+    val frames = mutableListOf<ByteArray>()
+    val device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice("00:11:22:33:44:55")
+    val gatt = ShadowBluetoothGatt.newInstance(device)
+    setField("gatt", gatt)
+    setField("txChar", BluetoothGattCharacteristic(NimoBLE.CHAR_TX, 8, 16))
+    val state = Nimo::class.java.getDeclaredField("handshakeState")
+    setField("handshakeState", state.type.enumConstants.single { it.toString() == "READY" })
+    lateinit var queue: NimoGattQueue<BluetoothGattCharacteristic>
+    queue = NimoGattQueue(
+      NimoScheduler { delay, task ->
+        val handler = Handler(Looper.getMainLooper())
+        val pending = Runnable { task() }
+        handler.postDelayed(pending, delay)
+        val cancel: () -> Unit = { handler.removeCallbacks(pending) }
+        cancel
+      },
+      { characteristic, bytes ->
+        frames.add(bytes.copyOf())
+        Handler(Looper.getMainLooper()).post { queue.written(gatt, characteristic, true) }
+        true
+      },
+      { fail(it) },
+      NimoBLE.INTER_FRAME_DELAY_MS,
+    )
+    queue.connected(gatt)
+    setField("writes", queue)
+    return frames
+  }
+
+  private fun setField(name: String, value: Any) {
+    Nimo::class.java.getDeclaredField(name).apply { isAccessible = true }.set(nimo, value)
+  }
+
+  private fun respond(cmd: Int, key: Int, status: Int) {
+    Nimo::class.java.getDeclaredMethod("handleResponse", Int::class.javaPrimitiveType,
+      Int::class.javaPrimitiveType, Int::class.javaPrimitiveType, ByteArray::class.java)
+      .apply { isAccessible = true }.invoke(nimo, cmd, key, status, byteArrayOf())
+  }
+
   private fun runOffMain(operation: () -> Unit) {
     val failure = AtomicReference<Throwable?>()
     val caller = Thread({

package/android/src/testDebug/java/com/mentra/bluetoothsdk/sgcs/NimoReadinessDriverTest.kt

@@ -121,25 +121,31 @@ class NimoReadinessDriverTest {
     assertTrue(failures.isEmpty())
   }
 
-  @Test fun unknownPeerCannotLaunchFromHandshakeOrTwsOnlyReports() {
-    canvas.offer(byteArrayOf(0, 0, 1), "initial")
+  @Test fun freshHandshakeProbesCanvasWithoutWaitingForHeartbeat() {
     finishHandshake(peer = null)
-    assertKeys()
-    emit(packet(6, 3, byteArrayOf(0, 1)))
     assertNull(field("peerCompanionReady").get(nimo))
+    assertKeys(1) // Firmware validates peer readiness, not a synthetic heartbeat.
+    emit(packet(6, 2, byteArrayOf(0, 0, 1))) // Stock dashboard entering at startup.
+    assertKeys(1)
+    emit(packet(7, 1, byteArrayOf(0, 0xFD.toByte())))
+    assertKeys(1, 4)
+    assertArrayEquals(NimoCanvasCodec.frames(4, byteArrayOf(0, 0, 1), 512).single(), frames.last())
+    assertTrue(failures.isEmpty())
+  }
+
+  @Test fun knownDisconnectedPeerStillBlocksUntilReadinessArrives() {
+    finishHandshake(peer = false)
     assertKeys()
-    emit(heartbeat(peer = 0))
-    assertEquals(false, field("peerCompanionReady").get(nimo))
+    emit(packet(6, 3, byteArrayOf(0, 1)))
     assertKeys()
     emit(heartbeat())
-    assertEquals(true, field("peerCompanionReady").get(nimo))
     assertKeys(1)
     assertTrue(failures.isEmpty())
   }
 
   @Test fun queuedOldGattAndWrongServiceCannotEstablishReadiness() {
     canvas.offer(byteArrayOf(0, 0, 1), "initial")
-    finishHandshake(peer = null)
+    finishHandshake(peer = false)
     val oldGatt = currentGatt
     queue(heartbeat(), oldGatt)
     currentGatt = newGatt()
@@ -147,7 +153,7 @@ class NimoReadinessDriverTest {
     idle() // The generation check must occur when the queued callback executes.
     emit(heartbeat(), oldGatt)
     emit(heartbeat(), currentGatt, characteristic(UUID.fromString("00001234-0000-1000-8000-00805f9b34fb")))
-    assertNull(field("peerCompanionReady").get(nimo))
+    assertEquals(false, field("peerCompanionReady").get(nimo))
     assertKeys()
 
     emit(heartbeat()) // Positive control through the actual current RX callback.

package/build/BluetoothSdk.types.d.ts

@@ -1341,6 +1341,8 @@ export interface OtaProgress {
     errorMessage?: string;
 }
 export interface GlassesStatus {
+    /** iOS G2 arm still disconnected after a three-second partial link; cleared on reset or both links. */
+    g2MissingArm?: "left" | "right" | null;
     connection: GlassesConnectionStatus;
     micEnabled: boolean;
     voiceActivityDetectionEnabled: boolean;