@glassly/engine 0.3.2-beta.572 → 0.3.2-beta.597

package/src/facades/dev.ts

@@ -94,12 +94,12 @@ export type DevRuntimeStatusSnapshot = ReturnType<typeof projectRuntimeStatus>
 export const dev = {
   /** Inject a glasses gesture through the normal dashboard/miniapp input policy. */
   sendGesture,
-  /** The cloud-v2 core/runtime URL overrides. */
+  /** The cloud core/runtime URL overrides. */
   cloudUrls: (): {core?: string; runtime?: string} => {
     const s = useSettingsStore.getState()
     return {core: s.getSetting(SETTINGS.cloud_core_url.key), runtime: s.getSetting(SETTINGS.cloud_runtime_url.key)}
   },
-  /** Override the cloud-v2 URLs and reconnect the live client onto them. */
+  /** Override the cloud URLs and reconnect the live client onto them. */
   setCloudUrls: (urls: {core?: string; runtime?: string}) => {
     const next = {...currentCloudUrlOverrides(), ...urls}
     const resolved = resolveCloudUrlReconnectTarget(next)

package/src/facades/glasses.ts

@@ -25,6 +25,10 @@ import {hasDefaultDevice} from "../services/DeviceStoreHydration"
 import {projectPairingIdentity} from "../services/PairingIdentity"
 import {isGlassesConnected, isGlassesReady} from "../services/GlassesReadiness"
 import {pushAllBluetoothSettings} from "../services/GlassesSettingsSync"
+import neuralBandInput, {
+  type NeuralBandClaimStatus,
+  type NeuralBandHandwritingStatus,
+} from "../services/neuralBand/NeuralBandInput"
 import {recordSupportProfileConnectionFailure} from "../services/SupportProfileSync"
 import {getModelCapabilities, type DeviceTypes} from "../types"
 import {glassesWifi} from "./glassesWifi"
@@ -267,6 +271,29 @@ export const glasses = {
     },
   },
 
+  // --- Meta Neural Band (a controller with a claim step and its own features) ---
+  neuralBand: {
+    /** Store the Meta account session the one-time band claim uses. */
+    setMetaSession: (accessToken: string, userId: string): Promise<void> =>
+      BluetoothSdk.neuralBandSetMetaSession(accessToken, userId),
+    clearMetaSession: (): Promise<void> => BluetoothSdk.neuralBandClearMetaSession(),
+    hasMetaSession: (): Promise<boolean> => BluetoothSdk.neuralBandHasMetaSession(),
+    /** A band identity is stored on this phone, so the remembered band connects without a claim. */
+    isClaimed: (): Promise<boolean> => BluetoothSdk.neuralBandIsClaimed(),
+    /** The latest claim progress, kept across screens. */
+    claimStatus: (): NeuralBandClaimStatus => neuralBandInput.claimStatus(),
+    resetClaim: (): void => neuralBandInput.resetClaim(),
+    onClaimStatus: (cb: (status: NeuralBandClaimStatus) => void): (() => void) => neuralBandInput.onClaimStatus(cb),
+    /** The band's handwriting model; writing arrives on the miniapp keyboard stream. */
+    setHandwriting: (enabled: boolean): Promise<void> => BluetoothSdk.neuralBandSetHandwriting(enabled),
+    handwritingStatus: (): NeuralBandHandwritingStatus => neuralBandInput.handwritingStatus(),
+    onHandwritingStatus: (cb: (status: NeuralBandHandwritingStatus) => void): (() => void) =>
+      neuralBandInput.onHandwritingStatus(cb),
+    /** The band's air mouse; movement reaches miniapps on the pointer stream. */
+    setPointer: (enabled: boolean): Promise<void> => BluetoothSdk.neuralBandSetPointer(enabled),
+    setHand: (hand: "left" | "right"): Promise<void> => BluetoothSdk.neuralBandSetHand(hand),
+  },
+
   // --- audio (glasses media-volume + own-app playback hint) ---
   audio: {
     /** Read the glasses' current media volume. */

package/src/facades/pairing.ts

@@ -63,7 +63,7 @@ function projectTargetReady(options: Pick<PairingReadyWaitOptions, "deviceModel"
   const {deviceModel, deviceName} = options
   const glasses = useGlassesStore.getState()
 
-  if (deviceModel === ControllerTypes.R1) {
+  if (deviceModel !== undefined && (Object.values(ControllerTypes) as string[]).includes(deviceModel)) {
     if (!glasses.controllerConnected || !glasses.controllerFullyBooted) return false
     const settings = useSettingsStore.getState()
     const pairedModel = settings.getSetting(SETTINGS.default_controller.key)

package/src/facades/reports.ts

@@ -1,9 +1,9 @@
 /**
  * reports facade — `engine.reports`: user/system report submission over the
- * Cloud V2 core client.
+ * Cloud core client.
  *
  * Host/OEM code owns UI and wording. Engine owns Glassly mechanics: context
- * collection, recent phone logs, Cloud V2 calls, local automatic throttling,
+ * collection, recent phone logs, Cloud calls, local automatic throttling,
  * screenshots, and notifying connected glasses.
  */
 import BluetoothSdk from "@glassly/bluetooth-sdk/internal"

package/src/facades/session.ts

@@ -1,5 +1,5 @@
 /**
- * session facade — `engine.session`: the cloud-v2 live-session surface engine
+ * session facade — `engine.session`: the cloud live-session surface engine
  * now owns (keystone #5). Exposes the connection status read-model (status +
  * audio transport, projected from the engine-owned cloud-status store) and the
  * liveness flag.
@@ -38,7 +38,7 @@ export const session = {
    * Legacy Cloud-V1 websocket status. The socket's writer (the host
    * WebSocketManager) was deleted in the Cloud V1 ripout, so this now always
    * reports the store's initial DISCONNECTED; the host connection banners
-   * render `status()` (the cloud-v2 runtime) instead. Kept, with the backing
+   * render `status()` (the cloud runtime) instead. Kept, with the backing
    * connection store, for the engine-side legacy-surface removal (issue #3392).
    */
   legacyWebsocketStatus: (): WebSocketStatus => useConnectionStore.getState().status,

package/src/generated/releaseMetadata.ts

@@ -12,9 +12,9 @@ export interface EngineReleaseMetadata {
 export const ENGINE_RELEASE_METADATA: Readonly<EngineReleaseMetadata> = Object.freeze({
   "schemaVersion": 1,
   "familyBaseVersion": "0.3.2",
-  "releaseIdentity": "0.3.2-beta.572",
-  "releaseSetId": "glassly-0.3.2-beta.572",
-  "sourceCommit": "8e7b479822f0116bfe53f16d1709adf73e35e28f",
+  "releaseIdentity": "0.3.2-beta.597",
+  "releaseSetId": "glassly-0.3.2-beta.597",
+  "sourceCommit": "4bbd4945a62883e5f384569b0f5c56a51e5c81cd",
   "otaManifestUrl": null,
   "otaManifestSha256": null
 })

package/src/index.ts

@@ -7,7 +7,7 @@
  * capability tables, timers). Judgment rule: read models, commands, pure
  * functions and types belong here; anything that mutates runtime state or
  * exposes a raw store/service remains private to the Glassly host.
- * See cloud-v2/docs/issues/020-glasses-status-boundary/integration-review.md §D.
+ * See cloud/docs/issues/020-glasses-status-boundary/integration-review.md §D.
  */
 
 // The namespaced OEM-facing engine API (the "(A) host API"). See ./engine.
@@ -201,6 +201,20 @@ export {
 } from "./utils/devMiniappLaunch"
 export {HardwareCompatibility, type CompatibilityResult} from "./utils/hardware"
 export {BgTimer, throttle, debounce} from "./utils/timers"
+// Meta Neural Band: the account sign-in a claim needs (the WebView lives in the host).
+export {
+  MetaAuthError,
+  authEntryUrl,
+  callbackMatches,
+  callbackQuery,
+  decryptBlob,
+  isLoginCallback,
+  login,
+  tokensQuery,
+  type MetaSession,
+  type MetaSsoTokens,
+} from "./services/neuralBand/MetaAuth"
+export type {NeuralBandClaimStatus, NeuralBandHandwritingStatus} from "./services/neuralBand/NeuralBandInput"
 
 // Hardware types and capability profiles.
 export {

package/src/runtime/bootstrap.ts

@@ -29,9 +29,9 @@ export interface IslandAuth {
 }
 
 export interface IslandConfigValues {
-  /** cloud-v2 core service base URL (defaults resolved by the cloud client). */
+  /** cloud core service base URL (defaults resolved by the cloud client). */
   coreUrl?: string
-  /** cloud-v2 runtime service base URL. */
+  /** cloud runtime service base URL. */
   runtimeUrl?: string
   /** OEM identifier (Glassly is OEM #0); reserved for OEM auth/telemetry. */
   oemId?: string

package/src/services/CloudAudioSubscriptionSync.ts

@@ -5,12 +5,12 @@
  *
  * Failure mode this protects:
  * 1. Local captions subscribes to transcription.
- * 2. The first Cloud V2 `PUT /api/audio/subscriptions` throws while the socket
+ * 2. The first Cloud `PUT /api/audio/subscriptions` throws while the socket
  *    is reconnecting or Core is briefly unreachable.
  * 3. A reconnect/resync recomputes the same desired subscription set.
  *
  * If we mark the set as "last applied" before the PUT succeeds, step 3 is
- * incorrectly deduped and captions can wait forever even though Cloud V2 later
+ * incorrectly deduped and captions can wait forever even though Cloud later
  * reconnects. So `begin()` only blocks exact duplicates while a write is in
  * flight; only `succeeded()` promotes that key to the applied state.
  */

package/src/services/CloudClientService.ts

@@ -35,7 +35,7 @@ import {storage as mmkvStorage} from "../utils/storage"
 import {useCloudClientStatusStore} from "../stores/cloudClientStatus"
 import {islandNotifications} from "./NotificationsEmitter"
 import {BgTimer} from "../utils/timers"
-import {logCloudV2TranscriptMetric} from "./CloudTranscriptE2EMetrics"
+import {logCloudTranscriptMetric} from "./CloudTranscriptE2EMetrics"
 import {isLocalUserId, LocalMiniappUserIdentity} from "./LocalMiniappUserIdentity"
 import {migrateLocalMiniappData, type LocalMiniappDataMigrationBackend} from "./LocalMiniappDataMigration"
 import {nativeHttpResponseBody} from "./NativeHttpResponse"
@@ -580,7 +580,7 @@ function construct(): void {
   })
   transcriptUnsubscribe = c.runtime.onTranscript((data) => {
     if (c !== client) return
-    logCloudV2TranscriptMetric(data)
+    logCloudTranscriptMetric(data)
     emitTranscript(data)
   })
   translationUnsubscribe = c.runtime.onTranslation((data) => {
@@ -857,7 +857,7 @@ export const cloudClientService = {
     stopDisableCloudWatcher()
   },
 
-  /** Device-side managed photo (cloud-v2): presign now, deliver bytes, await ready. */
+  /** Device-side managed photo: presign now, deliver bytes, await ready. */
   startManagedPhoto(opts: Record<string, unknown> = {}) {
     if (!client) throw new Error("cloud client not connected")
     return client.runtime.startManagedPhoto(opts)
@@ -867,7 +867,7 @@ export const cloudClientService = {
     return client.runtime.awaitManagedPhotoReady(requestId)
   },
 
-  /** Managed stream (cloud-v2): provision ingest+playback on the runtime. */
+  /** Managed stream: provision ingest+playback on the runtime. */
   startManagedStream(opts: Record<string, unknown> = {}) {
     if (!client) throw new Error("cloud client not connected")
     return client.runtime.startManagedStream(opts)

package/src/services/CloudTranscriptE2EMetrics.ts

@@ -2,7 +2,7 @@ import type {TranscriptionData} from "@glassly/cloud-protocol"
 
 import {buildE2EMetric, logE2EMetricPayload} from "../utils/e2eMetrics"
 
-export function buildCloudV2TranscriptMetric(data: TranscriptionData): Record<string, unknown> {
+export function buildCloudTranscriptMetric(data: TranscriptionData): Record<string, unknown> {
   return buildE2EMetric("cloud_v2_transcript", {
     text: data.text,
     state: data.isFinal ? "final" : "interim",
@@ -22,6 +22,6 @@ export function buildCloudV2TranscriptMetric(data: TranscriptionData): Record<st
   })
 }
 
-export function logCloudV2TranscriptMetric(data: TranscriptionData): void {
-  logE2EMetricPayload(buildCloudV2TranscriptMetric(data), "cloud_v2_transcript")
+export function logCloudTranscriptMetric(data: TranscriptionData): void {
+  logE2EMetricPayload(buildCloudTranscriptMetric(data), "cloud_v2_transcript")
 }

package/src/services/DeviceEventRouter.ts

@@ -35,6 +35,7 @@ import {retirePendingSelectionOnPromotion} from "./PairingIdentity"
 import GlobalEventEmitter from "../utils/GlobalEventEmitter"
 import {asgCameraApi} from "./asg/asgCameraApi"
 import {dispatchTouchEvent, resetTouchInput} from "./GlassesTouchInput"
+import neuralBandInput from "./neuralBand/NeuralBandInput"
 import dashboardOpenTrace from "./debug/DashboardOpenTrace"
 
 let subs: Array<{remove: () => void}> = []
@@ -233,6 +234,10 @@ export function startDeviceEventRouter(): void {
   // Physical keyboard bridged through G2 Glassly CFW: raw HID transitions →
   // layout-translated keyboard_event stream (with synthesized auto-repeat).
   subs.push(BluetoothSdk.addListener("keyboard_key", (event) => glassesKeyboardInput.handle(event)))
+  // Meta Neural Band: its gestures ride touch_event above; these are its own streams.
+  subs.push(BluetoothSdk.addListener("neural_band_claim", (event) => neuralBandInput.handleClaim(event)))
+  subs.push(BluetoothSdk.addListener("neural_band_handwriting", (event) => neuralBandInput.handleHandwriting(event)))
+  subs.push(BluetoothSdk.addListener("neural_band_pointer", (event) => neuralBandInput.handlePointer(event)))
   subs.push({
     remove: useGlassesStore.subscribe(
       (s) => s.keyboardConnected === true,

package/src/services/GestureDotsService.ts

@@ -1,8 +1,9 @@
 /**
  * Gesture dots — a debug indicator that flashes a small glyph top-right on the
  * glasses when a touch gesture arrives, while nothing else is on the display:
- * a filled circle for a single tap, an arrow for a swipe (cleared after a
- * short pulse), a bullseye while a CFW tap-then-hold is held. Extracted from
+ * a filled circle for a single tap, two for a double tap, an arrow for a swipe
+ * (cleared after a short pulse), a bullseye for a recognized long press.
+ * The Neural Band's middle finger (index 1) draws the same shapes hollow. Extracted from
  * the CFW dashboard service; it renders through
  * the ordinary scene pipeline, so it works on any positioning device (stock
  * G2 included), and is gated by the gesture_dots debug setting.
@@ -25,20 +26,27 @@ const DOTS_APP_ID = "system.gesture-dots"
 const GESTURE_FLASH_MS = 700
 const MARGIN_X = 16
 const MARGIN_TOP = 10
-// Off: tap_then_hold opens the side menu now.
-const HOLD_GLYPH_ENABLED = false
+/** Gestures that flash a glyph. */
+const FLASH_GLYPHS: Record<string, GestureDotGlyph> = {
+  single_tap: "dot",
+  double_tap: "double",
+  long_press: "hold",
+  swipe_up: "up",
+  swipe_down: "down",
+  swipe_left: "left",
+  swipe_right: "right",
+}
+/** The band's middle finger draws the filled shapes hollow. */
+const MIDDLE_FINGER_GLYPHS: Partial<Record<GestureDotGlyph, GestureDotGlyph>> = {dot: "ring", double: "doubleRing"}
 
 class GestureDotsService {
   private started = false
   private flash: GestureDotGlyph | null = null
   private flashTimer: number | null = null
-  /** Finger currently on the touch bar (tap_start..tap_end; the CFW forwards holds as these edges). */
-  private held = false
-  /**
-   * The CFW's tap_then_hold fired during this press (discrete recognition
-   * event; the tap_end that follows on release is what clears it).
-   */
-  private holdRecognized = false
+  /** Raw controller holds survive hold recognition/dial events until their own release. */
+  private presses = new Map<number, {raw: boolean; glyph: GestureDotGlyph}>()
+  /** Avoid sending identical images for successive phases of the same press. */
+  private renderedGlyph: GestureDotGlyph | null = null
   /** Whether the indicator scene currently has anything on it (needs a clear when the flash ends). */
   private visible = false
   private unsubs: Array<() => void> = []
@@ -75,14 +83,14 @@ class GestureDotsService {
     if (this.flashTimer !== null) BgTimer.clearTimeout(this.flashTimer)
     this.flashTimer = null
     this.flash = null
-    this.held = false
-    this.holdRecognized = false
+    this.presses.clear()
   }
 
   /** Another surface owns the display; forget the indicator without painting over it. */
   private relinquish(): void {
     this.resetGesture()
     this.visible = false
+    this.renderedGlyph = null
     sceneRenderer.clearApp(DOTS_APP_ID)
     this.trace("relinquish")
   }
@@ -94,15 +102,16 @@ class GestureDotsService {
   /**
    * Flash a gesture on the indicator. Other gesture names are ignored.
    * Claimed gestures cancel any earlier press/flash without starting a new
-   * one: the claimant may also consume the release edge.
+   * one: the claimant may also consume the release edge. `fingerIndex` is the
+   * Neural Band's finger on its pinches and press edges (1 = middle).
    */
-  noteGesture(gestureName: string, claimed = false): void {
+  noteGesture(gestureName: string, claimed = false, fingerIndex?: number): void {
     if (!this.started || !this.enabled()) return
-    this.applyGesture(gestureName, claimed)
+    this.applyGesture(gestureName, claimed, fingerIndex)
     this.trace("input", {gestureName, claimed})
   }
 
-  private applyGesture(gestureName: string, claimed: boolean): void {
+  private applyGesture(gestureName: string, claimed: boolean, fingerIndex?: number): void {
     if (localDisplayManager.hasActiveDisplay() || useDisplayStore.getState().overlayOwner !== null) {
       this.relinquish()
       return
@@ -112,49 +121,59 @@ class GestureDotsService {
       this.render()
       return
     }
-    // Tap edges show a steady circle for as long as the finger is down (on
-    // CFW these arrive for holds: ET_LONG/ET_REL forwarded as
-    // tap_start/tap_end), with no timer — tap_end clears it. The ring's
-    // touch_down is the same finger-down edge; the ring's tap_end releases it.
-    if (gestureName === "tap_start" || gestureName === "touch_down" || gestureName === "tap_end") {
-      const held = gestureName !== "tap_end"
-      if (this.held === held) return
-      this.held = held
-      if (!held) this.holdRecognized = false
+    const finger = fingerIndex ?? 0
+    const press = this.presses.get(finger)
+    if (gestureName === "touch_down" || gestureName === "tap_start") {
+      if (press) {
+        // Both reports describe one press. Never restart its visual feedback.
+        if (gestureName === "touch_down") press.raw = true
+        return
+      }
+      this.clearFlash()
+      this.presses.set(finger, {raw: gestureName === "touch_down", glyph: finger === 1 ? "ring" : "dot"})
       this.render()
       return
     }
-    if (gestureName === "tap_then_hold" && HOLD_GLYPH_ENABLED) {
-      this.held = true
-      this.holdRecognized = true
+    if (gestureName === "tap_end") {
+      if (!press) return
+      this.presses.delete(finger)
+      // The band's resolved tap arrives after release (double-tap window).
+      // Keep the glyph lit across that gap so one pinch never flashes twice.
+      if (press.raw && this.presses.size === 0) this.startFlash(press.glyph)
       this.render()
       return
     }
-    // Any other gesture implies the finger is up, even if tap_end was lost.
-    const released = this.held
-    this.held = false
-    this.holdRecognized = false
-    const flash: GestureDotGlyph | null =
-      gestureName === "single_tap"
-        ? "dot"
-        : gestureName === "swipe_up"
-          ? "up"
-          : gestureName === "swipe_down"
-            ? "down"
-            : null
-    if (!flash) {
-      if (released) this.render()
+    const shape = FLASH_GLYPHS[gestureName]
+    const glyph = shape && finger === 1 ? MIDDLE_FINGER_GLYPHS[shape] ?? shape : shape
+    if (press?.raw && (!glyph || gestureName === "long_press")) {
+      // Pinch-and-turn reports do not release a finger. A recognized hold
+      // stays visible until tap_end instead of expiring halfway through it.
+      if (glyph) press.glyph = glyph
+      this.render()
       return
     }
-    this.flash = flash
+    // Completed taps/swipes become one continuous pulse, even if the device
+    // omits tap_end. Older tap_start-only devices retain the same fallback.
+    this.presses.delete(finger)
+    if (glyph) this.startFlash(glyph)
+    this.render()
+  }
+
+  private clearFlash(): void {
     if (this.flashTimer !== null) BgTimer.clearTimeout(this.flashTimer)
+    this.flashTimer = null
+    this.flash = null
+  }
+
+  private startFlash(glyph: GestureDotGlyph): void {
+    this.clearFlash()
+    this.flash = glyph
     this.flashTimer = BgTimer.setTimeout(() => {
       this.flashTimer = null
       this.flash = null
       this.render()
       this.trace("flash-ended")
     }, GESTURE_FLASH_MS)
-    this.render()
   }
 
   /** Debug setting only; no payloads or retained history. Correlate seq with G2PERF. */
@@ -165,7 +184,7 @@ class GestureDotsService {
         JSON.stringify({
           t: Date.now(),
           reason,
-          held: this.held,
+          held: this.presses.size > 0,
           flash: this.flash,
           overlay: useDisplayStore.getState().overlayOwner,
           active: localDisplayManager.hasActiveDisplay(),
@@ -188,15 +207,18 @@ class GestureDotsService {
   private render(): void {
     if (!this.started) return
     if (localDisplayManager.hasActiveDisplay() || useDisplayStore.getState().overlayOwner !== null) return
-    const shown = this.flash ?? (this.held ? (this.holdRecognized ? "hold" : "dot") : null)
+    const shown = Array.from(this.presses.values()).at(-1)?.glyph ?? this.flash
     if (!this.enabled()) {
       if (this.visible) {
         this.visible = false
+        this.renderedGlyph = null
         sceneRenderer.emitScene(DOTS_APP_ID, "main", [])
       }
       return
     }
     if (!shown && !this.visible) return
+    const glyph = shown ?? "blank"
+    if (glyph === this.renderedGlyph) return
     const elements: SceneElementInput[] = [
       {
         type: "image",
@@ -208,13 +230,14 @@ class GestureDotsService {
           h: GESTURE_DOT_GLYPH_SIZE,
           anchor: "top-right",
         },
-        data: GESTURE_DOT_GLYPHS[shown ?? "blank"],
+        data: GESTURE_DOT_GLYPHS[glyph],
       },
     ]
     this.visible = true
+    this.renderedGlyph = glyph
     const result = sceneRenderer.emitScene(DOTS_APP_ID, "main", elements)
     this.trace("render", {
-      glyph: shown ?? "blank",
+      glyph,
       ...(result?.kind === "scene" ? {seq: result.seq, sent: result.sent} : {}),
     })
   }

package/src/services/GlassesTouchInput.ts

@@ -50,8 +50,11 @@ function shouldForwardScroll(event: TouchEvent): boolean {
 export function dispatchTouchEvent(event: TouchEvent): void {
   const gesture = event.gestureName
   const claimant = localMiniappRuntime.gestureClaimant(gesture)
+  // The Neural Band's middle finger (index 1) shares the tap names but is left
+  // to miniapps: the engine's own double-tap behaviors are the index finger's.
+  const osDoubleTap = gesture === "double_tap" && event.index !== 1
 
-  if (gesture === "double_tap") {
+  if (osDoubleTap) {
     // A visible main miniapp opts out of OS exit by registering double tap (the
     // terminal's back-to-menu). The latest claimant still receives it. Otherwise
     // the tap means "leave the app". The controller shows the bounded OS
@@ -72,7 +75,7 @@ export function dispatchTouchEvent(event: TouchEvent): void {
     // An overlay app claims the double tap on an empty screen to open the dashboard.
     if (gesture === "double_tap" && isOverlayApp(claimant)) dashboardOpenTrace.trigger("double-tap", event.timestamp)
     // The press may have started before this app claimed its release edge.
-    gestureDotsService.noteGesture(gesture, true)
+    gestureDotsService.noteGesture(gesture, true, event.index)
     if (!shouldForwardScroll(event)) return
     localMiniappRuntime.forwardEvent("touch_event", event, undefined, claimant)
     return
@@ -81,7 +84,7 @@ export function dispatchTouchEvent(event: TouchEvent): void {
   // Gesture-dots debug indicator (any device, gated by its setting). It
   // only paints while the screen is otherwise empty. Process even suppressed
   // scroll repeats here so their completion still clears a held dot.
-  gestureDotsService.noteGesture(gesture)
+  gestureDotsService.noteGesture(gesture, false, event.index)
 
   if (!shouldForwardScroll(event)) return
   localMiniappRuntime.forwardEvent("touch_event", event)
@@ -90,7 +93,7 @@ export function dispatchTouchEvent(event: TouchEvent): void {
   // Glassly CFW glasses the dashboard miniapp claims it while it runs
   // (ADR-0006); stock firmware keeps its native dashboard (ADR-0002). The
   // modal nav UI owns the screen; showDashboard would fight it.
-  if (gesture === "double_tap" && !nativeNavigationService.isActive) {
+  if (osDoubleTap && !nativeNavigationService.isActive) {
     useDisplayStore.getState().setDisplayEvent({layout: {layoutType: "unavailable", reason: "firmware-dashboard"}})
     void Promise.resolve(BluetoothSdk.showDashboard()).catch((err) => {
       console.error("DeviceEventRouter: showDashboard failed:", err)
@@ -113,7 +116,12 @@ export function sendGesture(
     | "tap_then_hold"
     | "touch_down"
     | "swipe_up"
-    | "swipe_down",
+    | "swipe_down"
+    | "swipe_left"
+    | "swipe_right"
+    | "long_press"
+    | "dial_up"
+    | "dial_down",
 ): void {
   const model = useGlassesStore.getState().deviceModel
   dispatchTouchEvent({