@glassly/engine 0.3.5 → 0.3.6-beta.851

package/src/services/appleWatch/AppleWatchLink.ts

@@ -0,0 +1,297 @@
+/**
+ * The Apple Watch remote's phone half: the watch app's status context (glasses, the miniapp in
+ * front, launchable miniapps, whether Assist takes questions, the mirror setting), mirror frames
+ * while the setting is on, and the commands the watch sends back. Native adds whether the active
+ * watch is paired and keeps the newest frame for when the watch app opens. Gestures ride
+ * `touch_event` like any controller's.
+ */
+import type {AppleWatchCommandEvent} from "@glassly/bluetooth-sdk"
+import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
+import type {MirrorSnapshot} from "@glassly/miniapp"
+import {MiniappStreamType} from "@glassly/miniapp"
+import {Platform} from "react-native"
+
+import {useAppStatusStore} from "../../stores/apps"
+import {useGlassesStore} from "../../stores/glasses"
+import {SETTINGS, useSettingsStore} from "../../stores/settings"
+import type {ClientApp} from "../../types"
+import {BgTimer} from "../../utils/timers"
+import {isGlassesConnected} from "../GlassesReadiness"
+import localMiniappRuntime from "../LocalMiniappRuntime"
+import {mirrorService} from "../MirrorService"
+import {keyEventsForTextChange} from "../neuralBand/NeuralBandInput"
+
+export const ASSIST_PACKAGE = "com.glassly.assistant"
+export const ASSIST_ACTION = "ask"
+/** WatchConnectivity messages top out near 64 KB; frames past this are skipped, not truncated. */
+const MAX_FRAME_BYTES = 48_000
+const MAX_IMAGE_CHARS = 16_000
+const MAX_APPS = 24
+const STATE_DEBOUNCE_MS = 250
+const MIRROR_INTERVAL_MS = 500
+
+export interface WatchStateInput {
+  glasses: {connected: boolean; model: string; battery: number}
+  apps: readonly ClientApp[]
+  assist: boolean
+  mirror: boolean
+}
+
+/** Miniapps the watch can open: shown, compatible, and drawing on the glasses. */
+export function launchableApps(apps: readonly ClientApp[]): {packageName: string; name: string}[] {
+  return apps
+    .filter((app) => app.type === "standard" && !app.hidden && app.compatibility?.isCompatible !== false)
+    .filter((app) => app.packageName && !app.packageName.includes("@empty"))
+    .slice(0, MAX_APPS)
+    .map((app) => ({packageName: app.packageName, name: app.name}))
+}
+
+export function watchState({glasses, apps, assist, mirror}: WatchStateInput): Record<string, unknown> {
+  const front = apps.find((app) => app.foregrounded && app.running && app.type === "standard")
+  const state: Record<string, unknown> = {
+    glasses: {connected: glasses.connected, name: glasses.model || "Glasses", battery: glasses.battery},
+    apps: launchableApps(apps),
+    assist,
+    mirror,
+  }
+  if (front) state.app = {packageName: front.packageName, name: front.name}
+  return state
+}
+
+type WatchElement = Record<string, string | number | boolean | number[]>
+
+const level = (color: unknown, fallback = 15) =>
+  typeof color === "number" ? Math.max(0, Math.min(15, color)) : fallback
+
+/** The glasses frame in the watch's drawing vocabulary; null when there is nothing to draw. */
+export function mirrorFrame(snapshot: MirrorSnapshot): Record<string, unknown> | null {
+  const canvas = snapshot.canvas
+  if (!canvas) return null
+  const content = snapshot.content
+  if (content.kind === "bitmap") {
+    if (content.data.length > MAX_FRAME_BYTES) return null
+    return {width: canvas.width, height: canvas.height, bitmap: content.data, elements: []}
+  }
+  if (content.kind !== "scene") return null
+  const elements: WatchElement[] = []
+  for (const element of content.elements) {
+    const {x, y, w, h} = element.box
+    const style = element.style ?? {}
+    switch (element.type) {
+      case "text":
+        if (!element.text) break
+        elements.push({
+          type: "text",
+          x,
+          y,
+          w,
+          h,
+          text: element.text,
+          size: style.fontSize ?? 20,
+          color: level(style.color),
+        })
+        break
+      case "rect":
+        elements.push({
+          type: "rect",
+          x,
+          y,
+          w,
+          h,
+          fill: style.fill === true,
+          border: style.border ?? 1,
+          radius: style.radius ?? 0,
+          color: level(style.color),
+        })
+        break
+      case "circle":
+        elements.push({
+          type: "circle",
+          x,
+          y,
+          w,
+          h,
+          fill: style.fill === true,
+          border: style.border ?? 1,
+          color: level(style.color),
+        })
+        break
+      case "line":
+      case "triangle":
+      case "quad": {
+        const points = (element.points ?? []).flatMap((point) => [point.x, point.y])
+        if (points.length < 4) break
+        const closed = element.type !== "line"
+        elements.push({
+          type: "line",
+          points,
+          width: style.width ?? style.border ?? 1,
+          color: level(style.color),
+          closed,
+          fill: closed && style.fill === true,
+        })
+        break
+      }
+      case "image":
+        if (element.data && element.data.length <= MAX_IMAGE_CHARS)
+          elements.push({type: "image", x, y, w, h, data: element.data})
+        break
+    }
+  }
+  const frame = {width: canvas.width, height: canvas.height, elements}
+  return JSON.stringify(frame).length > MAX_FRAME_BYTES ? null : frame
+}
+
+export interface AppleWatchCommandDeps {
+  apps: () => readonly ClientApp[]
+  start: (app: ClientApp) => Promise<unknown>
+  stop: (packageName: string) => Promise<unknown>
+  ask: (query: string) => Promise<unknown>
+  type: (stream: string, payload: unknown) => void
+  now: () => number
+}
+
+const defaultDeps: AppleWatchCommandDeps = {
+  apps: () => useAppStatusStore.getState().apps,
+  start: (app) => useAppStatusStore.getState().start(app),
+  stop: (packageName) => useAppStatusStore.getState().stop(packageName),
+  ask: (query) => localMiniappRuntime.invokeActionFromHost(ASSIST_PACKAGE, ASSIST_ACTION, {query}),
+  type: (stream, payload) => localMiniappRuntime.forwardEvent(stream, payload),
+  now: () => Date.now(),
+}
+
+export async function handleAppleWatchCommand(
+  event: AppleWatchCommandEvent,
+  deps: AppleWatchCommandDeps = defaultDeps,
+): Promise<void> {
+  switch (event.command) {
+    case "launch": {
+      const app = launchableApps(deps.apps()).some((entry) => entry.packageName === event.packageName)
+        ? deps.apps().find((entry) => entry.packageName === event.packageName)
+        : undefined
+      if (!app) {
+        console.warn(`AppleWatch: launch of unknown miniapp ${event.packageName}`)
+        return
+      }
+      await deps.start(app)
+      return
+    }
+    case "stop": {
+      const front = deps.apps().find((app) => app.foregrounded && app.running && app.type === "standard")
+      if (front) await deps.stop(front.packageName)
+      return
+    }
+    case "assist": {
+      const query = event.text.trim()
+      if (query) await deps.ask(query)
+      return
+    }
+    case "text":
+      for (const key of keyEventsForTextChange("", event.text, deps.now()))
+        deps.type(MiniappStreamType.KEYBOARD_EVENT, key)
+      return
+  }
+}
+
+let stops: (() => void)[] = []
+let stopMirror: (() => void) | null = null
+
+function currentState(): Record<string, unknown> {
+  const glasses = useGlassesStore.getState()
+  return watchState({
+    glasses: {
+      connected: isGlassesConnected(glasses.connection),
+      model: glasses.deviceModel,
+      battery: glasses.batteryLevel,
+    },
+    apps: useAppStatusStore.getState().apps,
+    assist: localMiniappRuntime.hostActionAvailable(ASSIST_PACKAGE, ASSIST_ACTION),
+    mirror: useSettingsStore.getState().getSetting(SETTINGS.apple_watch_mirror.key) === true,
+  })
+}
+
+function syncMirror(enabled: boolean): void {
+  if (!enabled) {
+    if (stopMirror) {
+      stopMirror()
+      stopMirror = null
+      void BluetoothSdk.setWatchMirror(null).catch(() => {})
+    }
+    return
+  }
+  if (stopMirror) return
+  let lastSentAt = 0
+  let pending: MirrorSnapshot | null = null
+  let timer: ReturnType<typeof BgTimer.setTimeout> | null = null
+  const send = (snapshot: MirrorSnapshot) => {
+    lastSentAt = Date.now()
+    void BluetoothSdk.setWatchMirror(mirrorFrame(snapshot)).catch((err) =>
+      console.warn("AppleWatch: mirror push failed:", err),
+    )
+  }
+  const unsubscribe = mirrorService.subscribe((snapshot) => {
+    const wait = lastSentAt + MIRROR_INTERVAL_MS - Date.now()
+    if (wait <= 0 && !timer) {
+      send(snapshot)
+      return
+    }
+    pending = snapshot
+    timer ??= BgTimer.setTimeout(
+      () => {
+        timer = null
+        if (pending) send(pending)
+        pending = null
+      },
+      Math.max(wait, 0),
+    )
+  })
+  stopMirror = () => {
+    unsubscribe()
+    if (timer) BgTimer.clearTimeout(timer)
+    timer = null
+  }
+}
+
+export function startAppleWatchLink(): void {
+  if (Platform.OS !== "ios" || stops.length > 0) return
+  let lastKey = ""
+  let timer: ReturnType<typeof BgTimer.setTimeout> | null = null
+  const push = () => {
+    timer = null
+    const state = currentState()
+    const key = JSON.stringify(state)
+    if (key === lastKey) return
+    lastKey = key
+    void BluetoothSdk.setWatchState(state).catch((err) => console.warn("AppleWatch: state push failed:", err))
+  }
+  const schedule = () => {
+    timer ??= BgTimer.setTimeout(push, STATE_DEBOUNCE_MS)
+  }
+  const mirrorEnabled = () => useSettingsStore.getState().getSetting(SETTINGS.apple_watch_mirror.key) === true
+  const commands = BluetoothSdk.addListener("apple_watch_command", (event) => {
+    handleAppleWatchCommand(event).catch((err) => console.warn(`AppleWatch: ${event.command} failed:`, err))
+  })
+  stops = [
+    () => commands.remove(),
+    useGlassesStore.subscribe(schedule),
+    useAppStatusStore.subscribe(schedule),
+    useSettingsStore.subscribe(
+      (s) => s.getSetting(SETTINGS.apple_watch_mirror.key),
+      () => {
+        syncMirror(mirrorEnabled())
+        schedule()
+      },
+    ),
+    () => {
+      if (timer) BgTimer.clearTimeout(timer)
+      timer = null
+    },
+  ]
+  syncMirror(mirrorEnabled())
+  schedule()
+}
+
+export function stopAppleWatchLink(): void {
+  stops.splice(0).forEach((stop) => stop())
+  syncMirror(false)
+}

package/src/services/controllers.ts

@@ -26,9 +26,26 @@ const NEURAL_BAND_SURFACE: InputSurface = {
   ],
 }
 
+/** The Apple Watch trackpad's taps and four-way swipes, and the Digital Crown as the dial. */
+const APPLE_WATCH_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.APPLE_WATCH]: [APPLE_WATCH_SURFACE],
   [ControllerTypes.R1]: [],
 }
 

package/src/services/manifestActions.ts

@@ -79,29 +79,41 @@ export function normalizeManifestActions(raw: unknown): DeclaredAction[] {
   return out
 }
 
-const WIDGET_SIZES: readonly DeclaredWidgetSize[] = ["XS", "SM", "MD", "LG"]
+const WIDGET_SIZES: readonly DeclaredWidgetSize[] = ["XS", "XSM", "SM", "MD", "LG"]
 const isWidgetSize = (value: unknown): value is DeclaredWidgetSize => (WIDGET_SIZES as readonly unknown[]).includes(value)
 
 /**
  * Normalize manifest widgets for installed and dev-sideloaded bundles: an
- * entry without an id, a name or a usable size is dropped, repeats of a
+ * entry without an id, a name or a usable card size is dropped, repeats of a
  * size are folded, and a default size the widget does not offer becomes
- * its first size.
+ * its first size. Listing `EX` makes a widget expandable; it is not a card
+ * size. Taps expand it until the wearer turns that off (AppRegistry applies
+ * the choice).
  */
 export function normalizeManifestWidgets(raw: unknown): DeclaredWidget[] {
   if (!Array.isArray(raw)) return []
   const out: DeclaredWidget[] = []
   const seen = new Set<string>()
-  for (const w of raw as Array<{id?: unknown; name?: unknown; sizes?: unknown; defaultSize?: unknown}>) {
+  for (const w of raw as Array<{
+    id?: unknown
+    name?: unknown
+    sizes?: unknown
+    defaultSize?: unknown
+    expandable?: unknown
+  }>) {
     if (!w || typeof w.id !== "string" || !w.id || typeof w.name !== "string" || !w.name || seen.has(w.id)) continue
     const sizes = Array.isArray(w.sizes) ? Array.from(new Set(w.sizes.filter(isWidgetSize))) : []
     if (sizes.length === 0) continue
     seen.add(w.id)
+    // `expandable: true` is how bundles from before `EX` said the same.
+    const expandable = (Array.isArray(w.sizes) && w.sizes.includes("EX")) || w.expandable === true
     out.push({
       id: w.id,
       name: w.name,
       sizes,
       defaultSize: isWidgetSize(w.defaultSize) && sizes.includes(w.defaultSize) ? w.defaultSize : sizes[0],
+      expandable,
+      expandOnTap: expandable,
     })
   }
   return out

package/src/services/memoryBackupFile.ts

@@ -0,0 +1,50 @@
+/**
+ * Memory backup files: the share-sheet export and file-picker import behind
+ * Settings > Memory and session.memory.exportFile/importFile.
+ */
+
+import type {MemoryExportResult, MemoryImportResult} from "@glassly/miniapp"
+import {File, Paths} from "expo-file-system"
+import {Platform} from "react-native"
+import Share from "react-native-share"
+
+import {MemoryBackupError} from "./MemoryStore"
+import {memoryStore} from "./memoryStoreInstance"
+
+// Some Android document providers report .json files as octet-stream.
+const PICK_MIME_TYPES =
+  Platform.OS === "android" ? ["application/json", "application/octet-stream"] : ["application/json"]
+
+export async function exportMemoryFile(): Promise<MemoryExportResult> {
+  const backup = await memoryStore.exportBackup()
+  const filename = `glassly-memory-${localDate(backup.exportedAt)}.json`
+  const file = new File(Paths.cache, filename)
+  file.writeSync(JSON.stringify(backup))
+  try {
+    await Share.open({url: file.uri, type: "application/json", filename, title: "Glassly memory"})
+    return {success: true}
+  } catch (error: any) {
+    // react-native-share rejects when the user dismisses the sheet.
+    if (error?.message?.includes("User did not share")) return {success: false, cancelled: true}
+    throw error
+  }
+}
+
+/** Resolves null when the user cancels the picker. */
+export async function importMemoryFile(): Promise<MemoryImportResult | null> {
+  const picked = await File.pickFileAsync({mimeTypes: PICK_MIME_TYPES})
+  if (picked.canceled) return null
+  let data: unknown
+  try {
+    data = JSON.parse(await picked.result.text())
+  } catch {
+    throw new MemoryBackupError("Not a Glassly memory backup")
+  }
+  return memoryStore.importBackup(data)
+}
+
+function localDate(ms: number): string {
+  const d = new Date(ms)
+  const pad = (n: number) => String(n).padStart(2, "0")
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`
+}

package/src/services/settingsBridge.ts

@@ -6,10 +6,10 @@
  * be tested without the native import surface the runtime pulls in.
  *
  * A dashboard miniapp is the usual consumer: it edits the notification,
- * glasses-menu and display-position keys the phone's settings screens used
- * to, through the store, so persistence, server sync and the Bluetooth sync
- * of `menu_apps` and the position behave as if a phone screen wrote them. A dashboard's own look is not here; it keeps
- * that in its storage.
+ * glasses-menu, display-position, brightness and microphone keys the phone's
+ * settings screens do, through the store, so persistence, server sync and the
+ * Bluetooth sync behave as if a phone screen wrote them. A dashboard's own
+ * look is not here; it keeps that in its storage.
  */
 
 import type {ControllerStatus, PairedController} from "@glassly/bluetooth-sdk"
@@ -28,6 +28,11 @@ export const SETTINGS_BRIDGE_KEYS: Readonly<Record<string, SettingsBridgeAccess>
   // Where the glasses draw; each model's steps are its display.positionRange.
   dashboard_depth: "write",
   dashboard_height: "write",
+  // Device settings the dashboard's glasses Settings page edits.
+  brightness: "write",
+  auto_brightness: "write",
+  // Per paired model: the store resolves the indexed key.
+  preferred_mic: "write",
   twelve_hour_time: "write",
   menu_apps: "write",
   notifications_enabled: "write",

package/src/services/widgetPlacements.ts

@@ -2,12 +2,14 @@
  * Who placed which widget where: the pure bookkeeping behind the runtime's
  * widget routing. A placement is one host's box for one provider widget;
  * a provider is placed while any host holds one of its widgets. Frames are
- * kept per widget so a host that places one again gets the last frame
- * at once.
+ * kept per widget and view so a host that places one again gets the last
+ * card and expanded frames at once.
  */
 
+export type WidgetView = "card" | "expanded"
+
 export interface WidgetBox {
-  size: "XS" | "SM" | "MD" | "LG"
+  size: "XS" | "XSM" | "SM" | "MD" | "LG"
   width: number
   height: number
 }
@@ -22,8 +24,8 @@ export interface Placement {
 export interface WidgetPlacements {
   /** Keyed by `${host}|${provider}/${widgetId}`. */
   placements: ReadonlyMap<string, Placement>
-  /** The latest frame per `${provider}/${widgetId}`. */
-  frames: ReadonlyMap<string, unknown[]>
+  /** The latest frame per `${provider}/${widgetId}` and view. */
+  frames: ReadonlyMap<string, Readonly<Partial<Record<WidgetView, unknown[]>>>>
 }
 
 export const widgetKey = (providerPackageName: string, widgetId: string): string => `${providerPackageName}/${widgetId}`
@@ -71,14 +73,26 @@ export function dropProvider(state: WidgetPlacements, providerPackageName: strin
   return placements.size === state.placements.size ? state : {...state, placements}
 }
 
-export function setFrame(state: WidgetPlacements, providerPackageName: string, widgetId: string, elements: unknown[]): WidgetPlacements {
+export function setFrame(
+  state: WidgetPlacements,
+  providerPackageName: string,
+  widgetId: string,
+  elements: unknown[],
+  view: WidgetView = "card",
+): WidgetPlacements {
+  const key = widgetKey(providerPackageName, widgetId)
   const frames = new Map(state.frames)
-  frames.set(widgetKey(providerPackageName, widgetId), elements)
+  frames.set(key, {...state.frames.get(key), [view]: elements})
   return {...state, frames}
 }
 
-export function frameOf(state: WidgetPlacements, providerPackageName: string, widgetId: string): unknown[] | null {
-  return state.frames.get(widgetKey(providerPackageName, widgetId)) ?? null
+export function frameOf(
+  state: WidgetPlacements,
+  providerPackageName: string,
+  widgetId: string,
+  view: WidgetView = "card",
+): unknown[] | null {
+  return state.frames.get(widgetKey(providerPackageName, widgetId))?.[view] ?? null
 }
 
 export function placementOf(

package/src/stores/apps.ts

@@ -19,7 +19,7 @@ import {DeviceTypes} from "../types/enums"
 import {getModelCapabilities} from "../types/hardware"
 import {HardwareCompatibility, type CompatibilityResult} from "../utils/hardware/hardware"
 import {storage} from "../utils/storage/storage"
-import appRegistry, {saveAlwaysOnOverride} from "../services/AppRegistry"
+import appRegistry, {saveAlwaysOnOverride, saveWidgetExpandChoice} from "../services/AppRegistry"
 import localDisplayManager from "../services/LocalDisplayManager"
 import {islandNotifications} from "../services/NotificationsEmitter"
 import sttModelManager from "../services/STTModelManager"
@@ -103,6 +103,12 @@ interface AppStatusState {
    * off leaves it running. Persists the wearer's choice beside the hidden flag.
    */
   setAlwaysOn: (packageName: string, status: boolean) => Promise<void>
+  /**
+   * Whether a tap on one of the miniapp's dashboard widgets expands it to the
+   * full screen. Only widgets that list `EX` expand; false for the rest.
+   * Persists the choice and answers the setting now in force.
+   */
+  setWidgetExpand: (packageName: string, widgetId: string, expandOnTap: boolean) => boolean
   /** Replace the whole apps array. Hosts use this when their extra source changes. */
   setApps: (apps: ClientApp[]) => void
 }
@@ -256,6 +262,7 @@ function projectApps(previousState: AppStatusState, localApps: ClientApp[]): Cli
         // across both passes.
         foregrounded: app.packageName === previousState.foregroundedPackage,
         paused: app.local && app.running && isMiniappsPaused(),
+        widgetOnly: !!app.local && app.running && miniappWidgetMode.isWidgetOnly(app.packageName),
       }
       const prev = previousByPackage.get(app.packageName)
       return prev && shallowEqualApp(prev, next) ? prev : next
@@ -362,6 +369,11 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
       return false
     }
 
+    // An app running only for its widget is promoted before the host hook:
+    // the hook may foreground it, and setForeground sends a widget-only app
+    // back here.
+    if (app.widgetOnly) miniappWidgetMode.setWidgetOnly(packageName, false)
+
     // Host navigation / open-animation seam. Runs on EVERY accepted open —
     // including re-opening an already-running app — so the animation always
     // plays (BuiltInMiniappCatalog.navigateForApp: overlay apps setForeground
@@ -374,13 +386,12 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
 
     // If the tapped app is already running, this is a re-open: the nav/foreground
     // above already drove the animation, and there's nothing to spawn. Short-
-    // circuit before the spawn pipeline. An app running only for its widget
-    // is promoted instead: it keeps its context and takes the foreground.
+    // circuit before the spawn pipeline. A promoted app keeps its context but
+    // still takes the foreground below.
     if (app.running && !app.widgetOnly) {
       saveLastOpenTime(packageName)
       return true
     }
-    if (app.widgetOnly) miniappWidgetMode.setWidgetOnly(packageName, false)
 
     // Only-one rules: one standard app in the foreground, one dashboard
     // drawing the overlay. Starting another stops the one running. Widget-only
@@ -495,13 +506,10 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
       apps: s.apps.map((a) => ({...a, foregrounded: a.packageName === packageName})),
     }))
 
-    // Ensure the JSContext exists. start() is idempotent for an
-    // already-running app and enforces the foreground-only-one rule for
-    // standard apps. Fire-and-forget after the flag flip so it doesn't block
-    // paint.
-    // if (!app.running) {
-    //   get().start(app)
-    // }
+    // The wearer is in this app now: one running only for its widget becomes
+    // a normal run. start() promotes it, stops the standard peer and keeps the
+    // context. Fire-and-forget after the flag flip so it doesn't block paint.
+    if (app.running && app.widgetOnly) void get().start(app, {skipNavigation: true})
   },
 
   clearForeground: () => {
@@ -585,6 +593,22 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
     if (status && !app.running) await get().start(app, {skipNavigation: true})
   },
 
+  setWidgetExpand: (packageName, widgetId, expandOnTap) => {
+    const app = get().apps.find((a) => a.packageName === packageName)
+    const widget = app?.widgets?.find((w) => w.id === widgetId)
+    if (!widget?.expandable) return false
+    if (widget.expandOnTap === expandOnTap) return expandOnTap
+    saveWidgetExpandChoice(packageName, widgetId, expandOnTap)
+    set((s) => ({
+      apps: s.apps.map((a) =>
+        a.packageName === packageName
+          ? {...a, widgets: a.widgets?.map((w) => (w.id === widgetId ? {...w, expandOnTap} : w))}
+          : a,
+      ),
+    }))
+    return expandOnTap
+  },
+
   setApps: (apps) => set({apps}),
 }))
 

package/src/stores/bluetoothSettingKeys.ts

@@ -35,3 +35,23 @@ function isMentraLiveDevice(model: string | undefined): boolean {
 export function getBluetoothSettingKeysForDevice(deviceModel: string | undefined, fullKeys: string[]): string[] {
   return isMentraLiveDevice(deviceModel) ? MENTRA_LIVE_SETTING_KEYS : fullKeys
 }
+
+/**
+ * Glasses Menu entries the firmware's own menu cannot open: Settings is the
+ * dashboard's glasses page, which only the dashboard's Apps menu shows.
+ */
+const NATIVE_MENU_EXCLUDED_PACKAGES = new Set(["com.glassly.settings"])
+const nativeMenuAppsCache = new WeakMap<object, unknown[]>()
+
+/** `menu_apps` as the glasses get it; the same array in gives the same array out, so the change-push stays quiet. */
+export function nativeMenuApps(value: unknown): unknown {
+  if (!Array.isArray(value)) return value
+  let filtered = nativeMenuAppsCache.get(value)
+  if (!filtered) {
+    filtered = value.filter(
+      (item) => !NATIVE_MENU_EXCLUDED_PACKAGES.has((item as {packageName?: string} | null)?.packageName ?? ""),
+    )
+    nativeMenuAppsCache.set(value, filtered)
+  }
+  return filtered
+}