@glassly/engine 0.1.0-dev.99 → 0.2.9-beta.448

package/src/services/DeviceEventRouter.ts

@@ -20,39 +20,60 @@ import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
 import {shallow} from "zustand/shallow"
 
 import localMiniappRuntime from "./LocalMiniappRuntime"
-import localDisplayManager from "./LocalDisplayManager"
+import glassesKeyboardInput from "./GlassesKeyboardInput"
+import glassesSensorService from "./GlassesSensorService"
 import localSttFallbackCoordinator from "./LocalSttFallbackCoordinator"
-import {MiniappExitGesture} from "./MiniappExitGesture"
-import nativeNavigationService from "./NativeNavigationService"
 import speakerLabelResolver from "./SpeakerLabelResolver"
 import {phonePhotoCoordinator} from "./PhonePhotoCoordinator"
 import {phoneStreamCoordinator} from "./PhoneStreamCoordinator"
 import {isGlassesConnected} from "./GlassesReadiness"
 import {useGlassesStore} from "../stores/glasses"
-import {SETTINGS, useSettingsStore} from "../stores/settings"
+import {useSettingsStore} from "../stores/settings"
 import {useAppStatusStore} from "../stores/apps"
 import {retirePendingSelectionOnPromotion} from "./PairingIdentity"
 import GlobalEventEmitter from "../utils/GlobalEventEmitter"
-import {BgTimer} from "../utils/timers"
 import {asgCameraApi} from "./asg/asgCameraApi"
-import dashboardCoordinator from "./DashboardCoordinator"
-import gestureDotsService from "./GestureDotsService"
+import {dispatchTouchEvent, resetTouchInput} from "./GlassesTouchInput"
+import dashboardOpenTrace from "./debug/DashboardOpenTrace"
 
 let subs: Array<{remove: () => void}> = []
 
-const miniappExitGesture = new MiniappExitGesture({
-  getState: () => useAppStatusStore.getState(),
-  getVisiblePackageName: () => localDisplayManager.getVisibleMiniappPackageName(),
-  beginExitNotice: (packageName, text) => localDisplayManager.beginMiniappExit(packageName, text),
-  finishExitNotice: (packageName) => localDisplayManager.finishMiniappExit(packageName),
-  cancelExitNotice: (packageName) => localDisplayManager.cancelMiniappExit(packageName),
-  setTimeout: (callback, delay) => BgTimer.setTimeout(callback, delay),
-  clearTimeout: (timerId) => BgTimer.clearTimeout(timerId),
-})
-
 export function startDeviceEventRouter(): void {
   if (subs.length) return
 
+  subs.push(
+    BluetoothSdk.addListener("light_sensor", ({type: _type, ...reading}) => {
+      localMiniappRuntime.forwardEvent("light_sensor", reading)
+    }),
+    // Stock firmware emits these only inside its nav UI; custom firmware whenever the
+    // raw compass runs. Either way they feed the one session.compass stream.
+    BluetoothSdk.addListener("compass_heading", ({type: _type, heading, ...reading}) => {
+      localMiniappRuntime.forwardEvent("glasses_compass", {degrees: heading, ...reading})
+    }),
+    BluetoothSdk.addListener("compass_calibration", ({type: _type, ...reading}) => {
+      localMiniappRuntime.forwardEvent("compass_calibration", reading)
+    }),
+    {
+      remove: useGlassesStore.subscribe(
+        (s) => s.connection,
+        (connection) => {
+          if (isGlassesConnected(connection)) void glassesSensorService.resync()
+          else glassesSensorService.disconnected()
+        },
+      ),
+    },
+    {
+      // CFW classification lands after device-ready; compass demand recorded before
+      // that only reaches the firmware once the scene canvas is published.
+      remove: useGlassesStore.subscribe(
+        (s) => s.sceneCanvasWidth,
+        (width) => {
+          if ((width ?? 0) > 0) void glassesSensorService.resync()
+        },
+      ),
+    },
+  )
+
   // --- device state → engine stores ---
 
   // Standalone WiFi status → glasses store.
@@ -82,17 +103,28 @@ export function startDeviceEventRouter(): void {
     ),
   })
 
-  // Incremental battery status → glasses store + local miniapps.
+  // Battery streams follow the store, including initial native hydration and
+  // onGlassesStatus patches. G2 can report its level without battery_status;
+  // forwarding only that legacy event leaves a running dashboard ring-only.
+  subs.push({
+    remove: useGlassesStore.subscribe(
+      (s) => ({level: s.batteryLevel, charging: s.charging}),
+      (battery) => {
+        localMiniappRuntime.forwardEvent("glasses_battery_update", {
+          type: "glasses_battery_update",
+          ...battery,
+          timestamp: Date.now(),
+        })
+      },
+      {equalityFn: shallow},
+    ),
+  })
+
+  // Legacy standalone events feed the same store subscription.
   subs.push(
     BluetoothSdk.addListener("battery_status", (event) => {
       const state = useGlassesStore.getState()
       state.setBatteryInfo(event.level, event.charging, state.caseBatteryLevel, state.caseCharging)
-      localMiniappRuntime.forwardEvent("glasses_battery_update", {
-        type: "glasses_battery_update",
-        level: event.level,
-        charging: event.charging,
-        timestamp: event.timestamp ?? Date.now(),
-      })
     }),
   )
 
@@ -196,53 +228,18 @@ export function startDeviceEventRouter(): void {
       localMiniappRuntime.forwardEvent("button_press", event)
     }),
   )
-  subs.push(
-    BluetoothSdk.addListener("touch_event", (event) => {
-      // While the custom dashboard is visible it owns its focus/navigation
-      // gestures; do not leak those into a miniapp running underneath it.
-      if (dashboardCoordinator.handleGesture(event.gestureName)) return
-
-      // Gesture-dots debug indicator (any device, gated by its setting). It
-      // only paints while the screen is otherwise empty; the gesture still
-      // flows to miniapps below.
-      gestureDotsService.noteGesture(event.gestureName)
-
-      localMiniappRuntime.forwardEvent("touch_event", event)
-      // Double-tap policy, moved out of the native G2 handlers: exit a visible
-      // unclaimed miniapp; otherwise open the dashboard or toggle head-up.
-      // Native only reports the gesture now.
-      if (event.gestureName === "double_tap") {
-        // A foreground miniapp that claimed double_tap (CLAIM_GESTURES) is
-        // using it as an in-app gesture (e.g. the terminal's back-to-menu) —
-        // the event was already forwarded above; skip the system default.
-        if (localMiniappRuntime.foregroundClaimsGesture("double_tap")) return
-
-        // An unclaimed double tap exits only the miniapp whose frame is visibly
-        // on the glasses. The controller shows the bounded OS notice first,
-        // then uses the normal store stop path (and closes its phone overlay).
-        // Checked before the dashboard toggle: while an app owns the screen an
-        // unclaimed double-tap always means "leave the app" — the (custom or
-        // native) dashboard is for the empty screen, and head-up still opens
-        // the custom dashboard mid-app.
-        if (miniappExitGesture.tryExitVisibleMiniapp()) return
-
-        // Eligible G2 custom firmware replaces the native dashboard.
-        if (dashboardCoordinator.toggleCustom()) return
-
-        const useNativeDashboard = useSettingsStore.getState().getSetting(SETTINGS.use_native_dashboard.key) !== false
-        if (useNativeDashboard) {
-          // The modal nav UI owns the screen; showDashboard would fight it.
-          if (!nativeNavigationService.isActive) {
-            void Promise.resolve(BluetoothSdk.showDashboard()).catch((err) => {
-              console.error("DeviceEventRouter: showDashboard failed:", err)
-            })
-          }
-        } else {
-          dashboardCoordinator.toggleLegacy()
-        }
-      }
-    }),
-  )
+  subs.push(BluetoothSdk.addListener("touch_event", dispatchTouchEvent))
+  // 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)))
+  subs.push({
+    remove: useGlassesStore.subscribe(
+      (s) => s.keyboardConnected === true,
+      (connected) => {
+        if (!connected) glassesKeyboardInput.reset()
+      },
+    ),
+  })
   // G2 IMU accelerometer — payload already matches the miniapp AccelData shape.
   subs.push(
     BluetoothSdk.addListener("accel_event", (event) => {
@@ -255,12 +252,14 @@ export function startDeviceEventRouter(): void {
     }),
   )
   // Head position — translate native {up:boolean} → SDK {position:"up"|"down"}.
+  // The dashboard miniapp opens on head-up from this stream (ADR-0006).
   subs.push(
     BluetoothSdk.addListener("head_up", (event) => {
-      dashboardCoordinator.setHeadUp(event.up)
+      if (event.up) dashboardOpenTrace.trigger("head-up")
       localMiniappRuntime.forwardEvent("head_up", {position: event.up ? "up" : "down", timestamp: Date.now()})
     }),
   )
+  subs.push({remove: dashboardOpenTrace.start()})
   // On-device STT transcripts → local miniapps only while the local engine is
   // active (cloud fallback or an explicit forceLocal subscription). The runtime
   // filters mixed local/cloud delivery per miniapp to avoid double-delivery.
@@ -293,7 +292,7 @@ export function startDeviceEventRouter(): void {
       if (app.running) {
         useAppStatusStore.getState().stop(packageName)
       } else {
-        useAppStatusStore.getState().start(app, {skipNavigation: true})
+        useAppStatusStore.getState().start(app, {skipNavigation: true, launchSource: "glasses"})
       }
     }),
   )
@@ -302,5 +301,5 @@ export function startDeviceEventRouter(): void {
 export function stopDeviceEventRouter(): void {
   for (const sub of subs) sub.remove()
   subs = []
-  miniappExitGesture.reset()
+  resetTouchInput()
 }

package/src/services/DisplayDiagnostics.ts

@@ -0,0 +1,107 @@
+import type {DisplayDiagnostic} from "@glassly/miniapp"
+
+// Explicit allowlist: the diagnostics API must never expose ordinary console
+// messages, packet bytes, or arbitrary application content to another miniapp.
+const fields = new Set([
+  "v",
+  "run",
+  "id",
+  "t",
+  "type",
+  "app",
+  "seq",
+  "page",
+  "pageGeneration",
+  "qL",
+  "qR",
+  "payloadQueue",
+  "pendingFrame",
+  "cfw",
+  "mic",
+  "background",
+  "fpsLimit",
+  "windowMs",
+  "txBytes",
+  "txPackets",
+  "txBytesL",
+  "txBytesR",
+  "framesIn",
+  "framesEncoded",
+  "framesAcked",
+  "coalesced",
+  "errors",
+  "timeouts",
+  "nacks",
+  "resync",
+  "vectorFrames",
+  "rasterFrames",
+  "noop",
+  "fragments",
+  "elements",
+  "animatedElements",
+  "payloadBytes",
+  "uploadBytes",
+  "encodeErrors",
+  "stockTextWrites",
+  "stockTextBytes",
+  "imuSamples",
+  "session",
+  "fragment",
+  "fragments",
+  "mode",
+  "bytes",
+  "totalMs",
+  "result",
+  "written",
+  "attempt",
+  "stage",
+  "ok",
+  "mtuL",
+  "mtuR",
+  "encodeMs",
+  "vectorFallback",
+])
+const timing =
+  /^(creditWaitMs[LR]|writeQueueMs|transferMs|submitMs|writeMs|ackMs|resumeMs|frameMs|encodeMs|frameQueueMs)(Avg|Max|Total)$/
+
+export function collectDisplayDiagnostics(
+  entries: readonly {message: string}[],
+  now = Date.now(),
+): DisplayDiagnostic[] {
+  const records: DisplayDiagnostic[] = []
+  const seen = new Set<string>()
+  for (let i = entries.length - 1; i >= 0 && records.length < 180; i--) {
+    const message = entries[i].message
+    const offset = message.indexOf("G2PERF ")
+    if (offset < 0 || message.length > 8192) continue
+    try {
+      const raw = JSON.parse(message.slice(offset + 7))
+      if (
+        !raw ||
+        raw.v !== 1 ||
+        typeof raw.run !== "string" ||
+        raw.run.length > 64 ||
+        !Number.isSafeInteger(raw.id) ||
+        raw.id < 1 ||
+        !Number.isSafeInteger(raw.t) ||
+        raw.t < now - 180_000 ||
+        raw.t > now + 5000 ||
+        !["sample", "stall", "session"].includes(raw.type)
+      )
+        continue
+      const key = `${raw.run}:${raw.id}`
+      if (seen.has(key)) continue
+      const record: Record<string, string | number | boolean> = {}
+      for (const [name, value] of Object.entries(raw)) {
+        if (!fields.has(name) && !timing.test(name)) continue
+        if ((typeof value === "number" && Number.isFinite(value)) || typeof value === "boolean") record[name] = value
+        else if (typeof value === "string") record[name] = value.slice(0, 160)
+      }
+      records.push(record as DisplayDiagnostic)
+      seen.add(key)
+    } catch {
+      /* Ignore unrelated or incomplete console lines. */
+    }
+  }
+  return records.reverse()
+}

package/src/services/DisplayProcessor.ts

@@ -30,17 +30,13 @@ import {
 import {ISLAND_SETTINGS_KEYS} from "../runtime/config"
 import {useGlassesStore} from "../stores/glasses"
 import {useSettingsStore} from "../stores/settings"
+import {DeviceTypes} from "../types/enums"
 import {isGlassesConnected} from "./GlassesReadiness"
 
 // =============================================================================
 // Types
 // =============================================================================
 
-/**
- * Supported device models for display processing
- */
-export type DeviceModel = "g1" | "g2" | "z100" | "nex" | "mach1" | "mentra-live" | "simulated" | "unknown"
-
 /**
  * Display event types that we process
  */
@@ -204,48 +200,12 @@ function isBreakMode(value: unknown): value is BreakMode {
 /**
  * Map device model names to display profiles
  */
-const DEVICE_PROFILES: Record<DeviceModel, DisplayProfile> = {
-  "g1": G1_PROFILE,
-  "g2": G2_PROFILE,
-  "z100": Z100_PROFILE,
-  "nex": NEX_PROFILE,
-  "mach1": Z100_PROFILE, // Mach1 uses same hardware as Vuzix Z100
-  "mentra-live": G1_PROFILE, // Mentra Live has no display, uses G1 as fallback
-  "simulated": G1_PROFILE, // Simulated uses G1 profile
-  "unknown": G1_PROFILE, // Default to G1
-}
-
-/**
- * Normalize various model name strings to our DeviceModel type
- */
-function normalizeModelName(modelName: string | null | undefined): DeviceModel {
-  if (!modelName) return "unknown"
-
-  const lower = modelName.toLowerCase()
-
-  if (lower.includes("g2") || lower.includes("even realities g2")) {
-    return "g2"
-  }
-  if (lower.includes("g1") || lower.includes("even realities")) {
-    return "g1"
-  }
-  if (lower.includes("z100") || lower.includes("vuzix")) {
-    return "z100"
-  }
-  if (lower.includes("nex") || lower.includes("glassly display")) {
-    return "nex"
-  }
-  if (lower.includes("mach1") || lower.includes("mach 1")) {
-    return "mach1"
-  }
-  if (lower.includes("glassly live") || lower.includes("mentra-live")) {
-    return "mentra-live"
-  }
-  if (lower.includes("simulated") || lower.includes("simulator")) {
-    return "simulated"
-  }
-
-  return "unknown"
+const DEVICE_PROFILES: Partial<Record<DeviceTypes, DisplayProfile>> = {
+  [DeviceTypes.G1]: G1_PROFILE,
+  [DeviceTypes.G2]: G2_PROFILE,
+  [DeviceTypes.Z100]: Z100_PROFILE,
+  [DeviceTypes.NEX]: NEX_PROFILE,
+  [DeviceTypes.MACH1]: Z100_PROFILE, // Mach1 uses same hardware as Vuzix Z100
 }
 
 // =============================================================================
@@ -260,7 +220,7 @@ function normalizeModelName(modelName: string | null | undefined): DeviceModel {
  * const processor = DisplayProcessor.getInstance()
  *
  * // When glasses connect
- * processor.setDeviceModel("Even Realities G1")
+ * processor.setDeviceModel(DeviceTypes.G1)
  *
  * // Process display events
  * const processed = processor.processDisplayEvent(rawEvent)
@@ -273,7 +233,7 @@ export class DisplayProcessor {
   private wrapper: TextWrapper
   private composer: ColumnComposer
   private profile: DisplayProfile
-  private deviceModel: DeviceModel = "unknown"
+  private deviceModel: DeviceTypes = DeviceTypes.NONE
   private options: DisplayProcessorOptions
 
   private runtimeAttached = false
@@ -368,21 +328,21 @@ export class DisplayProcessor {
    * @param modelName - The model name from the connected glasses (e.g., "Even Realities G1")
    */
   public setDeviceModel(modelName: string | null | undefined): void {
-    const normalizedModel = normalizeModelName(modelName)
+    const model = Object.values(DeviceTypes).find((deviceType) => deviceType === modelName) ?? DeviceTypes.NONE
 
-    if (normalizedModel === this.deviceModel) {
+    if (model === this.deviceModel) {
       return // No change needed
     }
 
-    this.deviceModel = normalizedModel
-    const newProfile = DEVICE_PROFILES[normalizedModel]
+    this.deviceModel = model
+    const newProfile = DEVICE_PROFILES[model] ?? G1_PROFILE
 
     if (newProfile !== this.profile) {
       this.updateProfile(newProfile)
     }
 
     if (this.options.debug) {
-      console.log(`[DisplayProcessor] Device model set to: ${normalizedModel} (from: ${modelName})`)
+      console.log(`[DisplayProcessor] Device model set to: ${model} (from: ${modelName})`)
     }
   }
 
@@ -407,7 +367,7 @@ export class DisplayProcessor {
   /**
    * Get the current device model
    */
-  public getDeviceModel(): DeviceModel {
+  public getDeviceModel(): DeviceTypes {
     return this.deviceModel
   }
 
@@ -712,6 +672,11 @@ export class DisplayProcessor {
     return this.measurer.measureText(text)
   }
 
+  /** Rendered advance of one character on the current device's font, in canvas px. */
+  public measureChar(char: string): number {
+    return this.measurer.measureChar(char)
+  }
+
   /**
    * Check if text fits on a single line
    *

package/src/services/GestureDotsService.ts

@@ -12,6 +12,7 @@
  * to ONE re-used firmware image container — flash and idle swap its bytes
  * (data-only update, no page rebuild) instead of creating/removing containers.
  */
+import {useDisplayStore} from "../stores/display"
 import {SETTINGS, useSettingsStore} from "../stores/settings"
 import type {SceneElementInput} from "../utils/display/scene"
 import {BgTimer} from "../utils/timers"
@@ -24,6 +25,8 @@ 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
 
 class GestureDotsService {
   private started = false
@@ -48,23 +51,40 @@ class GestureDotsService {
       // retained state when something else takes over, and clear any
       // leftover flash when the display empties again.
       localDisplayManager.onActiveDisplayChange((active) => {
-        if (active) this.visible = false
+        if (active) this.relinquish()
         else this.render()
       }),
+      // Overlays do not change the retained main display's occupancy.
+      useDisplayStore.subscribe(
+        (state) => state.overlayOwner,
+        (owner) => {
+          if (owner !== null) this.relinquish()
+        },
+      ),
     )
   }
 
   stop(): void {
     for (const unsub of this.unsubs) unsub()
     this.unsubs = []
+    this.relinquish()
+    this.started = false
+  }
+
+  private resetGesture(): void {
     if (this.flashTimer !== null) BgTimer.clearTimeout(this.flashTimer)
     this.flashTimer = null
     this.flash = null
     this.held = false
     this.holdRecognized = false
+  }
+
+  /** Another surface owns the display; forget the indicator without painting over it. */
+  private relinquish(): void {
+    this.resetGesture()
     this.visible = false
-    this.started = false
     sceneRenderer.clearApp(DOTS_APP_ID)
+    this.trace("relinquish")
   }
 
   private enabled(): boolean {
@@ -72,32 +92,48 @@ class GestureDotsService {
   }
 
   /**
-   * Flash a gesture on the indicator. Other gesture names are ignored. The
-   * device-event router calls this after the CFW dashboard had its chance to
-   * consume the gesture, so dashboard navigation does not flash.
+   * 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.
    */
-  noteGesture(gestureName: string): void {
+  noteGesture(gestureName: string, claimed = false): void {
     if (!this.started || !this.enabled()) return
+    this.applyGesture(gestureName, claimed)
+    this.trace("input", {gestureName, claimed})
+  }
+
+  private applyGesture(gestureName: string, claimed: boolean): void {
+    if (localDisplayManager.hasActiveDisplay() || useDisplayStore.getState().overlayOwner !== null) {
+      this.relinquish()
+      return
+    }
+    if (claimed) {
+      this.resetGesture()
+      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.
-    if (gestureName === "tap_start" || gestureName === "tap_end") {
-      const held = gestureName === "tap_start"
+    // 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
       this.render()
       return
     }
-    // CFW tap-then-hold (the stock Menu gesture): swap the steady dot for the
-    // bullseye until release. Recognition arrives mid-press, but set held too
-    // in case the tap_start edge was missed — the release edge still clears.
-    if (gestureName === "tap_then_hold") {
+    if (gestureName === "tap_then_hold" && HOLD_GLYPH_ENABLED) {
       this.held = true
       this.holdRecognized = true
       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"
@@ -106,17 +142,38 @@ class GestureDotsService {
           : gestureName === "swipe_down"
             ? "down"
             : null
-    if (!flash) return
+    if (!flash) {
+      if (released) this.render()
+      return
+    }
     this.flash = flash
     if (this.flashTimer !== null) BgTimer.clearTimeout(this.flashTimer)
     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. */
+  private trace(reason: string, details: Record<string, unknown> = {}): void {
+    if (!this.enabled()) return
+    console.log(
+      "GESTUREDOTS " +
+        JSON.stringify({
+          t: Date.now(),
+          reason,
+          held: this.held,
+          flash: this.flash,
+          overlay: useDisplayStore.getState().overlayOwner,
+          active: localDisplayManager.hasActiveDisplay(),
+          ...details,
+        }),
+    )
+  }
+
   /**
    * Paint or clear the indicator. Nothing is drawn while anything else is on
    * the glasses (miniapp frame or system screen) or when no gesture was just
@@ -130,7 +187,7 @@ class GestureDotsService {
    */
   private render(): void {
     if (!this.started) return
-    if (localDisplayManager.hasActiveDisplay()) return
+    if (localDisplayManager.hasActiveDisplay() || useDisplayStore.getState().overlayOwner !== null) return
     const shown = this.flash ?? (this.held ? (this.holdRecognized ? "hold" : "dot") : null)
     if (!this.enabled()) {
       if (this.visible) {
@@ -155,7 +212,11 @@ class GestureDotsService {
       },
     ]
     this.visible = true
-    sceneRenderer.emitScene(DOTS_APP_ID, "main", elements)
+    const result = sceneRenderer.emitScene(DOTS_APP_ID, "main", elements)
+    this.trace("render", {
+      glyph: shown ?? "blank",
+      ...(result?.kind === "scene" ? {seq: result.seq, sent: result.sent} : {}),
+    })
   }
 }