@glassly/engine 0.3.1-dev.494 → 0.3.1-dev.523

package/src/services/MiniappLauncher.ts

@@ -28,10 +28,9 @@ import {File} from "expo-file-system"
 import {permissions} from "../facades/permissions"
 import {decideDevLaunchRoute} from "../utils/devMiniappLaunch"
 import {storage} from "../utils/storage/storage"
-import appRegistry, {getLocalAppRunningState, saveLocalAppRunningState} from "./AppRegistry"
+import appRegistry from "./AppRegistry"
 import devServerBridge from "./DevServerBridge"
 import localMiniappRuntime, {type InstalledMiniappManifest} from "./LocalMiniappRuntime"
-import {activeDashboardAmong} from "./pages/activeDashboard"
 import type {MiniappLaunchSource} from "@glassly/miniapp"
 import type {JSRouter} from "./JSRouter"
 
@@ -284,44 +283,43 @@ class MiniappLauncher {
   }
 
   /**
-   * Re-spawn local miniapps that were running when the app was last killed.
+   * Start the Always On local miniapps at boot.
    *
    * Miniapps run in the phone's own JS engine, so a host-process kill tears
-   * down their JSContext with nothing to resurrect them. Without this they
-   * would silently stay stopped on the next launch even though the user left
-   * them running.
+   * down their JSContext. Only Always On apps come back: whatever else was
+   * running when the app was killed stays stopped until the wearer opens it
+   * again. The spawn is headless (no foreground, no navigation) and registers
+   * the package so the home tray/switcher project it as running, exactly as a
+   * normal start would. The WebView, if any, re-attaches lazily when the user
+   * opens the app.
    *
-   * Each local miniapp persists its running flag to disk on start/stop
-   * (`saveLocalAppRunningState`, via the applet's `onStart`/`onStop`). We read
-   * those flags back and re-spawn the background context headlessly (no
-   * foreground, no navigation) — the spawn registers the package so the home
-   * tray/switcher project it as running, exactly as a normal start would. The
-   * WebView, if any, re-attaches lazily when the user opens the app.
+   * One dashboard runs at a time: a dashboard already running keeps its place,
+   * else the first Always On dashboard by package name starts and the rest
+   * stay stopped. The flag is exclusive after any user action (setAlwaysOn
+   * clears it on the other dashboards), so this only arbitrates manifests
+   * that both claim it.
    *
-   * Idempotent and best-effort: skips already-spawned contexts, and clears the
-   * persisted flag for any app whose bundle can no longer be resolved
-   * (uninstalled, or dev server gone) so a dead entry doesn't retry every boot.
-   * Not compatibility-gated: a previously-running background app shouldn't be
-   * dropped just because glasses are momentarily disconnected at boot — it
-   * resumes when they reconnect, same as mid-session.
-   *
-   * Always On apps (the dashboard) start whether or not they were running
-   * when the app was last killed, and get a switcher card like any other app.
-   * A dashboard that does not hold the role (ADR-0009) is not started by its
-   * Always On flag.
-   * Both restore paths skip apps missing required OS permissions without
-   * prompting or clearing their saved running/Always On choice.
+   * Idempotent and best-effort: skips already-spawned contexts, and skips apps
+   * missing required OS permissions without prompting or clearing their Always
+   * On choice. Not compatibility-gated: an Always On app shouldn't be dropped
+   * just because glasses are momentarily disconnected at boot — it resumes
+   * when they reconnect, same as mid-session.
    */
   async autostartLocalMiniapps(): Promise<void> {
     const apps = await appRegistry.getInstalledMiniapps()
-    const activeDashboard = activeDashboardAmong(apps)
+    const dashboards = apps.filter((app) => app.type === "dashboard")
+    const dashboard =
+      dashboards.find((app) => this.isRunning(app.packageName))?.packageName ??
+      dashboards
+        .filter((app) => app.alwaysOn)
+        .map((app) => app.packageName)
+        .sort()[0] ??
+      null
     for (const app of apps) {
-      // Only phone-hosted miniapps have a JSContext to re-spawn. Offline
-      // built-ins (`local:false, offline:true`) restore their native running
-      // state elsewhere and have no bundle to launch.
-      if (!app.local) continue
-      const alwaysOn = app.alwaysOn && (app.type !== "dashboard" || app.packageName === activeDashboard)
-      if (!alwaysOn && !getLocalAppRunningState(app.packageName)) continue
+      // Only phone-hosted miniapps have a JSContext to spawn. Offline
+      // built-ins (`local:false, offline:true`) have no bundle to launch.
+      if (!app.local || !app.alwaysOn) continue
+      if (app.type === "dashboard" && app.packageName !== dashboard) continue
       if (this.isRunning(app.packageName)) continue
       try {
         const missing = await permissions.missingRequired(app.permissions ?? [])
@@ -340,8 +338,7 @@ class MiniappLauncher {
       try {
         await this.ensureRunning(app.packageName)
       } catch (e) {
-        console.warn(`MiniappLauncher: autostart failed for ${app.packageName} — clearing stale running flag`, e)
-        saveLocalAppRunningState(app.packageName, false)
+        console.warn(`MiniappLauncher: autostart failed for ${app.packageName}`, e)
       }
     }
   }

package/src/services/MiniappPauseCoordinator.ts

@@ -0,0 +1,100 @@
+/**
+ * MiniappPauseCoordinator — pauses every local miniapp while the paired
+ * glasses are disconnected.
+ *
+ * A paused miniapp keeps its JSContext and state. The runtime tells it
+ * (`session.on("pause")`), stops fanning out streams to it, and drops the mic
+ * and transcription demand its subscriptions were holding, until the glasses
+ * are back. The pause waits out a grace window so a BLE blip does not pause
+ * and resume an app within a second; resume is immediate on reconnect.
+ *
+ * Only a phone paired to real glasses pauses. With nothing paired, or with the
+ * simulated device, there is nothing to reconnect to and miniapps keep running
+ * (the mirror and dev flows depend on that).
+ */
+import {useGlassesStore} from "../stores/glasses"
+import {BgTimer} from "../utils/timers"
+import {isGlassesConnected, type GlassesConnectionStatus} from "./GlassesReadiness"
+import {isPairedToRealGlasses} from "./PairedGlassesLatch"
+import {projectPairingIdentity, subscribePairingIdentity, type IdentitySnapshot} from "./PairingIdentity"
+
+export const MINIAPP_PAUSE_GRACE_MS = 10_000
+
+export type MiniappPauseReason = "glasses_disconnected"
+
+type Listener = (paused: boolean) => void
+
+let started = false
+let paused = false
+let graceTimer: number | null = null
+const listeners = new Set<Listener>()
+let unsubscribers: Array<() => void> = []
+
+/** Paired to real glasses that are not connected. */
+export function shouldPauseMiniapps(identity: IdentitySnapshot, connection: GlassesConnectionStatus): boolean {
+  return isPairedToRealGlasses(identity) && !isGlassesConnected(connection)
+}
+
+export function isMiniappsPaused(): boolean {
+  return paused
+}
+
+/** Fires on pause/resume transitions only. */
+export function onMiniappsPauseChange(listener: Listener): () => void {
+  listeners.add(listener)
+  return () => {
+    listeners.delete(listener)
+  }
+}
+
+function setPaused(next: boolean): void {
+  if (paused === next) return
+  paused = next
+  console.log(`MiniappPauseCoordinator: ${next ? "paused" : "resumed"} local miniapps`)
+  for (const listener of listeners) {
+    try {
+      listener(next)
+    } catch (e) {
+      console.warn("MiniappPauseCoordinator: listener threw", e)
+    }
+  }
+}
+
+function clearGrace(): void {
+  if (graceTimer === null) return
+  BgTimer.clearTimeout(graceTimer)
+  graceTimer = null
+}
+
+function wanted(): boolean {
+  return shouldPauseMiniapps(projectPairingIdentity(), useGlassesStore.getState().connection)
+}
+
+function evaluate(): void {
+  if (!wanted()) {
+    clearGrace()
+    setPaused(false)
+    return
+  }
+  if (paused || graceTimer !== null) return
+  graceTimer = BgTimer.setTimeout(() => {
+    graceTimer = null
+    if (wanted()) setPaused(true)
+  }, MINIAPP_PAUSE_GRACE_MS)
+}
+
+/** Start after the persisted settings are loaded so the pairing identity reads true. */
+export function startMiniappPauseCoordinator(): void {
+  if (started) return
+  started = true
+  unsubscribers = [useGlassesStore.subscribe((s) => s.connection.state, evaluate), subscribePairingIdentity(evaluate)]
+  evaluate()
+}
+
+export function stopMiniappPauseCoordinator(): void {
+  for (const unsubscribe of unsubscribers) unsubscribe()
+  unsubscribers = []
+  clearGrace()
+  paused = false
+  started = false
+}

package/src/services/OfflineTranslationManager.ts

@@ -0,0 +1,40 @@
+import {Platform} from "react-native"
+import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
+import type {OfflineTranslationLanguage, OfflineTranslationStatus} from "@glassly/bluetooth-sdk"
+
+export type {OfflineTranslationLanguage, OfflineTranslationStatus}
+
+/** Headless on-device translation needs the iOS 26 Translation framework. */
+export function offlineTranslationSupported(): boolean {
+  return Platform.OS === "ios" && parseInt(String(Platform.Version), 10) >= 26
+}
+
+/**
+ * On-device translation language packs. The OS owns the assets: there is no
+ * download progress or removal API, only install state and a system prompt
+ * that downloads a pair.
+ */
+export const offlineTranslationManager = {
+  isSupported: offlineTranslationSupported,
+
+  /** Languages `source` can be translated into, with their install state. */
+  async languages(source: string): Promise<OfflineTranslationLanguage[]> {
+    if (!offlineTranslationSupported()) return []
+    return BluetoothSdk.getOfflineTranslationLanguages(source)
+  },
+
+  async status(source: string, target: string): Promise<OfflineTranslationStatus> {
+    if (!offlineTranslationSupported()) return "unavailable"
+    return BluetoothSdk.getOfflineTranslationStatus(source, target)
+  },
+
+  /** Shows the system download prompt; resolves with the pair's status afterwards. */
+  async download(source: string, target: string): Promise<OfflineTranslationStatus> {
+    if (!offlineTranslationSupported()) return "unavailable"
+    return BluetoothSdk.downloadOfflineTranslation(source, target)
+  },
+
+  translate(text: string, source: string, target: string): Promise<string> {
+    return BluetoothSdk.translateOffline(text, source, target)
+  },
+}

package/src/services/pages/OverlayPages.ts

@@ -1,12 +1,12 @@
 /**
- * The overlay app's page (ADR-0006, ADR-0009): one Page per dashboard that
+ * The overlay app's page (ADR-0006, ADR-0010): one Page per dashboard that
  * has taken the slot, the only Page implementation the page host shows. The
  * engine keeps the slot and the eligibility watch; a page only relays:
  * holding the slot is reported to its app as a view change, and the app's
  * frames reach the slot through `renderOverlay` under its package name. Only
- * the dashboard that holds the role may show; when the role moves, the
- * previous holder hears it was replaced. The runtime supplies the sink that
- * delivers to apps, so this module never imports it.
+ * the connected dashboard may show; a stopping one is removed without a
+ * word. The runtime supplies the sink that delivers to apps, so this module
+ * never imports it.
  */
 import pageHost, {type Page, type PageHiddenReason} from "./PageHost"
 import {isOverlayApp} from "./overlayApps"
@@ -45,7 +45,7 @@ class OverlayPages {
     return pageHost.showing === page
   }
 
-  /** Release the slot if the app holds it; "replaced" when the dashboard role moved on. */
+  /** Release the slot if the app holds it. */
   hide(packageName: string, reason: PageHiddenReason = "hidden"): void {
     const page = this.pages.get(packageName)
     if (page) pageHost.hide(page, reason)

package/src/services/pages/overlayApps.ts

@@ -1,12 +1,14 @@
 /**
- * The overlay app: the connected miniapp that holds the dashboard role
- * (ADR-0009). It alone may take the overlay slot through
- * `session.display.showView("dashboard")` and has "dashboard" in its
- * `display.views` capability while the glasses are eligible. The runtime
- * records each dashboard miniapp (manifest type "dashboard") as it connects
- * and stops, and who holds the role; the engine never knows what a dashboard
- * draws. Kept free of imports so the runtime and the notification policy can
- * both read it without a cycle.
+ * The overlay app: the connected dashboard miniapp (ADR-0010). It alone may
+ * take the overlay slot through `session.display.showView("dashboard")` and
+ * has "dashboard" in its `display.views` capability while the glasses are
+ * eligible. The runtime records each dashboard miniapp (manifest type
+ * "dashboard") as it connects and stops; the first connected one holds the
+ * role until it stops, and the engine never knows what a dashboard draws.
+ * Only one dashboard runs at a time (the apps store stops the previous one
+ * before starting another), so two connected at once is a transient. Kept
+ * free of imports so the runtime and the notification policy can both read
+ * it without a cycle.
  */
 
 export type DisplayView = "main" | "dashboard"
@@ -18,9 +20,9 @@ const listening = new Set<string>()
 let active: string | null = null
 const listeners = new Set<() => void>()
 
-/** `packageName` holds the dashboard role and is connected. */
+/** `packageName` holds the dashboard role. */
 export function isOverlayApp(packageName: string): boolean {
-  return packageName === active && connected.has(packageName)
+  return packageName === active
 }
 
 /** `packageName` is a connected dashboard miniapp, whether or not it holds the role. */
@@ -29,29 +31,27 @@ export function isDashboardApp(packageName: string): boolean {
 }
 
 export function overlayApps(): readonly string[] {
-  return active !== null && connected.has(active) ? [active] : []
+  return active !== null ? [active] : []
 }
 
-/** The package that holds the dashboard role, connected or not. */
+/** The connected dashboard that holds the role, or null for nobody. */
 export function activeDashboard(): string | null {
   return active
 }
 
-export function setActiveDashboard(packageName: string | null): void {
-  if (active === packageName) return
-  active = packageName
-  emit()
-}
-
+/** A dashboard connected: it takes the role when nobody holds it. */
 export function addDashboardApp(packageName: string): void {
   if (connected.has(packageName)) return
   connected.add(packageName)
+  if (active === null) active = packageName
   emit()
 }
 
+/** A dashboard stopped: the role passes to another connected one, by package name, else to nobody. */
 export function removeDashboardApp(packageName: string): void {
   listening.delete(packageName)
   if (!connected.delete(packageName)) return
+  if (active === packageName) active = [...connected].sort()[0] ?? null
   emit()
 }
 
@@ -65,7 +65,7 @@ export function setOverlayViewer(packageName: string, subscribed: boolean): void
 
 /** The overlay app presents phone notifications. */
 export function overlayViewerRunning(): boolean {
-  return active !== null && connected.has(active) && listening.has(active)
+  return active !== null && listening.has(active)
 }
 
 export function onOverlayAppsChange(listener: () => void): () => void {

package/src/services/settingsBridge.ts

@@ -5,10 +5,10 @@
  * request validation. Pure, so the runtime's handlers stay thin and this can
  * be tested without the native import surface the runtime pulls in.
  *
- * A dashboard miniapp is the usual consumer: it edits the notification and
- * glasses-menu keys the phone's settings screens used to, through the store,
- * so persistence, server sync and the Bluetooth sync of `menu_apps` behave as
- * if a phone screen wrote them. A dashboard's own look is not here; it keeps
+ * 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.
  */
 
@@ -19,6 +19,10 @@ export const SETTINGS_BRIDGE_KEYS: Readonly<Record<string, SettingsBridgeAccess>
   // The dashboard's master switch is a phone-side debug knob.
   custom_dashboard_enabled: "read",
   contextual_dashboard: "write",
+  head_up_angle: "write",
+  // Where the glasses draw; each model's steps are its display.positionRange.
+  dashboard_depth: "write",
+  dashboard_height: "write",
   twelve_hour_time: "write",
   menu_apps: "write",
   notifications_enabled: "write",
@@ -33,16 +37,11 @@ export const SETTINGS_BRIDGE_KEYS: Readonly<Record<string, SettingsBridgeAccess>
 
 /**
  * Read-only keys the engine computes: whether the wearer can see the phone,
- * whether the foreground miniapp is drawing on the glasses, the ring's
- * battery, and the package that holds the dashboard role (null for nobody).
- * They change on their own clocks; the runtime pushes them like stored keys.
+ * whether the foreground miniapp is drawing on the glasses, and the ring's
+ * battery. They change on their own clocks; the runtime pushes them like
+ * stored keys.
  */
-export const DERIVED_SETTINGS_KEYS = [
-  "phone_active",
-  "foreground_app_on_screen",
-  "ring_battery",
-  "active_dashboard",
-] as const
+export const DERIVED_SETTINGS_KEYS = ["phone_active", "foreground_app_on_screen", "ring_battery"] as const
 export type DerivedSettingsKey = (typeof DERIVED_SETTINGS_KEYS)[number]
 
 export function isDerivedSettingsKey(key: string): key is DerivedSettingsKey {

package/src/stores/apps.ts

@@ -24,8 +24,8 @@ import localDisplayManager from "../services/LocalDisplayManager"
 import {islandNotifications} from "../services/NotificationsEmitter"
 import sttModelManager from "../services/STTModelManager"
 import {miniappLauncher} from "../services/MiniappLauncher"
+import {isMiniappsPaused, onMiniappsPauseChange} from "../services/MiniappPauseCoordinator"
 import {miniappRunningRegistry} from "../services/MiniappRunningRegistry"
-import {activeDashboardAmong, resolveActiveDashboard} from "../services/pages/activeDashboard"
 import {defaultHiddenStatus, isGatedByDevTools, isGatedUntilPaired, resolveHiddenStatus} from "./appVisibility"
 import {SETTINGS, useSettingsStore} from "./settings"
 import BluetoothSdk from "@glassly/bluetooth-sdk"
@@ -102,7 +102,6 @@ interface AppStatusState {
    * off leaves it running. Persists the wearer's choice beside the hidden flag.
    */
   setAlwaysOn: (packageName: string, status: boolean) => Promise<void>
-  setActiveDashboard: (packageName: string) => Promise<void>
   /** Replace the whole apps array. Hosts use this when their extra source changes. */
   setApps: (apps: ClientApp[]) => void
 }
@@ -255,6 +254,7 @@ function projectApps(previousState: AppStatusState, localApps: ClientApp[]): Cli
         // through to the root router (restart). Deriving here keeps the flag stable
         // across both passes.
         foregrounded: app.packageName === previousState.foregroundedPackage,
+        paused: app.local && app.running && isMiniappsPaused(),
       }
       const prev = previousByPackage.get(app.packageName)
       return prev && shallowEqualApp(prev, next) ? prev : next
@@ -379,12 +379,11 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
       return true
     }
 
-    // Foreground-only-one rule: stop other running standard apps.
-    if (app.type === "standard") {
-      const runningForeground = state.apps.filter(
-        (a) => a.running && a.type === "standard" && a.packageName !== packageName,
-      )
-      for (const r of runningForeground) {
+    // Only-one rules: one standard app in the foreground, one dashboard
+    // drawing the overlay. Starting another stops the one running.
+    if (app.type === "standard" || app.type === "dashboard") {
+      const runningPeers = state.apps.filter((a) => a.running && a.type === app.type && a.packageName !== packageName)
+      for (const r of runningPeers) {
         await get().stop(r.packageName)
       }
     }
@@ -413,9 +412,7 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
         set((s) => ({
           apps: s.apps.map((a) => (a.packageName === packageName ? {...a, running: false, loading: false} : a)),
         }))
-        // onStart already persisted running:true to disk (saveLocalAppRunningState)
-        // before the spawn; run onStop to undo it so a refresh/reboot doesn't
-        // resurrect a "running" app with no JS context.
+        // onStart already ran before the spawn; run onStop to undo it.
         await startStopApp(app, false)
         return false
       }
@@ -508,17 +505,9 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
 
   uninstall: (packageName, version) => {
     return Res.try_async(async () => {
-      const wasActiveDashboard = activeDashboardAmong(get().apps) === packageName
       const res = await appRegistry.uninstall(packageName, version)
       if (res.is_error()) throw res.error
       set((s) => ({apps: s.apps.filter((a) => a.packageName !== packageName)}))
-      // The dashboard role fell back to another dashboard, which was stopped
-      // when it lost the role: start it, as launch would have.
-      if (wasActiveDashboard) {
-        const apps = get().apps
-        const heir = apps.find((a) => a.packageName === activeDashboardAmong(apps))
-        if (heir?.alwaysOn && !heir.running) await get().start(heir, {skipNavigation: true})
-      }
     })
   },
 
@@ -556,46 +545,49 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
   setAlwaysOn: async (packageName: string, status: boolean) => {
     const app = get().apps.find((a) => a.packageName === packageName)
     if (!app) return
+    // One dashboard is Always On at a time: marking this one clears the others.
+    const cleared =
+      status && app.type === "dashboard"
+        ? get().apps.filter((a) => a.type === "dashboard" && a.alwaysOn && a.packageName !== packageName)
+        : []
     saveAlwaysOnOverride(packageName, status)
+    for (const other of cleared) saveAlwaysOnOverride(other.packageName, false)
     set((s) => ({
-      apps: s.apps.map((a) => (a.packageName === packageName ? {...a, alwaysOn: status} : a)),
+      apps: s.apps.map((a) => {
+        if (a.packageName === packageName) return {...a, alwaysOn: status}
+        if (cleared.includes(a)) return {...a, alwaysOn: false}
+        return a
+      }),
     }))
     if (status && !app.running) await get().start(app, {skipNavigation: true})
   },
 
-  // The dashboard role (ADR-0009) moves to `packageName`: the previous holder
-  // stops and the new one starts in the background.
-  setActiveDashboard: async (packageName: string) => {
-    const apps = get().apps
-    const next = apps.find((a) => a.packageName === packageName && a.type === "dashboard")
-    if (!next) return
-    const previous = apps.find((a) => a.packageName === activeDashboardAmong(apps))
-    await useSettingsStore.getState().setSetting(SETTINGS.active_dashboard.key, packageName)
-    if (previous?.running && previous.packageName !== packageName) await get().stop(previous.packageName)
-    if (!next.running) await get().start(next, {skipNavigation: true})
-  },
-
   setApps: (apps) => set({apps}),
 }))
 
 // Project miniappRunningRegistry membership into the store's `running` field
-// for local apps so the home tray and switcher reflect actual mount state
-// without waiting for the next refresh() cycle.
-miniappRunningRegistry.subscribe(() => {
+// (and the pause coordinator's state into `paused`) for local apps so the home
+// tray and switcher reflect actual mount state without waiting for the next
+// refresh() cycle.
+function projectLocalRunningState(): void {
   const running = new Set(miniappRunningRegistry.getAll())
+  const pausedNow = isMiniappsPaused()
   const state = useAppStatusStore.getState()
   let changed = false
   const updated = state.apps.map((app) => {
     if (!app.local) return app
     const next = running.has(app.packageName)
-    if (app.running === next) return app
+    const paused = next && pausedNow
+    if (app.running === next && (app.paused ?? false) === paused) return app
     changed = true
-    return {...app, running: next}
+    return {...app, running: next, paused}
   })
   if (changed) {
     useAppStatusStore.setState({apps: updated})
   }
-})
+}
+miniappRunningRegistry.subscribe(projectLocalRunningState)
+onMiniappsPauseChange(projectLocalRunningState)
 
 // The display-manager's core (foreground) slot is DERIVED state: always the
 // currently-running standard app, no matter HOW it came to run — user tap
@@ -677,26 +669,6 @@ export const useRunningAlwaysOnApps = () => {
   return useMemo(() => apps.filter((app) => app.alwaysOn && app.running), [apps])
 }
 
-/** Installed miniapps that can hold the dashboard role: manifest type "dashboard". */
-export const useDashboards = () => {
-  const apps = useApps()
-  return useMemo(() => apps.filter((app) => app.type === "dashboard"), [apps])
-}
-
-/** The miniapp that holds the dashboard role (ADR-0009), or null when none is installed. */
-export const useActiveDashboard = (): ClientApp | null => {
-  const dashboards = useDashboards()
-  const chosen = useSettingsStore((s) => s.getSetting(SETTINGS.active_dashboard.key))
-  return useMemo(() => {
-    const packageName = resolveActiveDashboard(
-      dashboards.map((app) => app.packageName),
-      chosen,
-      SETTINGS.active_dashboard.defaultValue(),
-    )
-    return dashboards.find((app) => app.packageName === packageName) ?? null
-  }, [dashboards, chosen])
-}
-
 /** Apps that run without a foreground surface: background ones and dashboards. */
 const isBackgroundApp = (app: ClientApp): boolean => app.type === "background" || app.type === "dashboard"
 

package/src/stores/settings.ts

@@ -806,16 +806,6 @@ export const SETTINGS: Record<string, Setting> = {
     saveOnServer: false,
     persist: true,
   },
-  // The wearer's choice of dashboard miniapp (ADR-0009). Installs are
-  // per-phone, so the choice is device-local. The default is the bundled
-  // dashboard, which the role falls back to when the choice is not installed.
-  active_dashboard: {
-    key: "active_dashboard",
-    defaultValue: () => "com.glassly.dashboard",
-    writable: true,
-    saveOnServer: false,
-    persist: true,
-  },
   head_up_angle: {key: "head_up_angle", defaultValue: () => 45, writable: true, saveOnServer: true, persist: true},
   brightness: {key: "brightness", defaultValue: () => 50, writable: true, saveOnServer: true, persist: true},
   auto_brightness: {

package/src/types/applet.ts

@@ -81,7 +81,7 @@ export interface AppletInterface {
  * outside the manifest: offline routing, hardware compatibility result,
  * loading/hidden/local flags, lifecycle hooks, screenshot, and the
  * dev-miniapp escape hatches (`devUrl` / `isMiniappDev`) that surface a
- * `glassly-miniapp dev` snapshot.
+ * `glassly dev` snapshot.
  */
 /**
  * A manifest-declared action a miniapp exposes for other miniapps to invoke
@@ -116,6 +116,8 @@ export interface ClientApp extends AppletInterface {
    * the wearer's choice persists beside the hidden flag.
    */
   alwaysOn?: boolean
+  /** Running, but paused while the paired glasses are disconnected (MiniappPauseCoordinator). */
+  paused?: boolean
   onStart?: () => void
   onStop?: () => void
   screenshot?: string

package/src/types/capabilities/even-realities-g1.ts

@@ -28,6 +28,7 @@ export const evenRealitiesG1: Capabilities = {
     fieldOfView: {horizontal: 25},
     maxTextLines: 5,
     adjustBrightness: true,
+    positionRange: {height: {min: 0, max: 8}, depth: {min: 1, max: 9}},
 
     // Scene display API — no positioned elements; scenes degrade to text walls.
     canPosition: false,

package/src/types/capabilities/even-realities-g2.ts

@@ -29,6 +29,7 @@ export const evenRealitiesG2: Capabilities = {
     fieldOfView: {horizontal: 25},
     maxTextLines: 8,
     adjustBrightness: true,
+    positionRange: {height: {min: 0, max: 12}, depth: {min: 1, max: 3}},
 
     // Scene display API — EvenHub retained containers.
     width: 576,

package/src/types/capabilities/mentra-display.ts

@@ -28,6 +28,7 @@ export const mentraDisplay: Capabilities = {
     fieldOfView: {horizontal: 25},
     maxTextLines: 5,
     adjustBrightness: true,
+    positionRange: {height: {min: 0, max: 8}, depth: {min: 1, max: 4}},
 
     // Scene display API — firmware canvas components on the 500x220 virtual
     // screen centered in the 640x480 A6N panel (mos_display_config.c).

package/src/types/capabilities/nimo.ts

@@ -32,6 +32,7 @@ export const nimo: Capabilities = {
     resolution: {width: 640, height: 400},
     maxTextLines: 5,
     adjustBrightness: true,
+    positionRange: {height: {min: 0, max: 10}, depth: {min: 0, max: 10}},
   },
 
   // Microphone capabilities - Nimo streams Opus audio from both arms