@glassly/engine 0.1.0-dev.99 → 0.2.8-dev.445

package/src/stores/settings.ts

@@ -3,7 +3,6 @@ import {AsyncResult, result as Res, Result} from "typesafe-ts"
 import {create} from "zustand"
 import {subscribeWithSelector} from "zustand/middleware"
 
-import {normalizeDashboardWidgets} from "../services/CustomDashboardModel"
 import {storage} from "../utils/storage"
 import {getBluetoothSettingKeysForDevice} from "./bluetoothSettingKeys"
 import {useGlassesStore} from "./glasses"
@@ -49,6 +48,11 @@ export interface Setting {
   resetOnBuildEnvChange?: true
 }
 
+// The provider list the data-consent screen currently shows. Stored per
+// install so a later bump can be told apart from an older answer; the boot
+// router only shows the screen during first onboarding today.
+export const AI_DATA_CONSENT_VERSION = 1
+
 export const SETTINGS: Record<string, Setting> = {
   // feature flags / mantle settings:
   dev_mode: {key: "dev_mode", defaultValue: () => __DEV__, writable: true, saveOnServer: true, persist: true}, // deprecated
@@ -77,8 +81,12 @@ export const SETTINGS: Record<string, Setting> = {
     saveOnServer: true,
     persist: true,
   },
-  miniapp_dev_mode: {
-    key: "miniapp_dev_mode",
+  // Developer tools: shows the Miniapp Developer launcher and the dev-only
+  // bundled miniapps (see DEV_TOOLS_PACKAGES). Off by default so ordinary
+  // installs never see them. Replaced the legacy `miniapp_dev_mode` key,
+  // which only controlled the Miniapp Developer home tile.
+  dev_tools: {
+    key: "dev_tools",
     defaultValue: () => false,
     writable: true,
     saveOnServer: true,
@@ -132,10 +140,10 @@ export const SETTINGS: Record<string, Setting> = {
   },
   // Show the glasses display mirror on the home screen even when a real
   // (non-simulated) pair of glasses is paired. Toggled from the glasses card's
-  // long-press menu.
+  // long-press menu. Default on.
   home_mirror: {
     key: "home_mirror",
-    defaultValue: () => false,
+    defaultValue: () => true,
     writable: true,
     saveOnServer: true,
     persist: true,
@@ -223,6 +231,37 @@ export const SETTINGS: Record<string, Setting> = {
     saveOnServer: false,
     persist: true,
   },
+  // In-app disclosure of which third parties receive user data (App Store
+  // 5.1.2(i)). `_version` is the AI_DATA_CONSENT_VERSION the user last saw
+  // and `_agreed` is their answer. Declining turns disable_cloud on. The
+  // screen is part of first onboarding only. Device-local: consent is a
+  // property of this install, and logout's resetAllLocal() clears it so the
+  // next account is asked afresh.
+  ai_data_consent_version: {
+    key: "ai_data_consent_version",
+    defaultValue: () => 0,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
+  ai_data_consent_agreed: {
+    key: "ai_data_consent_agreed",
+    defaultValue: () => false,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
+  // The user chose "Continue without an account" on the login screen. Boot
+  // treats no-session + this flag as guest mode (cloud disabled, no token
+  // exchange). Signing in clears it. Device-local like disable_cloud; logout's
+  // resetAllLocal() drops it so the login screen offers Skip again.
+  login_skipped: {
+    key: "login_skipped",
+    defaultValue: () => false,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
   // Cloud V2 endpoint OVERRIDES. Empty = no override; cloudClient's resolveUrl
   // owns the full precedence (override -> env -> Metro-derived dev default).
   // The value may be an explicit URL or the METRO_AUTO sentinel ("my dev
@@ -428,6 +467,16 @@ export const SETTINGS: Record<string, Setting> = {
     persist: true,
     nativeAuthoritative: true,
   },
+  // Latched true the first time the identity projects as paired to real
+  // (non-simulated) glasses; never cleared, so forgetting the glasses keeps
+  // what it unlocked (the Store). Per-phone like the identity it derives from.
+  has_paired_glasses: {
+    key: "has_paired_glasses",
+    defaultValue: () => false,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
   default_controller: {
     key: "default_controller",
     defaultValue: () => "",
@@ -436,6 +485,16 @@ export const SETTINGS: Record<string, Setting> = {
     persist: true,
     nativeAuthoritative: true,
   },
+  // Display name of the keyboard the glasses remember (G2 Glassly CFW). The
+  // native bridge owns the address/bond; this only keeps the home card and
+  // settings row populated before the glasses connect, like default_controller.
+  keyboard_name: {
+    key: "keyboard_name",
+    defaultValue: () => "",
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
   pending_controller: {
     key: "pending_controller",
     defaultValue: () => "",
@@ -476,13 +535,6 @@ export const SETTINGS: Record<string, Setting> = {
     saveOnServer: true,
     persist: true,
   },
-  enable_phone_notifications: {
-    key: "enable_phone_notifications",
-    defaultValue: () => false,
-    writable: true,
-    saveOnServer: true,
-    persist: true,
-  },
   settings_access_count: {
     key: "settings_access_count",
     defaultValue: () => 0,
@@ -650,13 +702,6 @@ export const SETTINGS: Record<string, Setting> = {
     saveOnServer: true,
     persist: true,
   },
-  use_native_dashboard: {
-    key: "use_native_dashboard",
-    defaultValue: () => true,
-    writable: true,
-    saveOnServer: true,
-    persist: true,
-  },
   // Debug escape hatch: G2 scene rendering through the Glassly CFW
   // direct-framebuffer path (rasterized mode-3 frames into the carrier).
   // ON by default — the working production path on CFW glasses; OFF falls
@@ -671,8 +716,34 @@ export const SETTINGS: Record<string, Setting> = {
     saveOnServer: false,
     persist: true,
   },
+  // Debug: ask Glassly CFW glasses (revision 26+) for the 7.5 ms / latency-0
+  // fast BLE connection profile with slow mode suppressed, instead of the
+  // stock 15-30 ms link and its one-minute slow-mode timer. OFF by default:
+  // the fast link costs battery whenever the phone is merely connected, and
+  // the phone must agree to the interval. Synced to the Bluetooth SDK, which
+  // sends the control to both lenses and re-sends it on every CFW detection.
+  // Device-local debug knob, so not saved on the server.
+  cfw_fast_ble: {
+    key: "cfw_fast_ble",
+    defaultValue: () => false,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
+  // Maximum rate at which display updates leave the phone for the glasses.
+  // The Bluetooth SDK paces every scene frame and legacy layout to this,
+  // coalescing faster updates last-wins; clears bypass it. No effect on G2
+  // custom firmware, whose driver coalesces off the link itself. Device-local
+  // debug knob (2..20), so not saved on the server.
+  display_max_fps: {
+    key: "display_max_fps",
+    defaultValue: () => 8,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
   // Master switch for the Scene API dashboard on G2 custom firmware
-  // (CustomDashboardService.isEligible). Off leaves an eligible device on the
+  // (the dashboard's eligibility). Off leaves an eligible device on the
   // native head-up behavior. Device-local debug knob, so not saved on the
   // server.
   custom_dashboard_enabled: {
@@ -682,6 +753,37 @@ export const SETTINGS: Record<string, Setting> = {
     saveOnServer: false,
     persist: true,
   },
+  // Debug: time each dashboard open (head-up / double tap → glasses frame)
+  // and post the stage timeline as a phone notification. Persisted so a
+  // slow first open after an app restart is still caught. Device-local.
+  debug_dashboard_open_timing: {
+    key: "debug_dashboard_open_timing",
+    defaultValue: () => false,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
+  // Debug escape hatch: enter the G2's firmware-rendered navigation mode on
+  // custom firmware too. Off by default: CFW draws the navigation miniapp's
+  // own HUD through the scene canvas and reads session.compass directly, so
+  // native nav mode is reserved for stock firmware. Device-local debug knob,
+  // so not saved on the server.
+  cfw_native_navigation: {
+    key: "cfw_native_navigation",
+    defaultValue: () => false,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
+  // Debug: open miniapps from their last screenshot, fading straight into the
+  // app. Off shows the splash instead. Device-local, default on.
+  use_screenshot_transition: {
+    key: "use_screenshot_transition",
+    defaultValue: () => true,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
   // Gesture-dots debug indicator: flash a glyph on the glasses when a touch
   // gesture is received while the display is empty. Works on any
   // scene-capable device, not only CFW. Device-local debug knob, default off.
@@ -710,24 +812,33 @@ export const SETTINGS: Record<string, Setting> = {
     saveOnServer: false,
     persist: true,
   },
-  // Ordered [{id, enabled}] list — the widget composition of the dashboard.
-  custom_dashboard_widgets: {
-    key: "custom_dashboard_widgets",
-    defaultValue: () => normalizeDashboardWidgets(null),
+  // "solid" | "two_tone": the battery widgets' G and R.
+  custom_dashboard_battery_style: {
+    key: "custom_dashboard_battery_style",
+    defaultValue: () => "solid",
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
+  // {preset, slots: {slotId: widgetId}, scratchpad: [widgetId]} — the
+  // dashboard miniapp owns the shape and its default; null draws its default layout.
+  custom_dashboard_layout: {
+    key: "custom_dashboard_layout",
+    defaultValue: () => null,
     writable: true,
     saveOnServer: false,
     persist: true,
   },
   custom_dashboard_calendar_event_count: {
     key: "custom_dashboard_calendar_event_count",
-    defaultValue: () => 2,
+    defaultValue: () => 3,
     writable: true,
     saveOnServer: false,
     persist: true,
   },
   custom_dashboard_calendar_days_ahead: {
     key: "custom_dashboard_calendar_days_ahead",
-    defaultValue: () => 3,
+    defaultValue: () => 5,
     writable: true,
     saveOnServer: false,
     persist: true,
@@ -910,42 +1021,58 @@ 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",
+  // Apps the connected glasses reported posting notifications (bundle/package
+  // id + display name). Backs the filter UI where the phone cannot enumerate
+  // apps itself and the allowlist pushed to firmware that filters on-glass.
+  notification_seen_apps: {
+    key: "notification_seen_apps",
     defaultValue: () => [],
     writable: true,
     saveOnServer: false,
     persist: true,
   },
-  // G2 on-glass notification display behavior (NotificationControl):
-  g2_notifications_enabled: {
-    key: "g2_notifications_enabled",
+  // Notification display, any glasses: firmware that presents notifications
+  // itself receives these as a GlassesNotificationConfig; the engine's own
+  // viewer reads the same four. Master switch first.
+  notifications_enabled: {
+    key: "notifications_enabled",
     defaultValue: () => true,
     writable: true,
     saveOnServer: true,
     persist: true,
   },
-  g2_notification_auto_display: {
-    key: "g2_notification_auto_display",
+  // Show a popup when a notification arrives; off keeps history only.
+  notifications_popups: {
+    key: "notifications_popups",
     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",
+  // Popup duration in seconds; 0 lets the firmware or viewer pick its default.
+  notifications_popup_seconds: {
+    key: "notifications_popup_seconds",
     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",
+  // Hold popups while another glasses feature (navigation, a miniapp) is on screen.
+  notifications_hold_during_apps: {
+    key: "notifications_hold_during_apps",
+    defaultValue: () => true,
+    writable: true,
+    saveOnServer: true,
+    persist: true,
+  },
+  // Experimental, any glasses: hold notification popups while the phone is in
+  // use (unlocked, or the Glassly App foregrounded), so a notification isn't
+  // shown on the glasses and the phone screen at once. The dashboard reducer
+  // reads it with PhoneActivity when a notification posts; on iOS
+  // PhoneNotificationsSync also folds it into the stock G2 firmware's
+  // auto_display, which pops notifications up on its own.
+  notifications_ignore_while_active: {
+    key: "notifications_ignore_while_active",
     defaultValue: () => true,
     writable: true,
     saveOnServer: true,
@@ -1001,9 +1128,9 @@ 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.cfw_fast_ble.key,
+  SETTINGS.display_max_fps.key,
   SETTINGS.twelve_hour_time.key,
   SETTINGS.metric_system.key,
   // button:
@@ -1070,13 +1197,10 @@ export interface SettingsState {
 }
 
 const getDefaultSettings = () =>
-  Object.keys(SETTINGS).reduce(
-    (acc, key) => {
-      acc[key] = SETTINGS[key].defaultValue()
-      return acc
-    },
-    {} as Record<string, any>,
-  )
+  Object.keys(SETTINGS).reduce((acc, key) => {
+    acc[key] = SETTINGS[key].defaultValue()
+    return acc
+  }, {} as Record<string, any>)
 
 // Single-flight for loadAllSettings: the host fires it at module load and
 // engine.start()'s device-store hydration awaits it — without the memo the

package/src/types/applet.ts

@@ -3,7 +3,6 @@ import type {ReactNode} from "react"
  * App and miniapp types owned by @glassly/engine.
  */
 
-
 import {HardwareRequirement} from "./hardware"
 
 import type {CompatibilityResult} from "../utils/hardware/hardware"
@@ -24,6 +23,7 @@ export type AppPermissionType =
   | "LOCATION"
   | "BACKGROUND_LOCATION"
   | "READ_NOTIFICATIONS"
+  | "DISPLAY_MIRROR"
   | "POST_NOTIFICATIONS"
   | "API_KEYS"
   | "MEMORY"
@@ -107,12 +107,25 @@ export interface ClientApp extends AppletInterface {
   loading: boolean
   local: boolean
   hidden: boolean
+  /**
+   * Persistent miniapp: the host starts it at launch and it only stops from
+   * the app switcher's persistent pill; its card cannot be swiped away and
+   * the capsule close minimizes it. Manifest `persistent` gives the default;
+   * the wearer's choice persists beside the hidden flag.
+   */
+  persistent?: boolean
   onStart?: () => void
   onStop?: () => void
   screenshot?: string
   runtimePermissions?: string[]
   declaredPermissions?: string[]
   version?: string
+  /** Manifest `description`: the paragraph the store and the info page show. */
+  description?: string
+  /** Manifest `tagline`: one line under the name. */
+  tagline?: string
+  /** Manifest `tags`: lowercase store tag slugs. */
+  tags?: string[]
   needsPcm?: boolean
   needsTranscript?: boolean
   devUrl?: string

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

@@ -88,6 +88,9 @@ export const evenRealitiesG2: Capabilities = {
   // OTA capabilities - G2 firmware updates are not driven by the ASG OTA flow
   hasOta: false,
 
+  // Glassly CFW is bundled for the G2 and flashed over BLE from the app
+  hasCustomFirmware: true,
+
   // Dashboard - G2 renders Even Realities' native dashboard in firmware, so
   // Glassly does not manage the dashboard or expose dashboard settings for it
   hasNativeDashboard: true,
@@ -96,4 +99,7 @@ export const evenRealitiesG2: Capabilities = {
   // 576×188 overview map); magnetometer streams only while it is active
   hasNativeNavigation: true,
 
+  // Firmware notification centre: popups + history, on-glass app filter.
+  hasNativeNotifications: true,
+  nativeNotificationPopupSeconds: [0, 5, 7, 10],
 }

package/src/types/capabilities/simulated-glasses.ts

@@ -3,7 +3,7 @@
  *
  * Capability profile for the Simulated Glasses model.
  * Defines the hardware and software features available on this device.
- * This profile matches the Vuzix Z100 capabilities for testing purposes.
+ * The display previews the G2 Glassly CFW scene API, including SVG and rotation.
  */
 
 import type {Capabilities} from "../hardware"
@@ -38,10 +38,14 @@ export const simulatedGlasses: Capabilities = {
     width: 576,
     height: 288,
     canPosition: true,
-    maxTextElements: 6,
-    maxImageElements: 4,
-    shapes: ["rect"],
+    maxTextElements: 120,
+    maxImageElements: 120,
+    shapes: ["rect", "circle", "arc", "pie", "line", "triangle", "quad", "bezier", "svg"],
+    animation: true,
+    rotation: true,
+    depth: true,
     // The mirror renders full 8-bit grayscale; 16 matches the G2's 4-bit
+
     // panel so simulated output previews what real hardware can show.
     intensityLevels: 16,
     partialUpdate: true,

package/src/types/hardware.ts

@@ -56,11 +56,31 @@ export interface DisplayCapabilities {
   maxImageElements?: number
   /** Per-image dimension cap (box-level), when the firmware has one. */
   maxImagePx?: {width: number; height: number}
-  shapes?: "rect"[]
+  shapes?: DisplayShape[]
+  /** True ⇒ the device animates element transitions itself. */
+  animation?: boolean
+  /** Geometric and SVG rotations, including duration-based transitions. */
+  rotation?: boolean
+  /** Per-element stereo `depth` (a lens disparity) is honored; otherwise elements draw flat. */
+  depth?: boolean
   intensityLevels?: number
+
   partialUpdate?: boolean
+  /**
+   * The views a miniapp may draw right now: "main" for every app, "dashboard"
+   * (the overlay slot) only for the designated system dashboard app while the
+   * glasses are eligible. Per app; filled in by the miniapp runtime.
+   */
+  views?: DisplayView[]
 }
 
+export type DisplayView = "main" | "dashboard"
+
+export type DisplayShape = "rect" | "circle" | "arc" | "pie" | "line" | "triangle" | "quad" | "bezier" | "svg"
+
+/** Every vector shape the Glassly CFW rasterizes on the glasses. */
+export const ALL_DISPLAY_SHAPES: DisplayShape[] = ["rect", "circle", "arc", "pie", "line", "triangle", "quad", "bezier"]
+
 /**
  * Microphone capabilities
  */
@@ -164,6 +184,10 @@ export interface Capabilities {
   // OTA capability
   hasOta?: boolean
 
+  // True when the app ships a flashable Glassly custom firmware for this
+  // model, so pairing can offer to install it and Settings exposes the flasher
+  hasCustomFirmware?: boolean
+
   // Native dashboard capability
   // True when the device renders its own dashboard in firmware (e.g. Even
   // Realities' built-in dashboard on G2). Glassly does not manage or expose
@@ -175,6 +199,15 @@ export interface Capabilities {
   // (G2 nav mode: instruction card + map slots + magnetometer compass); nav
   // apps feed it structured fields and map bitmaps instead of scene elements
   hasNativeNavigation?: boolean
+
+  // True when the firmware presents phone notifications itself (popup +
+  // history) and takes a GlassesNotificationConfig. How it gets the content
+  // (reading the phone's stream, or an upload from the phone) is the driver's
+  // business; the engine only decides who presents.
+  hasNativeNotifications?: boolean
+  // Popup durations the firmware accepts, in seconds (0 = firmware default).
+  // Drivers snap other values; the settings UI offers exactly these.
+  nativeNotificationPopupSeconds?: number[]
 }
 
 /**

package/src/types/index.ts

@@ -17,6 +17,7 @@ export type {
   PowerCapabilities,
   Capabilities,
 } from "./hardware"
+export {ALL_DISPLAY_SHAPES} from "./hardware"
 
 export {
   HARDWARE_CAPABILITIES,

package/src/utils/debouncedPatch.ts

@@ -1,22 +1,26 @@
+import {BgTimer} from "./timers"
+
 /**
  * Merge partial patches and flush once after `delayMs` of quiet time.
- * Uses global setTimeout so Jest fake timers can advance debounced writes.
+ * Runs on BgTimer so a debounced write still lands while the app is
+ * backgrounded; off-Android (and under Jest) BgTimer falls through to the
+ * global timer, so fake timers can still advance it.
  */
 export function createDebouncedPatchFlusher<T extends Record<string, unknown>>(
   flush: (patch: T) => void,
   delayMs: number,
 ) {
   let pending = {} as T
-  let timer: ReturnType<typeof setTimeout> | null = null
+  let timer: number | null = null
 
   const schedule = (callback: () => void) => {
-    timer = setTimeout(callback, delayMs) as ReturnType<typeof setTimeout>
+    timer = BgTimer.setTimeout(callback, delayMs)
   }
 
   return (patch: Partial<T>) => {
     pending = {...pending, ...patch}
     if (timer != null) {
-      clearTimeout(timer)
+      BgTimer.clearTimeout(timer)
     }
     schedule(() => {
       timer = null

package/src/utils/devMiniappLaunch.ts

@@ -22,6 +22,8 @@
 import {configuredDevHost} from "./configuredDevHost"
 import {storage} from "./storage/storage"
 
+import {BgTimer} from "./timers"
+
 const REACHABILITY_TIMEOUT_MS = 1500
 
 // A single dropped DNS lookup or momentary Wi-Fi blip (AP roam, DHCP renewal,
@@ -53,13 +55,13 @@ export type DecideDevLaunchOptions = {
 }
 
 function delay(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms))
+  return new Promise((resolve) => BgTimer.setTimeout(resolve, ms))
 }
 
 /** Single GET <devUrl>/miniapp.json attempt with a hard timeout. */
 async function fetchManifestOnce(devUrl: string): Promise<DevManifest | null> {
   const controller = new AbortController()
-  const timer = setTimeout(() => controller.abort(), REACHABILITY_TIMEOUT_MS)
+  const timer = BgTimer.setTimeout(() => controller.abort(), REACHABILITY_TIMEOUT_MS)
   try {
     const res = await fetch(`${devUrl.replace(/\/$/, "")}/miniapp.json`, {
       method: "GET",
@@ -68,7 +70,7 @@ async function fetchManifestOnce(devUrl: string): Promise<DevManifest | null> {
     if (!res.ok) return null
     return (await res.json()) as DevManifest
   } finally {
-    clearTimeout(timer)
+    BgTimer.clearTimeout(timer)
   }
 }