@glassly/engine 0.3.7 → 0.3.8-beta.1013

package/src/index.ts

@@ -64,11 +64,20 @@ export type {
   LocalLlmModelId,
 } from "./services/LocalLlmModelManager"
 export {DEFAULT_LOCAL_LLM_MODEL, isLocalLlmModelId} from "./services/LocalLlmModelManager"
+export type {
+  OfflineActivity,
+  OfflineActivityReason,
+  OfflineLlmActivity,
+  OfflineTranscriptionActivity,
+  OfflineTranslationActivity,
+  OfflineTranslationPair,
+} from "./services/OfflineActivity"
 
 // Shared user memory timeline (engine.memory / Settings > Memory). Entry and
 // session shapes are canonical in @glassly/miniapp (the session.memory
 // surface); the stats read model is engine-side.
 export type {MemoryStats} from "./services/MemoryStore"
+export type {AppStateExportResult, AppStateRestoreOptions, AppStateRestoreResult} from "./services/appStateBackupFile"
 export type {SpeakerProfile} from "./services/SpeakerProfileStore"
 export type {EnrollOutcome} from "./facades/speakers"
 export {MENTRA_LIVE_SETTING_KEYS, getBluetoothSettingKeysForDevice} from "./stores/bluetoothSettingKeys"
@@ -230,6 +239,7 @@ export {
 } from "./services/neuralBand/MetaAuth"
 export type {
   NeuralBandClaimStatus,
+  NeuralBandFirmwareStatus,
   NeuralBandHandwritingStatus,
   NeuralBandHandwritingUpdate,
 } from "./services/neuralBand/NeuralBandInput"

package/src/services/AppRegistry.ts

@@ -658,7 +658,8 @@ class AppRegistry {
     }
   }
 
-  public async getActiveVersion(packageName: string): Promise<string> {
+  /** Undefined when no bundle is on disk (offline built-ins, HTTP-direct dev apps). */
+  public async getActiveVersion(packageName: string): Promise<string | undefined> {
     let versions = this.getInstalledVersions(packageName)
     // Treat MMKV as a hint, not authority. A stored version may have been
     // GC'd off disk without this pointer being updated.
@@ -677,8 +678,10 @@ class AppRegistry {
     }
     versions = versions.filter((v) => semver.valid(v))
     versions.sort((a, b) => semver.rcompare(a, b))
-    this.setActiveVersion(packageName, versions[0])
-    return versions[0]
+    const latest = versions[0] as string | undefined
+    // Never persist undefined: MMKV.set throws on it.
+    if (latest) this.setActiveVersion(packageName, latest)
+    return latest
   }
 
   public setActiveVersion(packageName: string, version: string): Result<void, Error> {
@@ -727,7 +730,13 @@ class AppRegistry {
     const installed = diskApps.filter(
       (app) => !offlinePackages.has(app.packageName) && !devPackages.has(app.packageName),
     )
-    return [...installed, ...dev, ...offline]
+    // The last switcher-card capture comes back from disk, so a relaunched
+    // app's card is not blank until it is minimized again.
+    const withScreenshot = (app: ClientApp): ClientApp => ({
+      ...app,
+      screenshot: app.screenshot ?? getLocalAppScreenshot(app.packageName),
+    })
+    return [...installed.map(withScreenshot), ...dev.map(withScreenshot), ...offline]
   }
 
   public async getInstalledMiniapps(): Promise<ClientApp[]> {
@@ -747,6 +756,8 @@ class AppRegistry {
       const out: ClientApp[] = []
       for (const lmaInfo of installedInfo) {
         const versionString = await this.getActiveVersion(lmaInfo.packageName)
+        // A package dir with no usable bundle (e.g. only a half-written version) has nothing to run.
+        if (!versionString) continue
         const versionInfo = lmaInfo.versions[versionString]
 
         const manifest = this.getMiniappManifest(lmaInfo.packageName, versionString) as {
@@ -963,6 +974,19 @@ export function saveWidgetExpandChoice(packageName: string, widgetId: string, ex
   storage.save(`${packageName}_widget_expand_${widgetId}`, expandOnTap)
 }
 
+/**
+ * Where a screenshot captured under an earlier install now lives: iOS gives
+ * every install a new container, so a stored absolute file URI goes stale
+ * while the file itself is still in the documents directory.
+ */
+function rerootDocumentUri(uri: string): string | null {
+  const marker = "/Documents/"
+  const at = uri.indexOf(marker)
+  if (at < 0) return null
+  const rerooted = new File(Paths.document, uri.slice(at + marker.length)).uri
+  return rerooted === uri ? null : rerooted
+}
+
 export function getLocalAppScreenshot(packageName: string): string | undefined {
   const key = `${packageName}_screenshot`
   const res = storage.load<string>(key)
@@ -971,14 +995,17 @@ export function getLocalAppScreenshot(packageName: string): string | undefined {
   const uri = res.value
   if (uri.startsWith("file://")) {
     try {
-      if (!new File(uri).exists) {
-        storage.remove(key)
-        return undefined
+      if (new File(uri).exists) return uri
+      const rerooted = rerootDocumentUri(uri)
+      if (rerooted && new File(rerooted).exists) {
+        storage.save(key, rerooted)
+        return rerooted
       }
     } catch {
-      storage.remove(key)
-      return undefined
+      // fall through: the stored uri is unusable
     }
+    storage.remove(key)
+    return undefined
   }
 
   return uri

package/src/services/AppStateBackup.ts

@@ -0,0 +1,283 @@
+/**
+ * App state backups (Settings > Profile > Backup): one JSON file carrying the
+ * system settings, every miniapp's SimpleStorage, the installed miniapp list
+ * with each app's home flags, and the memory timeline.
+ *
+ * It exists so a logout or reinstall doesn't mean signing back into every
+ * miniapp, which is why the file holds live credentials (miniapp tokens,
+ * provider API keys) as plain JSON. Pairing identity, cloud endpoints, and
+ * consent/login state stay out: they belong to the install and the account,
+ * not to the user's preferences.
+ *
+ * Storage keys are written without their user segment, so a backup restores
+ * into whatever namespace the phone has now (account or `local_`). Restore
+ * overwrites key by key and leaves keys the backup doesn't carry alone.
+ *
+ * Pure: the MMKV view, settings registry, and memory snapshot are passed in by
+ * appStateBackupFile.ts.
+ */
+
+import type {MemoryBackup} from "@glassly/miniapp"
+
+/** Key-value surface (MMKV in production, values already JSON-decoded). */
+export interface AppStateBackupBackend {
+  get(key: string): unknown | null
+  set(key: string, value: unknown): void
+  keys(): string[]
+}
+
+/** The fields of a SETTINGS descriptor that decide whether it is backed up. */
+export interface BackupSettingDescriptor {
+  key: string
+  persist: boolean
+  writable: boolean
+  nativeAuthoritative?: true
+  resetOnBuildEnvChange?: true
+  indexer?: (key: string) => string
+}
+
+export interface AppStateBackupMiniapp {
+  /** Set when the miniapp was installed at export. */
+  installed?: {version: string; source?: string}
+  /** SimpleStorage key → stored value. */
+  storage: Record<string, unknown>
+  /** Home flags by suffix: `hidden`, `always_on`, `widget_expand_<widgetId>`. */
+  prefs: Record<string, unknown>
+}
+
+export interface AppStateBackup {
+  format: "glassly-app-state"
+  version: 1
+  /** Epoch ms the backup was written. */
+  exportedAt: number
+  /** Stored setting values; indexed settings keep their `key:index` storage key. */
+  settings: Record<string, unknown>
+  miniapps: Record<string, AppStateBackupMiniapp>
+  memory: MemoryBackup | null
+}
+
+/** Thrown for a file that isn't an app state backup this build can read. */
+export class AppStateBackupError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = "AppStateBackupError"
+  }
+}
+
+const STORAGE_ROOT = "localstorage_"
+const PREF_SUFFIXES = ["hidden", "always_on"] as const
+const WIDGET_EXPAND_PREFIX = "widget_expand_"
+// Same rule as the miniapp.json schema; keeps a hand-edited file from writing keys no app reads.
+const PACKAGE_NAME_RE = /^[a-zA-Z][a-zA-Z0-9_]*(\.[a-zA-Z][a-zA-Z0-9_]*)+$/
+
+/**
+ * Persisted, writable settings that are still not the user's to carry between
+ * installs: account and consent state, the paired devices, and caches.
+ */
+const EXCLUDED_SETTINGS = new Set([
+  "auth_email",
+  "disable_cloud",
+  "ai_data_consent_version",
+  "ai_data_consent_agreed",
+  "login_skipped",
+  "has_paired_glasses",
+  "keyboard_name",
+  "cached_required_version",
+  "offline_camera_running",
+  "offline_translation_running",
+])
+
+export function isBackupSetting(setting: BackupSettingDescriptor): boolean {
+  return (
+    setting.persist &&
+    setting.writable &&
+    !setting.nativeAuthoritative &&
+    !setting.resetOnBuildEnvChange &&
+    !EXCLUDED_SETTINGS.has(setting.key)
+  )
+}
+
+export interface CollectAppStateInput {
+  backend: AppStateBackupBackend
+  userId: string
+  settings: BackupSettingDescriptor[]
+  installed: Array<{packageName: string; version: string; source?: string}>
+  memory: MemoryBackup | null
+  now: number
+}
+
+export function collectAppStateBackup(input: CollectAppStateInput): AppStateBackup {
+  const {backend, settings} = input
+  const keys = backend.keys()
+
+  const settingValues: Record<string, unknown> = {}
+  for (const setting of settings) {
+    if (!isBackupSetting(setting)) continue
+    if (setting.indexer) {
+      for (const key of keys) {
+        if (!key.startsWith(`${setting.key}:`)) continue
+        const value = backend.get(key)
+        if (value != null) settingValues[key] = value
+      }
+      continue
+    }
+    const value = backend.get(setting.key)
+    if (value != null) settingValues[setting.key] = value
+  }
+
+  const miniapps: Record<string, AppStateBackupMiniapp> = {}
+  const entry = (packageName: string) => (miniapps[packageName] ??= {storage: {}, prefs: {}})
+
+  for (const app of input.installed) {
+    const record = entry(app.packageName)
+    record.installed = app.source ? {version: app.version, source: app.source} : {version: app.version}
+    for (const suffix of PREF_SUFFIXES) {
+      const value = backend.get(`${app.packageName}_${suffix}`)
+      if (value != null) record.prefs[suffix] = value
+    }
+    const expandPrefix = `${app.packageName}_${WIDGET_EXPAND_PREFIX}`
+    for (const key of keys) {
+      if (!key.startsWith(expandPrefix)) continue
+      const value = backend.get(key)
+      if (value != null) record.prefs[key.slice(app.packageName.length + 1)] = value
+    }
+  }
+
+  // Longest first, so a package whose name extends another's still claims its own keys.
+  const known = input.installed.map((app) => app.packageName).sort((a, b) => b.length - a.length)
+  const prefix = `${STORAGE_ROOT}${input.userId}_`
+  for (const key of keys) {
+    if (!key.startsWith(prefix)) continue
+    const split = splitStorageKey(key.slice(prefix.length), known)
+    if (!split) continue
+    const value = backend.get(key)
+    if (value != null) entry(split.packageName).storage[split.key] = value
+  }
+
+  return {
+    format: "glassly-app-state",
+    version: 1,
+    exportedAt: input.now,
+    settings: settingValues,
+    miniapps,
+    memory: input.memory,
+  }
+}
+
+/** `{packageName}_{key}` → its parts. Package names may contain `_`, so known names win over the first `_`. */
+function splitStorageKey(rest: string, known: string[]): {packageName: string; key: string} | null {
+  const packageName = known.find((name) => rest.startsWith(`${name}_`)) ?? rest.slice(0, rest.indexOf("_"))
+  const key = rest.slice(packageName.length + 1)
+  if (!packageName || !key) return null
+  return {packageName, key}
+}
+
+export function parseAppStateBackup(data: unknown): AppStateBackup {
+  if (!isRecord(data) || data.format !== "glassly-app-state") {
+    throw new AppStateBackupError("Not a Glassly app state backup")
+  }
+  if (typeof data.version !== "number" || data.version > 1) {
+    throw new AppStateBackupError(`Unsupported app state backup version ${String(data.version)}`)
+  }
+
+  const settings = isRecord(data.settings) ? data.settings : {}
+  const miniapps: Record<string, AppStateBackupMiniapp> = {}
+  if (isRecord(data.miniapps)) {
+    for (const [packageName, raw] of Object.entries(data.miniapps)) {
+      if (!PACKAGE_NAME_RE.test(packageName) || !isRecord(raw)) continue
+      const record: AppStateBackupMiniapp = {
+        storage: isRecord(raw.storage) ? raw.storage : {},
+        prefs: isRecord(raw.prefs) ? raw.prefs : {},
+      }
+      if (isRecord(raw.installed) && typeof raw.installed.version === "string") {
+        record.installed = {version: raw.installed.version}
+        if (typeof raw.installed.source === "string") record.installed.source = raw.installed.source
+      }
+      miniapps[packageName] = record
+    }
+  }
+
+  let memory: MemoryBackup | null = null
+  if (data.memory != null) {
+    if (!isRecord(data.memory) || data.memory.format !== "glassly-memory") {
+      throw new AppStateBackupError("The backup's memory section is not a memory backup")
+    }
+    memory = data.memory as unknown as MemoryBackup
+  }
+
+  return {format: "glassly-app-state", version: 1, exportedAt: Number(data.exportedAt) || 0, settings, miniapps, memory}
+}
+
+/**
+ * The backup's settings this build will restore, split by how they're written:
+ * `plain` through the settings store, `indexed` (`key:index`) straight to storage.
+ * Keys this build doesn't know, or doesn't back up, are dropped.
+ */
+export function restorableSettings(
+  backup: AppStateBackup,
+  settings: BackupSettingDescriptor[],
+): {plain: Record<string, unknown>; indexed: Record<string, unknown>} {
+  const byKey = new Map(settings.map((setting) => [setting.key, setting]))
+  const plain: Record<string, unknown> = {}
+  const indexed: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(backup.settings)) {
+    if (value == null) continue
+    const colon = key.indexOf(":")
+    const setting = byKey.get(colon < 0 ? key : key.slice(0, colon))
+    if (!setting || !isBackupSetting(setting)) continue
+    if (colon < 0 && !setting.indexer) plain[key] = value
+    else if (colon > 0 && setting.indexer) indexed[key] = value
+  }
+  return {plain, indexed}
+}
+
+/** Miniapps the backup has storage for. */
+export function miniappsWithStorage(backup: AppStateBackup): string[] {
+  return Object.entries(backup.miniapps)
+    .filter(([, record]) => Object.entries(record.storage).some(([key, value]) => key && value != null))
+    .map(([packageName]) => packageName)
+}
+
+/** Write every miniapp's storage into `userId`'s namespace. Returns the packages that got keys. */
+export function restoreMiniappStorage(
+  backend: AppStateBackupBackend,
+  userId: string,
+  backup: AppStateBackup,
+): {packages: string[]; keys: number} {
+  const packages: string[] = []
+  let keys = 0
+  for (const [packageName, record] of Object.entries(backup.miniapps)) {
+    let wrote = 0
+    for (const [key, value] of Object.entries(record.storage)) {
+      if (!key || value == null) continue
+      backend.set(`${STORAGE_ROOT}${userId}_${packageName}_${key}`, value)
+      wrote++
+    }
+    if (wrote > 0) packages.push(packageName)
+    keys += wrote
+  }
+  return {packages, keys}
+}
+
+export interface MiniappPrefs {
+  hidden?: boolean
+  alwaysOn?: boolean
+  widgetExpand: Record<string, boolean>
+}
+
+/** A miniapp's home flags from the backup, with anything that isn't a boolean dropped. */
+export function miniappPrefs(record: AppStateBackupMiniapp): MiniappPrefs {
+  const prefs: MiniappPrefs = {widgetExpand: {}}
+  if (typeof record.prefs.hidden === "boolean") prefs.hidden = record.prefs.hidden
+  if (typeof record.prefs.always_on === "boolean") prefs.alwaysOn = record.prefs.always_on
+  for (const [key, value] of Object.entries(record.prefs)) {
+    if (!key.startsWith(WIDGET_EXPAND_PREFIX) || typeof value !== "boolean") continue
+    const widgetId = key.slice(WIDGET_EXPAND_PREFIX.length)
+    if (widgetId) prefs.widgetExpand[widgetId] = value
+  }
+  return prefs
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value != null && typeof value === "object" && !Array.isArray(value)
+}

package/src/services/BlobStore.ts

@@ -504,20 +504,14 @@ export class BlobStore {
     const key = (typeof payload.key === "string" && payload.key) || this.makeId()
     const mimeFilter = payload.mimeType as string | undefined
 
-    let picked: File | File[] | null = null
-    try {
-      picked = await File.pickFileAsync(undefined, mimeFilter)
-    } catch (err) {
-      // Picker dismissed / cancelled (or unavailable) → resolve to null, not an error.
-      console.log(`${LOG_TAG}: blob import picker dismissed`, err)
-      this.hooks.sendResult(packageName, requestId, true, null)
-      return
-    }
-    const file = Array.isArray(picked) ? picked[0] : picked
-    if (!file) {
+    // The options form resolves {canceled, result} and never throws; the deprecated
+    // (initialUri, mimeType) form resolves a bare File only when a mime type is passed.
+    const picked = await File.pickFileAsync(mimeFilter ? {mimeTypes: mimeFilter} : {})
+    if (picked.canceled) {
       this.hooks.sendResult(packageName, requestId, true, null)
       return
     }
+    const file = picked.result
     try {
       const size = file.size ?? 0
       if (this.overQuota(packageName, key, size)) {

package/src/services/CloudClientService.ts

@@ -19,9 +19,10 @@ import type {
   RuntimeSnapshot,
   StoreCatalogResponse,
   StoreListing,
+  StoreReleasesResponse,
 } from "@glassly/cloud-client/react-native"
 import type {SubjectTokenType} from "@glassly/cloud-client"
-import {Platform} from "react-native"
+import {AppState, Platform} from "react-native"
 import type {AudioSubscription, QuotaStatusPayload, TranscriptionData, TranslationData} from "@glassly/cloud-protocol"
 
 import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
@@ -70,6 +71,8 @@ const LOCAL_AUTH_PORT = 3002
 
 let client: CloudClient | null = null
 let connected = false
+/** The cloud closed us for a newer socket; the client stays down until reconnect(). */
+let superseded = false
 let persistentFailureTimer: ReturnType<typeof BgTimer.setTimeout> | null = null
 let persistentFailureNotified = false
 let audioSubscriptions: AudioSubscription[] = []
@@ -84,6 +87,7 @@ let authStateUnsubscribe: (() => void) | null = null
 let localDevRuntimeToken: {runtimeUrl: string; token: string; expiresAtMs: number} | null = null
 let lc3FrameSizeUnsubscribe: (() => void) | null = null
 let disableCloudUnsubscribe: (() => void) | null = null
+let foregroundUnsubscribe: (() => void) | null = null
 let coreTokenSyncPromise: Promise<string> | null = null
 /**
  * A device-local namespace (`local_…`) whose data still needs to be adopted
@@ -511,6 +515,26 @@ function stopLc3FrameSizeWatcher(): void {
   lc3FrameSizeUnsubscribe = null
 }
 
+/**
+ * Reclaim a superseded session only on foreground: the user picked this phone
+ * up, and a reclaim on any other signal would fight the newer socket.
+ */
+function startForegroundWatcher(): void {
+  if (foregroundUnsubscribe) return
+
+  const subscription = AppState.addEventListener("change", (state) => {
+    if (state !== "active" || !superseded || !client) return
+    console.log(`${LOG_TAG}: foregrounded after supersede; reconnecting runtime`)
+    cloudClientService.reconnect()
+  })
+  foregroundUnsubscribe = () => subscription.remove()
+}
+
+function stopForegroundWatcher(): void {
+  foregroundUnsubscribe?.()
+  foregroundUnsubscribe = null
+}
+
 /**
  * Apply a mid-session flip of the Privacy toggle without a restart: turning it
  * on tears the live client down, turning it back off reconnects. Installed by
@@ -596,6 +620,7 @@ function construct(): void {
   c.runtime.onConnected(() => {
     if (c !== client) return
     connected = true
+    superseded = false
     console.log(`${LOG_TAG}: runtime connected`)
     console.log(`${LOG_TAG}: debug: ws-session-debug connected`)
     // Cloud is up — cancel any pending persistent-failure alarm and re-arm for the
@@ -613,10 +638,9 @@ function construct(): void {
   c.runtime.onDisconnected((info) => {
     if (c !== client) return
     connected = false
+    superseded = /superseded by newer session/i.test(info.reason)
     console.log(`${LOG_TAG}: runtime disconnected (${info.reason})`)
-    console.log(
-      `${LOG_TAG}: debug: ws-session-debug disconnected reason=${info.reason} willStayDown=${/superseded by newer session/i.test(info.reason)}`,
-    )
+    console.log(`${LOG_TAG}: debug: ws-session-debug disconnected reason=${info.reason} willStayDown=${superseded}`)
     // Arm the persistent-failure alarm once; if we're still down when it fires, raise
     // the notification. A reconnect within the window cancels it (onConnected above).
     if (!persistentFailureTimer && !persistentFailureNotified) {
@@ -659,6 +683,7 @@ function construct(): void {
   )
 
   startLc3FrameSizeWatcher()
+  startForegroundWatcher()
 }
 
 /**
@@ -720,6 +745,7 @@ export const cloudClientService = {
     client = null
     localDevRuntimeToken = null
     connected = false
+    superseded = false
     resetRuntimeStatus()
     if (wasConnected) notifyConnectionListeners(false)
 
@@ -753,6 +779,13 @@ export const cloudClientService = {
     return c.core.store.get(packageName)
   },
 
+  async getStoreReleases(packageName: string): Promise<StoreReleasesResponse> {
+    if (!client) this.init()
+    const c = client
+    if (!c?.core) throw new Error("cloud client core is unavailable")
+    return c.core.store.releases(packageName)
+  },
+
   /** Bytes of a store icon or screenshot; these routes need the user Bearer. */
   async fetchStoreAsset(url: string): Promise<Uint8Array> {
     if (!client) this.init()
@@ -835,11 +868,13 @@ export const cloudClientService = {
       console.warn(`${LOG_TAG}: stop close() failed: ${(err as Error)?.message ?? err}`)
     }
     stopLc3FrameSizeWatcher()
+    stopForegroundWatcher()
     stopAuthWatch()
     clearRuntimeEventSubscriptions()
     clearPersistentFailureAlarm()
     const wasConnected = connected
     client = null
+    superseded = false
     // stop() is part of the logout lifecycle and runs before the host emits
     // SIGNED_OUT. Remove the persisted namespace owner here so a later account
     // can never inherit it. A force-stop/process kill does not call stop(), so
@@ -855,6 +890,10 @@ export const cloudClientService = {
   shutdown(): void {
     this.stop()
     stopDisableCloudWatcher()
+    // The next engine.start() is configured afresh; an override left by a
+    // reconnect() in this process would otherwise outrank the new config
+    // and keep the client on the previous backend.
+    endpointsOverride = null
   },
 
   /** Device-side managed photo: presign now, deliver bytes, await ready. */

package/src/services/DeviceEventRouter.ts

@@ -245,6 +245,7 @@ export function startDeviceEventRouter(): void {
   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(BluetoothSdk.addListener("neural_band_firmware", (event) => neuralBandInput.handleFirmware(event)))
   subs.push({
     remove: useGlassesStore.subscribe(
       (s) => s.keyboardConnected === true,

package/src/services/DisplayDiagnostics.ts

@@ -4,6 +4,7 @@ import type {DisplayDiagnostic} from "@glassly/miniapp"
 // messages, packet bytes, or arbitrary application content to another miniapp.
 const fields = new Set([
   "v",
+  "device",
   "run",
   "id",
   "t",
@@ -72,10 +73,11 @@ export function collectDisplayDiagnostics(
   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 ")
+    const prefix = message.includes("MEMOMINDPERF ") ? "MEMOMINDPERF " : "G2PERF "
+    const offset = message.indexOf(prefix)
     if (offset < 0 || message.length > 8192) continue
     try {
-      const raw = JSON.parse(message.slice(offset + 7))
+      const raw = JSON.parse(message.slice(offset + prefix.length))
       if (
         !raw ||
         raw.v !== 1 ||

package/src/services/DisplayProcessor.ts

@@ -20,6 +20,8 @@ import {
   Z100_PROFILE,
   NEX_PROFILE,
   RAYNEO_IO_PROFILE,
+  MEMOMIND_ONE_PROFILE,
+  RAYNEO_IO_CFW_PROFILE,
   TextMeasurer,
   TextWrapper,
   ColumnComposer,
@@ -42,12 +44,7 @@ import {isGlassesConnected} from "./GlassesReadiness"
  * Display event types that we process
  */
 export type DisplayLayoutType =
-  | "text_wall"
-  | "text_line"
-  | "text_rows"
-  | "reference_card"
-  | "double_text_wall"
-  | "bitmap_view"
+  "text_wall" | "text_line" | "text_rows" | "reference_card" | "double_text_wall" | "bitmap_view"
 
 /**
  * Raw display event from the cloud/WebSocket
@@ -208,6 +205,16 @@ const DEVICE_PROFILES: Partial<Record<DeviceTypes, DisplayProfile>> = {
   [DeviceTypes.NEX]: NEX_PROFILE,
   [DeviceTypes.MACH1]: Z100_PROFILE, // Mach1 uses same hardware as Vuzix Z100
   [DeviceTypes.RAYNEO_IO]: RAYNEO_IO_PROFILE,
+  [DeviceTypes.MEMOMIND_ONE]: MEMOMIND_ONE_PROFILE,
+}
+
+/**
+ * Scene text profiles for models whose Glassly CFW draws text with a font of
+ * its own, used while the CFW publishes a scene canvas.
+ */
+const CFW_SCENE_PROFILES: Partial<Record<DeviceTypes, DisplayProfile>> = {
+  [DeviceTypes.RAYNEO_IO]: RAYNEO_IO_CFW_PROFILE,
+  [DeviceTypes.MEMOMIND_ONE]: MEMOMIND_ONE_PROFILE,
 }
 
 // =============================================================================
@@ -275,8 +282,7 @@ export class DisplayProcessor {
     // Seed the device profile from the saved default wearable, read off the engine
     // settings store directly (was a host settings hook).
     const defaultWearable = useSettingsStore.getState().getSetting(ISLAND_SETTINGS_KEYS.defaultWearable) as
-      | string
-      | undefined
+      string | undefined
     if (defaultWearable) {
       this.setDeviceModel(defaultWearable)
       console.log(`DISPLAY_PROCESSOR: Initialized DisplayProcessor with default wearable: ${defaultWearable}`)
@@ -380,6 +386,12 @@ export class DisplayProcessor {
     return this.profile
   }
 
+  /** Profile scene text is wrapped with: the CFW's own while its scene page is up, else the model's. */
+  public getSceneProfile(): DisplayProfile {
+    const cfw = CFW_SCENE_PROFILES[this.deviceModel]
+    return cfw && (useGlassesStore.getState().sceneCanvasWidth ?? 0) > 0 ? cfw : this.profile
+  }
+
   // ===========================================================================
   // Display Event Processing
   // ===========================================================================

package/src/services/GlassesTouchInput.ts

@@ -110,7 +110,7 @@ function routeTouchEvent(event: TouchEvent): void {
   const doubleTap = gesture === "double_tap"
   // The Neural Band's middle finger (index 1) shares the tap names. Either
   // finger leaves the app on screen; the firmware dashboard is the index finger's.
-  const osDoubleTap = doubleTap && event.index !== 1
+  const osDoubleTap = doubleTap && !(event.source === 3 && event.index === 1)
   const osHeadUp = gesture === "head_up"
 
   if (doubleTap) {
@@ -156,7 +156,11 @@ function routeTouchEvent(event: TouchEvent): void {
   // pagesEligible: connected Glassly CFW glasses, whose firmware leaves the
   // dashboard to the phone; other firmware opens its own on a lift.
   const opensNativeDashboard = osDoubleTap || (osHeadUp && pagesEligible())
-  if (opensNativeDashboard && !nativeNavigationService.isActive && isGlassesConnected(useGlassesStore.getState().connection)) {
+  if (
+    opensNativeDashboard &&
+    !nativeNavigationService.isActive &&
+    isGlassesConnected(useGlassesStore.getState().connection)
+  ) {
     useDisplayStore.getState().setDisplayEvent({layout: {layoutType: "unavailable", reason: "firmware-dashboard"}})
     void Promise.resolve(BluetoothSdk.showDashboard()).catch((err) => {
       console.error("DeviceEventRouter: showDashboard failed:", err)