@glassly/engine 0.1.0-dev.61 → 0.1.0-dev.89

package/src/services/PhoneNotificationsSync.ts

@@ -1,24 +1,50 @@
 /**
- * Phone-notifications sync — engine-owned. Pushes the notification-forwarding
- * operational kill switch + config (`android_notification_listener_enabled`
- * and `notifications_blocklist`) to the native
- * NotificationListener via `CrustModule.setNotificationConfig`, so
+ * Phone-notifications sync — engine-owned. Started by `engine.start()`.
+ *
+ * Android: pushes the notification-forwarding operational kill switch + config
+ * (`android_notification_listener_enabled` and `notifications_blocklist`) to
+ * the native NotificationListener via `CrustModule.setNotificationConfig`, so
  * the blocklist reaches the listener for ANY host — not just the Glassly App,
  * where this used to live in MantleManager. The Android service is desired by
  * default now that its cold start is isolated from React Native. Native code
  * keeps the component discoverable in Android's notification-access Settings,
  * but only binds the service after access is granted. The debug setting remains
  * a hidden emergency kill switch; Notify's running state gates presentation,
- * not capture. Android-only; a no-op elsewhere. Started by `engine.start()`.
+ * not capture.
+ *
+ * iOS: the G2 consumes notifications on-firmware via ANCS, so the phone's job
+ * is config, not capture. This sync (a) records the apps the glasses report
+ * posting notifications (`notification_app_seen` → `ios_notification_seen_apps`)
+ * and (b) maps the shared `notifications_blocklist` + the G2 display settings
+ * onto the native `notification_filter` / `notification_ctrl` DeviceStore keys,
+ * which the bluetooth-sdk pushes to the glasses (and replays on reconnect).
+ * The firmware filter is allow-based and fail-open: an empty blocklist disables
+ * whitelisting entirely; any block enables it with allowlist = (catalog ∪ seen)
+ * minus blocked.
  */
+import {Platform} from "react-native"
 import {shallow} from "zustand/shallow"
 import CrustModule from "@glassly/crust"
+import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
+import type {
+  G2NotificationCtrlSetting,
+  G2NotificationFilterSetting,
+  NotificationAppSeenEvent,
+} from "@glassly/bluetooth-sdk/internal"
 
 import {useSettingsStore, SETTINGS} from "../stores/settings"
+import {IOS_NOTIFICATION_APP_CATALOG} from "./iosNotificationAppCatalog"
+
+export interface SeenNotificationApp {
+  appId: string
+  displayName: string
+  lastSeen: number
+}
 
 let unsubscribe: (() => void) | null = null
+let seenAppsSubscription: {remove(): void} | null = null
 
-function pushConfig(): void {
+function pushAndroidConfig(): void {
   const s = useSettingsStore.getState()
   const listenerEnabled = Boolean(s.getSetting(SETTINGS.android_notification_listener_enabled.key))
   const blocklist = s.getSetting(SETTINGS.notifications_blocklist.key)
@@ -27,20 +53,110 @@ function pushConfig(): void {
   )
 }
 
+export function getSeenNotificationApps(): SeenNotificationApp[] {
+  const seen = useSettingsStore.getState().getSetting(SETTINGS.ios_notification_seen_apps.key)
+  return Array.isArray(seen) ? (seen as SeenNotificationApp[]) : []
+}
+
+/** Catalog ∪ seen apps, seen display names winning. Sorted by name. */
+export function getKnownNotificationApps(): Array<{appId: string; displayName: string}> {
+  const merged = new Map<string, string>()
+  for (const app of IOS_NOTIFICATION_APP_CATALOG) {
+    merged.set(app.appId, app.displayName)
+  }
+  for (const app of getSeenNotificationApps()) {
+    if (app.appId) merged.set(app.appId, app.displayName || app.appId)
+  }
+  return [...merged.entries()]
+    .map(([appId, displayName]) => ({appId, displayName}))
+    .sort((a, b) => a.displayName.localeCompare(b.displayName))
+}
+
+export function computeG2NotificationFilter(): G2NotificationFilterSetting {
+  const blocklistValue = useSettingsStore.getState().getSetting(SETTINGS.notifications_blocklist.key)
+  const blocklist = Array.isArray(blocklistValue) ? (blocklistValue as string[]) : []
+  const blocked = new Set(blocklist)
+  // The list is included even while filtering is off, so the on-glass file
+  // already holds the user's current list when a first block enables it.
+  const apps = getKnownNotificationApps()
+    .filter((app) => !blocked.has(app.appId))
+    .map((app) => ({id: app.appId, name: app.displayName}))
+  return {enabled: blocked.size > 0, apps}
+}
+
+function computeG2NotificationCtrl(): G2NotificationCtrlSetting {
+  const s = useSettingsStore.getState()
+  return {
+    enabled: Boolean(s.getSetting(SETTINGS.g2_notifications_enabled.key)),
+    auto_display: Boolean(s.getSetting(SETTINGS.g2_notification_auto_display.key)),
+    disp_time: Number(s.getSetting(SETTINGS.g2_notification_disp_time.key)) || 0,
+    avoid_disturb: Boolean(s.getSetting(SETTINGS.g2_notification_avoid_disturb.key)),
+  }
+}
+
+function pushIosConfig(): void {
+  // The native DeviceStore dedupes unchanged values and replays these to the
+  // glasses on every reconnect, so pushing eagerly is cheap.
+  void Promise.resolve(
+    BluetoothSdk.updateBluetoothSettings({
+      notification_ctrl: computeG2NotificationCtrl(),
+      notification_filter: computeG2NotificationFilter(),
+    }),
+  ).catch((err: unknown) =>
+    console.warn(`PhoneNotificationsSync: notification config push failed: ${(err as Error)?.message ?? err}`),
+  )
+}
+
+/** Record a glasses-reported source app. Writes only on new app / renamed app. */
+function recordSeenApp(event: NotificationAppSeenEvent): void {
+  if (!event.appId) return
+  const seen = getSeenNotificationApps()
+  const existing = seen.find((app) => app.appId === event.appId)
+  const displayName = event.displayName || existing?.displayName || event.appId
+  if (existing && existing.displayName === displayName) return
+  const next = seen
+    .filter((app) => app.appId !== event.appId)
+    .concat([{appId: event.appId, displayName, lastSeen: event.timestamp || Date.now()}])
+  useSettingsStore.getState().setSetting(SETTINGS.ios_notification_seen_apps.key, next)
+}
+
 export function startPhoneNotificationsSync(): void {
   if (unsubscribe) return
-  pushConfig() // initial sync so the listener has the current config
+
+  if (Platform.OS === "android") {
+    pushAndroidConfig() // initial sync so the listener has the current config
+    unsubscribe = useSettingsStore.subscribe(
+      (state) => ({
+        listenerEnabled: state.getSetting(SETTINGS.android_notification_listener_enabled.key),
+        blocklist: state.getSetting(SETTINGS.notifications_blocklist.key),
+      }),
+      () => pushAndroidConfig(),
+      {equalityFn: shallow},
+    )
+    return
+  }
+
+  if (Platform.OS !== "ios") return
+
+  pushIosConfig()
   unsubscribe = useSettingsStore.subscribe(
     (state) => ({
-      listenerEnabled: state.getSetting(SETTINGS.android_notification_listener_enabled.key),
       blocklist: state.getSetting(SETTINGS.notifications_blocklist.key),
+      seenApps: state.getSetting(SETTINGS.ios_notification_seen_apps.key),
+      enabled: state.getSetting(SETTINGS.g2_notifications_enabled.key),
+      autoDisplay: state.getSetting(SETTINGS.g2_notification_auto_display.key),
+      dispTime: state.getSetting(SETTINGS.g2_notification_disp_time.key),
+      avoidDisturb: state.getSetting(SETTINGS.g2_notification_avoid_disturb.key),
     }),
-    () => pushConfig(),
+    () => pushIosConfig(),
     {equalityFn: shallow},
   )
+  seenAppsSubscription = BluetoothSdk.addListener("notification_app_seen", recordSeenApp)
 }
 
 export function stopPhoneNotificationsSync(): void {
   unsubscribe?.()
   unsubscribe = null
+  seenAppsSubscription?.remove()
+  seenAppsSubscription = null
 }

package/src/services/PhonePhotoCoordinator.ts

@@ -166,7 +166,7 @@ export class PhonePhotoCoordinator {
     // to time out. Fail fast with a typed error.
     //
     // We DON'T pre-check `hasCamera` here — the canonical capability data
-    // lives in `getModelCapabilities(deviceModel)` in the engine types and
+    // lives in `getModelCapabilities(deviceModel)` from @glassly/engine and
     // pulling that into this file would add a cross-package import. If a
     // cameraless device receives the BLE photo command, the glasses-side
     // handler will return a photo_response error within ~1s and the gated

package/src/services/PhoneStreamCoordinator.ts

@@ -796,12 +796,6 @@ export class PhoneStreamCoordinator {
       for (const reject of entry.hlsReadyRejecters) reject(pendingErr)
       entry.hlsReadyResolvers = []
       entry.hlsReadyRejecters = []
-      // Cloudflare DELETE is fire-and-forget — failing it doesn't undo the
-      // BLE stop we're about to do, and Cloudflare's idle-input scavenger
-      // will eventually clean up leaked inputs.
-      teardownManagedStream(entry.liveInputId).catch((err) => {
-        console.warn("[STREAM] teardownManagedStream failed:", err)
-      })
     }
 
     try {
@@ -816,6 +810,16 @@ export class PhoneStreamCoordinator {
       // Only clear if we're still the active entry (defensive — runExclusive
       // serializes us, so this should always be true).
       if (this.current === entry) this.current = null
+
+      if (entry.kind === "managed") {
+        // Start remote cleanup only after the publisher has stopped, but do not
+        // hold the local transition lock on an unbounded network request. The
+        // runtime's durable cleanup queue owns retries if this request fails or
+        // the app exits before Cloudflare finishes finalizing the recording.
+        void teardownManagedStream(entry.liveInputId).catch((err) => {
+          console.warn("[STREAM] teardownManagedStream failed:", err)
+        })
+      }
     }
   }
 }

package/src/services/SceneRenderer.ts

@@ -273,6 +273,10 @@ class SceneRenderer {
   }
 
   private sendFrame(frame: SceneFrame): void {
+    // Single native view: only the visible surface's frames go out. Suppressed
+    // main frames stay committed; setDashboardActive(false) replays them.
+    const dashboardActive = useDisplayStore.getState().dashboardActive
+    if (dashboardActive !== (frame.view === "dashboard")) return
     try {
       // Frames carry the canvas they were laid out against; only a frame from
       // a path that predates the tag falls back to the current capabilities.

package/src/services/StreamLifecycleController.ts

@@ -2,6 +2,10 @@
  * Drives RTMP stream liveliness checks via a keep-alive heartbeat:
  * `setActive(true)` starts the timer; each tick sends a keep-alive with a
  * fresh ackId; `maxMissedAcks` consecutive timeouts fire `onTimeout`.
+ *
+ * Phone-owned successor to the retired cloud stream lifecycle controller.
+ * It uses the local `LifecycleLogger` interface because pino is not a phone
+ * dependency.
  */
 
 export interface LifecycleLogger {

package/src/services/effectiveCapabilities.ts

@@ -9,7 +9,8 @@
  * lifted alongside the canvas, bounded only to keep frames sane.
  */
 import {useGlassesStore} from "../stores/glasses"
-import {getModelCapabilities, type Capabilities, type DeviceTypes} from "../types"
+import {DeviceTypes, getModelCapabilities, type Capabilities} from "../types"
+import {isGlasslyCfwFirmwareVersion} from "./CustomDashboardModel"
 
 const CFW_MAX_TEXT_ELEMENTS = 24
 const CFW_MAX_IMAGE_ELEMENTS = 16
@@ -28,13 +29,17 @@ export function runtimeSceneCanvas(): SceneCanvasSize | null {
 export function getEffectiveCapabilities(model: DeviceTypes): Capabilities {
   const base = getModelCapabilities(model)
   const canvas = runtimeSceneCanvas()
-  if (!base.display || !canvas) return base
+  // The firmware marker lifts the caps even when no canvas has been published:
+  // CFW classification rides the version string, and a G2 running Glassly CFW
+  // always rasterizes phone-side regardless of whether native reported dims.
+  const cfw = model === DeviceTypes.G2 && isGlasslyCfwFirmwareVersion(useGlassesStore.getState().firmwareVersion)
+  if (!base.display || (!canvas && !cfw)) return base
   return {
     ...base,
     display: {
       ...base.display,
-      width: canvas.width,
-      height: canvas.height,
+      width: canvas?.width ?? base.display.width,
+      height: canvas?.height ?? base.display.height,
       maxTextElements: Math.max(base.display.maxTextElements ?? 0, CFW_MAX_TEXT_ELEMENTS),
       maxImageElements: Math.max(base.display.maxImageElements ?? 0, CFW_MAX_IMAGE_ELEMENTS),
     },

package/src/services/iosNotificationAppCatalog.ts

@@ -0,0 +1,39 @@
+/**
+ * Seeded catalog of common iOS apps that post notifications, keyed by bundle
+ * id. iOS has no installed-apps enumeration — the filter UI shows this catalog
+ * plus apps the glasses have actually observed via ANCS — and the on-glass
+ * allowlist push needs known ids so a blocked app doesn't take every
+ * not-yet-seen app down with it (the firmware filter is allow-based).
+ */
+export interface IosNotificationApp {
+  appId: string
+  displayName: string
+}
+
+export const IOS_NOTIFICATION_APP_CATALOG: IosNotificationApp[] = [
+  {appId: "com.apple.MobileSMS", displayName: "Messages"},
+  {appId: "com.apple.mobilephone", displayName: "Phone"},
+  {appId: "com.apple.mobilemail", displayName: "Mail"},
+  {appId: "com.apple.mobilecal", displayName: "Calendar"},
+  {appId: "com.apple.reminders", displayName: "Reminders"},
+  {appId: "com.apple.facetime", displayName: "FaceTime"},
+  {appId: "net.whatsapp.WhatsApp", displayName: "WhatsApp"},
+  {appId: "ph.telegra.Telegraph", displayName: "Telegram"},
+  {appId: "org.whispersystems.signal", displayName: "Signal"},
+  {appId: "com.google.Gmail", displayName: "Gmail"},
+  {appId: "com.microsoft.Office.Outlook", displayName: "Outlook"},
+  {appId: "com.tinyspeck.chatlyio", displayName: "Slack"},
+  {appId: "com.hammerandchisel.discord", displayName: "Discord"},
+  {appId: "com.microsoft.skype.teams", displayName: "Teams"},
+  {appId: "com.facebook.Messenger", displayName: "Messenger"},
+  {appId: "com.facebook.Facebook", displayName: "Facebook"},
+  {appId: "com.burbn.instagram", displayName: "Instagram"},
+  {appId: "com.atebits.Tweetie2", displayName: "X"},
+  {appId: "com.zhiliaoapp.musically", displayName: "TikTok"},
+  {appId: "com.toyopagroup.picaboo", displayName: "Snapchat"},
+  {appId: "com.linkedin.LinkedIn", displayName: "LinkedIn"},
+  {appId: "com.google.ios.youtube", displayName: "YouTube"},
+  {appId: "com.spotify.client", displayName: "Spotify"},
+  {appId: "com.ubercab.UberClient", displayName: "Uber"},
+  {appId: "com.venmo.TouchFree", displayName: "Venmo"},
+]

package/src/services/otaInstallPolicy.ts

@@ -32,6 +32,8 @@ export const PING_INTERVAL_MS = 10_000
 export const QUERY_REPLY_TIMEOUT_MS = 6000
 /** 15s lockout on the Continue button after a BES restart, to prevent an accidental tap. */
 export const BES_CONTINUE_LOCKOUT_MS = 15_000
+/** Fail closed if a BES reboot never reconnects; normal restarts complete in a fraction of this window. */
+export const BES_RESTART_TIMEOUT_MS = 120_000
 
 // --- Legacy old-build (< MINIMUM_OTA_STATUS_BUILD) OTA policy (WP 8C) ---
 //
@@ -51,6 +53,7 @@ export const LEGACY_MTK_INSTALL_TIMEOUT_MS = MTK_INSTALL_TIMEOUT_MS + LEGACY_EXT
 export const LEGACY_GLOBAL_OTA_TIMEOUT_MS = GLOBAL_OTA_TIMEOUT_MS + LEGACY_EXTRA_TIMEOUT_MS
 export const LEGACY_PING_INTERVAL_MS = PING_INTERVAL_MS + LEGACY_EXTRA_TIMEOUT_MS
 export const LEGACY_BES_CONTINUE_LOCKOUT_MS = BES_CONTINUE_LOCKOUT_MS + LEGACY_EXTRA_TIMEOUT_MS
+export const LEGACY_BES_RESTART_TIMEOUT_MS = BES_RESTART_TIMEOUT_MS + LEGACY_EXTRA_TIMEOUT_MS
 /**
  * After a legacy apk `install FINISHED` observed in-flight, the legacy screen held the
  * completed state for 12s (+20s pad) so the ASG process restart settles (and fresh
@@ -122,6 +125,7 @@ export function selectOtaProtocolProfile(
 export const OtaProgressMessages = {
   stalledOrStuck: "Update may have failed. Ensure glasses have internet access and try again.",
   globalTimeout: "Update took too long. Please try again.",
+  restartTimeout: "Glasses did not finish restarting. Restart them before trying the update again.",
   sendOtaStartFailed: "Failed to communicate with glasses.",
   hotspotArtifactDownloadFailed: "Could not download the update to your phone. Check phone internet and try again.",
   hotspotArtifactVerifyFailed: "The update package could not be verified. Please try again later.",

package/src/stores/display.ts

@@ -29,54 +29,34 @@ const DISPLAY_COALESCE_MS = 150
 
 type DisplayEvent = Record<string, unknown> & {view?: string}
 
-function applyDisplayEvent(
-  set: (partial: Partial<DisplayStore>) => void,
-  get: () => DisplayStore,
-  event: DisplayEvent,
-) {
-  const currentView = get().view
-  const targetBucket = event.view === "dashboard" ? "dashboardEvent" : "mainEvent"
-
-  const updates: Partial<DisplayStore> = {
-    [targetBucket]: event,
-  }
-
-  // also update the current event if the view is the same:
-  if (event.view === currentView) {
-    updates.currentEvent = event
-  }
-
-  const visibleEvent = (updates.currentEvent ?? event) as DisplayEvent
-  const textLines = extractDisplayText(visibleEvent)
+function applyDisplayEvent(set: (partial: Partial<DisplayStore>) => void, event: DisplayEvent) {
+  const textLines = extractDisplayText(event)
   if (textLines.some((line) => line.trim() !== "")) {
     logE2EMetric("display_store_update", {
-      view: visibleEvent.view ?? currentView,
-      layout_type: (visibleEvent.layout as {layoutType?: string} | undefined)?.layoutType ?? "",
+      view: event.view ?? "main",
+      layout_type: (event.layout as {layoutType?: string} | undefined)?.layoutType ?? "",
       text_lines: textLines,
     })
   }
-
-  set(updates)
+  set({currentEvent: event})
 }
 
 export interface DisplayStore {
+  /** The frame currently on the glasses — the mirror renders this. */
   currentEvent: any
-  dashboardEvent: any
-  mainEvent: any
+  /** True while the dashboard covers the main content (see DashboardCoordinator). */
+  dashboardActive: boolean
   setDisplayEvent: (event: DisplayEvent | string) => void
-  view: string
-  setView: (view: string) => void
+  setDashboardActive: (active: boolean) => void
 }
 
 let pendingDisplayEvent: DisplayEvent | null = null
 let displayCoalesceTimer: ReturnType<typeof BgTimer.setTimeout> | null = null
 
 export const useDisplayStore = create<DisplayStore>()(
-  subscribeWithSelector((set, get) => ({
+  subscribeWithSelector((set) => ({
     currentEvent: {} as any,
-    dashboardEvent: {} as any,
-    mainEvent: {} as any,
-    view: "main",
+    dashboardActive: false,
     setDisplayEvent: (event: DisplayEvent | string) => {
       const parsed: DisplayEvent = typeof event === "string" ? JSON.parse(event) : event
       pendingDisplayEvent = parsed
@@ -85,24 +65,12 @@ export const useDisplayStore = create<DisplayStore>()(
         displayCoalesceTimer = null
         const next = pendingDisplayEvent
         pendingDisplayEvent = null
-        if (next) applyDisplayEvent(set, get, next)
+        if (next) applyDisplayEvent(set, next)
       }, DISPLAY_COALESCE_MS)
     },
-    setView: (view: string) => {
-      const currentView = get().view
-      if (view === currentView) {
-        return
-      }
-
-      // update the view and the currentEvent with the corresponding event:
-      let newEvent
-      if (view === "dashboard") {
-        newEvent = get().dashboardEvent
-      } else {
-        newEvent = get().mainEvent
-      }
-      logE2EMetric("display_view_changed", {view})
-      set({view, currentEvent: newEvent})
+    setDashboardActive: (active: boolean) => {
+      logE2EMetric("display_view_changed", {view: active ? "dashboard" : "main"})
+      set({dashboardActive: active})
     },
   })),
 )
@@ -116,6 +84,6 @@ export function flushDisplayCoalesceForTests(): void {
   if (pendingDisplayEvent) {
     const event = pendingDisplayEvent
     pendingDisplayEvent = null
-    applyDisplayEvent(useDisplayStore.setState, useDisplayStore.getState, event)
+    applyDisplayEvent(useDisplayStore.setState, event)
   }
 }

package/src/stores/glasses.ts

@@ -165,6 +165,8 @@ const initialState: GlassesStore = {
   controllerMacAddress: "",
   controllerBatteryLevel: -1,
   controllerSignalStrength: -1,
+  // iOS ANCS consent (G2 consumes notifications on-firmware):
+  ancsAuthorized: false,
 }
 
 export const useGlassesStore = create<GlassesState>()(

package/src/stores/settings.ts

@@ -140,6 +140,15 @@ export const SETTINGS: Record<string, Setting> = {
     saveOnServer: true,
     persist: true,
   },
+  // Tint the glasses display mirror text with the green chart color instead of
+  // the theme foreground. Toggled from Settings > Appearance.
+  mirror_green_text: {
+    key: "mirror_green_text",
+    defaultValue: () => false,
+    writable: true,
+    saveOnServer: true,
+    persist: true,
+  },
   debug_navigation_history: {
     key: "debug_navigation_history",
     defaultValue: () => false,
@@ -901,6 +910,47 @@ export const SETTINGS: Record<string, Setting> = {
     saveOnServer: true,
     persist: true,
   },
+  // iOS: apps observed posting notifications, reported by the glasses' ANCS
+  // client ({appId, displayName, lastSeen}[]). Backs the filter UI, since iOS
+  // has no installed-apps enumeration. Device-local by design.
+  ios_notification_seen_apps: {
+    key: "ios_notification_seen_apps",
+    defaultValue: () => [],
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
+  // G2 on-glass notification display behavior (NotificationControl):
+  g2_notifications_enabled: {
+    key: "g2_notifications_enabled",
+    defaultValue: () => true,
+    writable: true,
+    saveOnServer: true,
+    persist: true,
+  },
+  g2_notification_auto_display: {
+    key: "g2_notification_auto_display",
+    defaultValue: () => true,
+    writable: true,
+    saveOnServer: true,
+    persist: true,
+  },
+  // Popup duration in seconds; firmware accepts 0 (default), 5, 7, 10.
+  g2_notification_disp_time: {
+    key: "g2_notification_disp_time",
+    defaultValue: () => 5,
+    writable: true,
+    saveOnServer: true,
+    persist: true,
+  },
+  // Suppress popups while another on-glass feature (navigation, teleprompter) is active.
+  g2_notification_avoid_disturb: {
+    key: "g2_notification_avoid_disturb",
+    defaultValue: () => true,
+    writable: true,
+    saveOnServer: true,
+    persist: true,
+  },
   // Cached required version from server - used to enforce updates even when offline
   cached_required_version: {
     key: "cached_required_version",
@@ -942,8 +992,8 @@ export const BLUETOOTH_SETTING_KEYS: string[] = [
   SETTINGS.screen_disabled.key,
   SETTINGS.auth_email.key,
   SETTINGS.core_token.key,
-  // glasses settings:
-  SETTINGS.contextual_dashboard.key,
+  // glasses settings (contextual_dashboard is phone-side policy now — native
+  // no longer reads it):
   SETTINGS.head_up_angle.key,
   SETTINGS.brightness.key,
   SETTINGS.auto_brightness.key,
@@ -951,6 +1001,7 @@ export const BLUETOOTH_SETTING_KEYS: string[] = [
   SETTINGS.dashboard_depth.key,
   SETTINGS.menu_apps.key,
   SETTINGS.calendar_events.key,
+  // G2 native reads this to gate rendering while the ER firmware dashboard is open.
   SETTINGS.use_native_dashboard.key,
   SETTINGS.cfw_scene_renderer.key,
   SETTINGS.twelve_hour_time.key,

package/src/types/applet.ts

@@ -1,6 +1,6 @@
 import type {ReactNode} from "react"
 /**
- * App/Applet types for client interfaces
+ * App and miniapp types owned by @glassly/engine.
  */
 
 

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

@@ -85,6 +85,9 @@ export const evenRealitiesG2: Capabilities = {
   // WiFi capabilities - G2 does not support WiFi
   hasWifi: false,
 
+  // OTA capabilities - G2 firmware updates are not driven by the ASG OTA flow
+  hasOta: false,
+
   // Dashboard - G2 renders Even Realities' native dashboard in firmware, so
   // Glassly does not manage the dashboard or expose dashboard settings for it
   hasNativeDashboard: true,
@@ -93,6 +96,4 @@ export const evenRealitiesG2: Capabilities = {
   // 576×188 overview map); magnetometer streams only while it is active
   hasNativeNavigation: true,
 
-  // OTA capabilities - G2 firmware updates are not driven by the ASG OTA flow
-  hasOta: false,
 }

package/src/types/hardware.ts

@@ -189,6 +189,7 @@ export const HARDWARE_CAPABILITIES: Record<string, Capabilities> = {
   [mentraLive.modelName]: mentraLive,
   [simulatedGlasses.modelName]: simulatedGlasses,
   [vuzixZ100.modelName]: vuzixZ100,
+  [nimo.modelName]: nimo,
   [DeviceTypes.MACH1]: vuzixZ100, // Mach1 uses same Vuzix Ultralite hardware as Z100
   [nimo.modelName]: nimo,
   [DeviceTypes.AR99]: {

package/src/types/index.ts

@@ -25,9 +25,9 @@ export {
   evenRealitiesG1,
   evenRealitiesG2,
   mentraLive,
+  nimo,
   vuzixZ100,
   mentraDisplay,
-  nimo,
 } from "./hardware"
 
 // Applet types

package/src/utils/display/composer/ColumnComposer.ts

@@ -11,7 +11,7 @@
  * 2. Merges columns line-by-line with pixel-precise space padding
  * 3. Returns a single pre-composed string ready for native to chunk & send
  *
- * @see cloud/issues/026-mobile-display-processor for design docs
+ * @see notes/miniapp-display-api-redesign.md for the current display design
  */
 
 import type {DisplayProfile} from "../profiles/types"