@glassly/engine 0.3.3-dev.670 → 0.3.4-beta.689

package/src/services/STTModelManager.ts

@@ -2,6 +2,8 @@ import BluetoothSdk from "@glassly/bluetooth-sdk"
 import {Platform} from "react-native"
 import * as RNFS from "@dr.pogodin/react-native-fs"
 
+export type SttModelType = "transducer" | "ctc" | "nemotron" | "apple"
+
 export interface LanguageInfo {
   code: string
   displayName: string
@@ -9,7 +11,7 @@ export interface LanguageInfo {
   language: string
   downloaded: boolean
   path?: string
-  type: "transducer" | "ctc" | "nemotron"
+  type: SttModelType
 }
 
 export interface DownloadProgress {
@@ -30,19 +32,39 @@ export interface LanguageConfig {
   fileName: string
   downloadUrl?: string
   size: number
-  type: "transducer" | "ctc" | "nemotron"
+  type: SttModelType
   requiredFiles: string[]
   languageCode: string
 }
 
 const DEFAULT_LANGUAGE = "en"
 
+/**
+ * Apple SpeechTranscriber entries are keyed `apple:<bcp47>`; the same string is
+ * what native stores as the model path, since the OS owns the assets and there
+ * is no directory to point at.
+ */
+export const APPLE_STT_PREFIX = "apple:"
+
+export function isAppleSttCode(code: string): boolean {
+  return code.startsWith(APPLE_STT_PREFIX)
+}
+
+/** SpeechTranscriber ships with iOS 26. */
+export function appleSttSupported(): boolean {
+  return Platform.OS === "ios" && parseInt(String(Platform.Version), 10) >= 26
+}
+
 class STTModelManager {
   private static instance: STTModelManager
   private downloadJobId?: number
   private currentLanguage = DEFAULT_LANGUAGE
   private modelReadyListeners = new Set<() => void>()
   private modelBaseUrl = "https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/"
+  /** Apple locales reported by the OS, refreshed on each list load. */
+  private appleLanguages: Record<string, LanguageConfig> = {}
+  private appleInstalled = new Set<string>()
+  private appleRefresh: Promise<void> | null = null
 
   private languages: Record<string, LanguageConfig> = {
     "en": {
@@ -188,7 +210,10 @@ class STTModelManager {
     try {
       const path = await BluetoothSdk.getSttModelPath()
       const code = path && path.length > 0 ? this.getLanguageFromPath(path) : ""
-      if (code && this.languages[code]) {
+      if (code && isAppleSttCode(code)) {
+        await this.refreshAppleLanguages()
+      }
+      if (code && this.config(code)) {
         this.currentLanguage = code
         return code
       }
@@ -204,18 +229,59 @@ class STTModelManager {
   }
 
   setCurrentLanguage(code: string): void {
-    if (this.languages[code]) {
+    if (this.config(code)) {
       this.currentLanguage = code
     }
   }
 
   getBcp47ForLanguage(code?: string): string {
     const id = code || this.currentLanguage
-    return this.languages[id]?.languageCode ?? "en-US"
+    return this.config(id)?.languageCode ?? "en-US"
   }
 
+  /** Sherpa models first, then whatever Apple locales the last refresh reported. */
   getAvailableLanguages(): LanguageConfig[] {
-    return Object.values(this.languages)
+    return [...Object.values(this.languages), ...Object.values(this.appleLanguages)]
+  }
+
+  private config(code: string): LanguageConfig | undefined {
+    return this.languages[code] ?? this.appleLanguages[code]
+  }
+
+  /**
+   * Re-read the Apple locale list and install states from the OS. A no-op below
+   * iOS 26 and on Android, where the Apple section simply never appears.
+   */
+  async refreshAppleLanguages(): Promise<void> {
+    if (!appleSttSupported()) return
+    if (this.appleRefresh) return this.appleRefresh
+    this.appleRefresh = (async () => {
+      try {
+        const rows = await BluetoothSdk.getAppleSpeechLocales()
+        const next: Record<string, LanguageConfig> = {}
+        const installed = new Set<string>()
+        for (const row of rows) {
+          const code = APPLE_STT_PREFIX + row.code
+          next[code] = {
+            code,
+            displayName: row.name,
+            fileName: "",
+            size: 0,
+            type: "apple",
+            requiredFiles: [],
+            languageCode: row.code,
+          }
+          if (row.status === "installed") installed.add(code)
+        }
+        this.appleLanguages = next
+        this.appleInstalled = installed
+      } catch (error) {
+        console.warn("STTModelManager: Apple locale refresh failed:", error)
+      } finally {
+        this.appleRefresh = null
+      }
+    })()
+    return this.appleRefresh
   }
 
   getModelDirectory(): string {
@@ -225,6 +291,7 @@ class STTModelManager {
 
   getModelPath(code?: string): string {
     const id = code || this.currentLanguage
+    if (isAppleSttCode(id)) return id
     return `${this.getModelDirectory()}/${id}`
   }
 
@@ -236,6 +303,14 @@ class STTModelManager {
   async isModelAvailable(code?: string): Promise<boolean> {
     try {
       const id = code || this.currentLanguage
+      if (isAppleSttCode(id)) {
+        if (!appleSttSupported()) return false
+        const status = await BluetoothSdk.getAppleSpeechLocaleStatus(id.slice(APPLE_STT_PREFIX.length))
+        const installed = status === "installed"
+        if (installed) this.appleInstalled.add(id)
+        else this.appleInstalled.delete(id)
+        return installed
+      }
       const language = this.languages[id]
       if (!language) return false
 
@@ -258,7 +333,7 @@ class STTModelManager {
 
   async getLanguageInfo(code?: string): Promise<LanguageInfo> {
     const id = code || this.currentLanguage
-    const language = this.languages[id]
+    const language = this.config(id)
     if (!language) {
       throw new Error(`Language ${id} not found`)
     }
@@ -282,15 +357,61 @@ class STTModelManager {
     for (const code of Object.keys(this.languages)) {
       infos.push(await this.getLanguageInfo(code))
     }
+    // One OS round-trip covers every Apple row's install state.
+    await this.refreshAppleLanguages()
+    for (const language of Object.values(this.appleLanguages)) {
+      const downloaded = this.appleInstalled.has(language.code)
+      infos.push({
+        code: language.code,
+        displayName: language.displayName,
+        size: 0,
+        language: language.languageCode,
+        downloaded,
+        path: downloaded ? language.code : undefined,
+        type: "apple",
+      })
+    }
     return infos
   }
 
+  /** Downloads the Apple locale's assets through the OS, surfacing its progress as a download. */
+  private async installAppleModel(
+    code: string,
+    onProgress?: (progress: DownloadProgress) => void,
+    onExtractionProgress?: (progress: ExtractionProgress) => void,
+  ): Promise<void> {
+    if (!appleSttSupported()) {
+      throw new Error("Apple on-device speech requires iOS 26")
+    }
+    const locale = code.slice(APPLE_STT_PREFIX.length)
+    const subscription = BluetoothSdk.addListener("apple_speech_install_progress", (event) => {
+      if (event.locale !== locale) return
+      onProgress?.({jobId: 0, bytesWritten: 0, contentLength: 0, percentage: event.percentage})
+    })
+    try {
+      const status = await BluetoothSdk.installAppleSpeechLocale(locale)
+      if (status !== "installed") {
+        throw new Error(`Apple speech assets for ${locale} are ${status}`)
+      }
+    } finally {
+      subscription.remove()
+    }
+    onExtractionProgress?.({percentage: 100})
+    this.appleInstalled.add(code)
+    if (code === this.currentLanguage) {
+      await this.setNativeModelPath(code, locale)
+    }
+  }
+
   async downloadModel(
     code?: string,
     onProgress?: (progress: DownloadProgress) => void,
     onExtractionProgress?: (progress: ExtractionProgress) => void,
   ): Promise<void> {
     const id = code || this.currentLanguage
+    if (isAppleSttCode(id)) {
+      return this.installAppleModel(id, onProgress, onExtractionProgress)
+    }
     const language = this.languages[id]
     if (!language) {
       throw new Error(`Language ${id} not found`)
@@ -383,6 +504,14 @@ class STTModelManager {
 
   async deleteModel(code?: string): Promise<void> {
     const id = code || this.currentLanguage
+    if (isAppleSttCode(id)) {
+      // The OS owns the assets; only the app's reservation can be dropped.
+      this.appleInstalled.delete(id)
+      if (appleSttSupported()) {
+        await BluetoothSdk.releaseAppleSpeechLocale(id.slice(APPLE_STT_PREFIX.length))
+      }
+      return
+    }
     const modelPath = this.getModelPath(id)
     if (await RNFS.exists(modelPath)) {
       await RNFS.unlink(modelPath)
@@ -390,7 +519,10 @@ class STTModelManager {
   }
 
   async activateLanguage(code: string): Promise<void> {
-    const language = this.languages[code]
+    if (isAppleSttCode(code) && !this.appleLanguages[code]) {
+      await this.refreshAppleLanguages()
+    }
+    const language = this.config(code)
     if (!language) {
       throw new Error(`Language ${code} not found`)
     }

package/src/services/controllers.ts

@@ -0,0 +1,77 @@
+/**
+ * Controller registry read-model: the paired records (the native-authoritative
+ * `controllers` setting) and the live driver statuses (glasses status
+ * `controllers`), plus what each model adds to the input surfaces. Pure.
+ */
+import type {ControllerStatus, PairedController} from "@glassly/bluetooth-sdk"
+
+import type {ButtonCapabilities} from "../types"
+import {ControllerTypes} from "../types/enums"
+
+export type InputSurface = NonNullable<ButtonCapabilities["buttons"]>[number]
+
+/** The Neural Band's thumb swipes, pinches and dial. */
+const NEURAL_BAND_SURFACE: InputSurface = {
+  type: "swipe2d",
+  events: [
+    "TAP",
+    "DOUBLE_TAP",
+    "PRESS_HOLD",
+    "SWIPE_UP",
+    "SWIPE_DOWN",
+    "SWIPE_LEFT",
+    "SWIPE_RIGHT",
+    "DIAL_UP",
+    "DIAL_DOWN",
+  ],
+}
+
+// The R1 swipes up/down like the temples it stands in for, so it adds nothing.
+const INPUT_SURFACES: Readonly<Record<string, readonly InputSurface[]>> = {
+  [ControllerTypes.NEURAL_BAND]: [NEURAL_BAND_SURFACE],
+  [ControllerTypes.R1]: [],
+}
+
+/** The input surfaces a connected controller of `model` adds to the glasses'. */
+export function controllerInputSurfaces(model: string): InputSurface[] {
+  return (INPUT_SURFACES[model] ?? []).map((surface) => ({...surface, events: [...surface.events]}))
+}
+
+/** The model swipes in two dimensions. */
+export function hasInput2d(model: string): boolean {
+  return (INPUT_SURFACES[model] ?? []).some((surface) => surface.type === "swipe2d")
+}
+
+export function isControllerModel(model: string | undefined): boolean {
+  return model !== undefined && (Object.values(ControllerTypes) as string[]).includes(model)
+}
+
+/** The `controllers` setting as records; malformed entries are dropped. */
+export function pairedControllersFrom(value: unknown): PairedController[] {
+  if (!Array.isArray(value)) return []
+  const records: PairedController[] = []
+  for (const entry of value) {
+    if (!entry || typeof entry !== "object") continue
+    const {id, model, name} = entry as Record<string, unknown>
+    if (typeof id !== "string" || !id || typeof model !== "string") continue
+    records.push({id, model, name: typeof name === "string" ? name : id})
+  }
+  return records
+}
+
+/** Delivering input: link up and the route or claim done. */
+export function isControllerReady(status: ControllerStatus | undefined): boolean {
+  return status?.connected === true && status.fullyBooted === true
+}
+
+export function readyControllers(statuses: Record<string, ControllerStatus> | undefined): ControllerStatus[] {
+  return Object.values(statuses ?? {}).filter(isControllerReady)
+}
+
+/** Change key over the controllers delivering input. */
+export function readyControllersKey(statuses: Record<string, ControllerStatus> | undefined): string {
+  return readyControllers(statuses)
+    .map((status) => `${status.id}=${status.model}`)
+    .sort()
+    .join(",")
+}

package/src/services/effectiveCapabilities.ts

@@ -12,21 +12,15 @@
  * that draws vector shapes keeps 128 scene slots, so shape-heavy frames
  * (a game board, a chart) get a larger shared text/shape budget.
  *
- * A connected controller that swipes in two dimensions (the Meta Neural Band)
- * adds its surface to `button.buttons` as a `swipe2d` entry, so a miniapp can
+ * Every connected controller adds its model's input surfaces to
+ * `button.buttons` (the Meta Neural Band a `swipe2d` entry), so a miniapp can
  * tell four-way swipes from the temples' and the R1 ring's up/down.
  */
 import {useGlassesStore} from "../stores/glasses"
 import {SETTINGS, useSettingsStore} from "../stores/settings"
-import {
-  ALL_DISPLAY_SHAPES,
-  DeviceTypes,
-  getModelCapabilities,
-  type ButtonCapabilities,
-  type Capabilities,
-} from "../types"
+import {ALL_DISPLAY_SHAPES, DeviceTypes, getModelCapabilities, type Capabilities} from "../types"
+import {controllerInputSurfaces, readyControllers, type InputSurface} from "./controllers"
 import {resolveNativeNavigation} from "./nativeNavigationGate"
-import {input2dFrom} from "./settingsBridge"
 
 const CFW_MAX_TEXT_ELEMENTS = 24
 const CFW_MAX_IMAGE_ELEMENTS = 16
@@ -90,35 +84,25 @@ function glassesCapabilities(model: DeviceTypes): Capabilities {
   }
 }
 
-type InputSurface = NonNullable<ButtonCapabilities["buttons"]>[number]
-
-/** The Neural Band's thumb swipes, pinches and dial. */
-const NEURAL_BAND_SURFACE: InputSurface = {
-  type: "swipe2d",
-  events: [
-    "TAP",
-    "DOUBLE_TAP",
-    "PRESS_HOLD",
-    "SWIPE_UP",
-    "SWIPE_DOWN",
-    "SWIPE_LEFT",
-    "SWIPE_RIGHT",
-    "DIAL_UP",
-    "DIAL_DOWN",
-  ],
-}
-
 function withControllerInput(caps: Capabilities): Capabilities {
-  const controller = useSettingsStore.getState().getSetting(SETTINGS.default_controller.key)
-  if (!input2dFrom(useGlassesStore.getState(), controller)) return caps
   const buttons = caps.button?.buttons ?? []
+  const types = new Set(buttons.map((surface) => surface.type))
+  const added: InputSurface[] = []
+  for (const status of readyControllers(useGlassesStore.getState().controllers)) {
+    for (const surface of controllerInputSurfaces(status.model)) {
+      if (types.has(surface.type)) continue
+      types.add(surface.type)
+      added.push(surface)
+    }
+  }
+  if (added.length === 0) return caps
   return {
     ...caps,
     hasButton: true,
     button: {
       ...caps.button,
-      count: (caps.button?.count ?? buttons.length) + 1,
-      buttons: [...buttons, NEURAL_BAND_SURFACE],
+      count: (caps.button?.count ?? buttons.length) + added.length,
+      buttons: [...buttons, ...added],
     },
   }
 }

package/src/services/neuralBand/NeuralBandInput.ts

@@ -2,7 +2,9 @@
  * The Meta Neural Band's own event streams, past the gestures that ride `touch_event`:
  * claim progress (for the pairing screens), the handwriting model (typed into the
  * miniapp keyboard stream as synthesized key presses) and the air mouse (forwarded
- * to miniapps on the pointer stream).
+ * to miniapps on the pointer stream). State is per band (`controllerId`); the
+ * latest claim is also kept on its own, since the pairing screen runs before
+ * the band's id reaches JS.
  */
 import type {NeuralBandClaimEvent, NeuralBandHandwritingEvent, NeuralBandPointerEvent} from "@glassly/bluetooth-sdk"
 import {MiniappStreamType} from "@glassly/miniapp"
@@ -15,6 +17,8 @@ export interface NeuralBandClaimStatus {
   message?: string
   sessionExpired: boolean
   bandName?: string
+  /** The band being claimed; absent until a claim event arrives. */
+  controllerId?: string
 }
 
 export interface NeuralBandHandwritingStatus {
@@ -25,6 +29,11 @@ export interface NeuralBandHandwritingStatus {
   text: string
 }
 
+export interface NeuralBandHandwritingUpdate {
+  id: string
+  status: NeuralBandHandwritingStatus
+}
+
 export interface NeuralBandInputOptions {
   forward?: (stream: string, payload: unknown) => void
   now?: () => number
@@ -56,11 +65,15 @@ function codeFor(char: string): string {
   return "Unidentified"
 }
 
+const IDLE_CLAIM: NeuralBandClaimStatus = {stage: "idle", sessionExpired: false}
+const IDLE_HANDWRITING: NeuralBandHandwritingStatus = {phase: "idle", message: "", text: ""}
+
 export class NeuralBandInput {
-  private claim: NeuralBandClaimStatus = {stage: "idle", sessionExpired: false}
-  private handwriting: NeuralBandHandwritingStatus = {phase: "idle", message: "", text: ""}
+  private latestClaim: NeuralBandClaimStatus = IDLE_CLAIM
+  private claims = new Map<string, NeuralBandClaimStatus>()
+  private handwriting = new Map<string, NeuralBandHandwritingStatus>()
   private claimListeners = new Set<(status: NeuralBandClaimStatus) => void>()
-  private handwritingListeners = new Set<(status: NeuralBandHandwritingStatus) => void>()
+  private handwritingListeners = new Set<(update: NeuralBandHandwritingUpdate) => void>()
   private readonly forward: (stream: string, payload: unknown) => void
   private readonly now: () => number
 
@@ -69,8 +82,10 @@ export class NeuralBandInput {
     this.now = options.now ?? (() => Date.now())
   }
 
-  claimStatus(): NeuralBandClaimStatus {
-    return this.claim
+  /** One band's claim, or the latest claim of any band without an id. */
+  claimStatus(controllerId?: string): NeuralBandClaimStatus {
+    if (controllerId === undefined) return this.latestClaim
+    return this.claims.get(controllerId) ?? IDLE_CLAIM
   }
 
   onClaimStatus(cb: (status: NeuralBandClaimStatus) => void): () => void {
@@ -78,42 +93,54 @@ export class NeuralBandInput {
     return () => this.claimListeners.delete(cb)
   }
 
-  handwritingStatus(): NeuralBandHandwritingStatus {
-    return this.handwriting
+  handwritingStatus(controllerId: string): NeuralBandHandwritingStatus {
+    return this.handwriting.get(controllerId) ?? IDLE_HANDWRITING
   }
 
-  onHandwritingStatus(cb: (status: NeuralBandHandwritingStatus) => void): () => void {
+  onHandwritingStatus(cb: (update: NeuralBandHandwritingUpdate) => void): () => void {
     this.handwritingListeners.add(cb)
     return () => this.handwritingListeners.delete(cb)
   }
 
   /** A new pairing attempt starts from a clean slate. */
   resetClaim(): void {
-    this.setClaim({stage: "idle", sessionExpired: false})
+    this.latestClaim = IDLE_CLAIM
+    for (const cb of this.claimListeners) cb(IDLE_CLAIM)
+  }
+
+  /** Drop an unpaired band's state. */
+  forget(controllerId: string): void {
+    this.claims.delete(controllerId)
+    this.handwriting.delete(controllerId)
   }
 
   handleClaim(event: NeuralBandClaimEvent): void {
-    this.setClaim({
+    const status: NeuralBandClaimStatus = {
       stage: event.stage,
       message: event.message,
       sessionExpired: event.sessionExpired === true,
       bandName: event.bandName,
-    })
+      controllerId: event.controllerId,
+    }
+    if (event.controllerId) this.claims.set(event.controllerId, status)
+    this.latestClaim = status
+    for (const cb of this.claimListeners) cb(status)
   }
 
   handleHandwriting(event: NeuralBandHandwritingEvent): void {
+    const id = event.controllerId
+    const current = this.handwritingStatus(id)
     if (event.kind === "state") {
-      const text = event.phase === "preparing" ? "" : this.handwriting.text
-      this.setHandwriting({phase: event.phase, message: event.message, problem: event.problem, text})
+      const text = event.phase === "preparing" ? "" : current.text
+      this.setHandwriting(id, {phase: event.phase, message: event.message, problem: event.problem, text})
       return
     }
-    const previous = this.handwriting.text
-    if (event.text !== previous) {
-      for (const key of keyEventsForTextChange(previous, event.text, this.now())) {
+    if (event.text !== current.text) {
+      for (const key of keyEventsForTextChange(current.text, event.text, this.now())) {
         this.forward(MiniappStreamType.KEYBOARD_EVENT, key)
       }
     }
-    this.setHandwriting({...this.handwriting, text: event.text})
+    this.setHandwriting(id, {...current, text: event.text})
   }
 
   handlePointer(event: NeuralBandPointerEvent): void {
@@ -123,24 +150,21 @@ export class NeuralBandInput {
         dx: event.dx,
         dy: event.dy,
         timestamp: event.timestamp,
+        controllerId: event.controllerId,
       })
     } else {
       this.forward(MiniappStreamType.POINTER_EVENT, {
         kind: "buttons",
         buttons: event.buttons,
         timestamp: event.timestamp,
+        controllerId: event.controllerId,
       })
     }
   }
 
-  private setClaim(status: NeuralBandClaimStatus): void {
-    this.claim = status
-    for (const cb of this.claimListeners) cb(status)
-  }
-
-  private setHandwriting(status: NeuralBandHandwritingStatus): void {
-    this.handwriting = status
-    for (const cb of this.handwritingListeners) cb(status)
+  private setHandwriting(id: string, status: NeuralBandHandwritingStatus): void {
+    this.handwriting.set(id, status)
+    for (const cb of this.handwritingListeners) cb({id, status})
   }
 }
 

package/src/services/neuralBand/NeuralBandSettingsSync.ts

@@ -1,59 +1,61 @@
 /**
- * Pushes the Neural Band's user settings (air mouse, wearing hand) to the native
- * controller: when the band connects, and whenever either setting changes while
- * it is connected. The native side keeps nothing across connections.
+ * Pushes the Neural Band user settings (air mouse, wearing hand) to every
+ * connected band: to each band as it connects, and to all of them whenever
+ * either setting changes. The native side keeps nothing across connections.
  */
 import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
 
 import {useGlassesStore} from "../../stores/glasses"
 import {SETTINGS, useSettingsStore} from "../../stores/settings"
 import {ControllerTypes} from "../../types/enums"
+import {readyControllers} from "../controllers"
 
 let unsubscribers: (() => void)[] = []
 
-function bandConnected(): boolean {
-  const glasses = useGlassesStore.getState()
-  const settings = useSettingsStore.getState()
-  return (
-    glasses.controllerConnected === true &&
-    glasses.controllerFullyBooted === true &&
-    settings.getSetting(SETTINGS.default_controller.key) === ControllerTypes.NEURAL_BAND
-  )
+function connectedBandIds(): string[] {
+  return readyControllers(useGlassesStore.getState().controllers)
+    .filter((status) => status.model === ControllerTypes.NEURAL_BAND)
+    .map((status) => status.id)
 }
 
-function pushAirMouse(): void {
-  if (!bandConnected()) return
+function pushAirMouse(id: string): void {
   const enabled = useSettingsStore.getState().getSetting(SETTINGS.neural_band_air_mouse.key) === true
-  void BluetoothSdk.neuralBandSetPointer(enabled).catch((err) =>
+  void BluetoothSdk.neuralBandSetPointer(id, enabled).catch((err) =>
     console.warn("NeuralBandSettingsSync: air mouse push failed:", err),
   )
 }
 
-function pushHand(): void {
-  if (!bandConnected()) return
+function pushHand(id: string): void {
   const hand = useSettingsStore.getState().getSetting(SETTINGS.neural_band_hand.key) === "left" ? "left" : "right"
-  void BluetoothSdk.neuralBandSetHand(hand).catch((err) =>
+  void BluetoothSdk.neuralBandSetHand(id, hand).catch((err) =>
     console.warn("NeuralBandSettingsSync: hand push failed:", err),
   )
 }
 
 export function startNeuralBandSettingsSync(): void {
   if (unsubscribers.length > 0) return
-  let wasConnected = bandConnected()
+  let connected = new Set(connectedBandIds())
   unsubscribers = [
     useGlassesStore.subscribe(
-      (s) => s.controllerConnected === true && s.controllerFullyBooted === true,
+      () => connectedBandIds().sort().join(","),
       () => {
-        const connected = bandConnected()
-        if (connected && !wasConnected) {
-          pushAirMouse()
-          pushHand()
+        const next = new Set(connectedBandIds())
+        for (const id of next) {
+          if (connected.has(id)) continue
+          pushAirMouse(id)
+          pushHand(id)
         }
-        wasConnected = connected
+        connected = next
       },
     ),
-    useSettingsStore.subscribe((s) => s.getSetting(SETTINGS.neural_band_air_mouse.key), pushAirMouse),
-    useSettingsStore.subscribe((s) => s.getSetting(SETTINGS.neural_band_hand.key), pushHand),
+    useSettingsStore.subscribe(
+      (s) => s.getSetting(SETTINGS.neural_band_air_mouse.key),
+      () => connectedBandIds().forEach(pushAirMouse),
+    ),
+    useSettingsStore.subscribe(
+      (s) => s.getSetting(SETTINGS.neural_band_hand.key),
+      () => connectedBandIds().forEach(pushHand),
+    ),
   ]
 }