@glassly/engine 0.1.0-dev.99 → 0.2.9-beta.448

package/src/services/debug/dashboardOpenTimeline.ts

@@ -0,0 +1,237 @@
+/**
+ * Stage timeline of one dashboard open, for the dashboard open timing debug
+ * setting. The clock starts when the opening gesture reaches the phone (or
+ * when native received it, if the event carries that time); every stage is
+ * stamped as ms after that. No I/O: DashboardOpenTrace.ts feeds it.
+ */
+
+export type DashboardOpenTrigger = "head-up" | "double-tap"
+
+/** In order. `js` exists only when the gesture carried a native receipt time; `settled` needs CFW rev 27+. */
+export const DASHBOARD_OPEN_STAGES = ["js", "showView", "slot", "frame", "presented", "settled"] as const
+export type DashboardOpenStage = (typeof DASHBOARD_OPEN_STAGES)[number]
+
+/** The stages every open must pass; the first one missing is where it stalled. */
+const REQUIRED_STAGES: readonly DashboardOpenStage[] = ["showView", "slot", "frame", "presented"]
+
+const STAGE_LABELS: Record<DashboardOpenStage, string> = {
+  js: "js",
+  showView: "showView",
+  slot: "slot",
+  frame: "frame",
+  presented: "shown",
+  settled: "settled",
+}
+
+export interface DashboardOpenTrace {
+  trigger: DashboardOpenTrigger
+  /** Further triggers of the same kind before the dashboard asked for the view. */
+  repeats: number
+  stages: Partial<Record<DashboardOpenStage, number>>
+  /** The first required stage that never arrived; absent once the glasses presented the frame. */
+  stalledAt?: DashboardOpenStage
+  /** What the glasses said when they reported the frame not presented. */
+  reason?: string
+  /** Since the overlay slot was last granted; null when it hasn't been this session. */
+  sinceLastOpenMs: number | null
+  /** How long the requesting overlay app had been connected at the gesture; negative when it connected after. */
+  appUpMs: number | null
+  /** How long the glasses had been connected at the gesture. */
+  glassesUpMs: number | null
+}
+
+export interface DashboardOpenTimelineDeps {
+  now(): number
+  setTimeout: (callback: () => void, ms: number) => number
+  clearTimeout: (handle: number) => void
+  /** A finished open. A gesture the dashboard never answered with showView is dropped silently. */
+  onFinished(trace: DashboardOpenTrace): void
+}
+
+/** A gesture not answered with showView by then did not open the dashboard; a later stage missing by then stalled. */
+export const OPEN_WINDOW_MS = 15_000
+/** How long to wait for the settle report once the frame was presented. */
+export const SETTLE_GRACE_MS = 2_000
+/** A native receipt time further back than this is on some other clock. */
+const MAX_NATIVE_LAG_MS = 60_000
+
+interface ActiveOpen {
+  trace: DashboardOpenTrace
+  startedAt: number
+  frameSeq: number | null
+  timer: number
+}
+
+export class DashboardOpenTimeline {
+  private active: ActiveOpen | null = null
+
+  constructor(private readonly deps: DashboardOpenTimelineDeps) {}
+
+  get tracing(): boolean {
+    return this.active !== null
+  }
+
+  /** The seq of the open's first overlay frame, once sent. */
+  get frameSeq(): number | null {
+    return this.active?.frameSeq ?? null
+  }
+
+  /**
+   * An opening gesture reached the phone. While an earlier one still waits
+   * for showView, the same gesture again only counts as a repeat (the clock
+   * keeps the first); a different gesture restarts the clock. Ignored once
+   * the open is under way.
+   */
+  trigger(
+    trigger: DashboardOpenTrigger,
+    context: {sinceLastOpenMs: number | null; glassesUpMs: number | null},
+    nativeAt?: number,
+  ): void {
+    const active = this.active
+    if (active) {
+      if (active.trace.stages.showView !== undefined) return
+      if (active.trace.trigger === trigger) {
+        active.trace.repeats++
+        return
+      }
+      this.cancel()
+    }
+    const now = this.deps.now()
+    const lag = nativeAt === undefined ? -1 : now - nativeAt
+    const native = nativeAt !== undefined && lag >= 0 && lag <= MAX_NATIVE_LAG_MS
+    this.active = {
+      trace: {trigger, repeats: 0, stages: native ? {js: lag} : {}, appUpMs: null, ...context},
+      startedAt: native ? nativeAt : now,
+      frameSeq: null,
+      timer: this.deps.setTimeout(() => this.expire(), OPEN_WINDOW_MS),
+    }
+  }
+
+  /** An overlay app asked for the dashboard view; `appConnectedAt` is when it connected, if known. */
+  showViewRequested(appConnectedAt: number | null): void {
+    const active = this.active
+    if (!active || active.trace.stages.showView !== undefined) return
+    active.trace.appUpMs = appConnectedAt === null ? null : active.startedAt - appConnectedAt
+    this.stamp("showView")
+  }
+
+  slotGranted(): void {
+    if (this.active?.trace.stages.showView !== undefined) this.stamp("slot")
+  }
+
+  /** The first overlay frame after the grant left for the glasses. */
+  frameSent(seq: number): void {
+    const active = this.active
+    if (!active || active.trace.stages.slot === undefined || active.frameSeq !== null) return
+    active.frameSeq = seq
+    this.stamp("frame")
+  }
+
+  /**
+   * The glasses reported a frame. A later frame presented folds ours in; ours
+   * not presented is noted, and the window still waits for a later one.
+   */
+  framePresented(seq: number, presented: boolean, reason?: string): void {
+    const active = this.active
+    if (!active || active.frameSeq === null || seq < active.frameSeq) return
+    if (active.trace.stages.presented !== undefined) return
+    if (!presented) {
+      if (seq === active.frameSeq) active.trace.reason = reason ?? "not presented"
+      return
+    }
+    this.stamp("presented")
+    this.deps.clearTimeout(active.timer)
+    active.timer = this.deps.setTimeout(() => this.finish(), SETTLE_GRACE_MS)
+  }
+
+  /** The glasses finished the animations of frame `seq` (and every frame before it). */
+  frameSettled(seq: number): void {
+    const active = this.active
+    if (!active || active.frameSeq === null || seq < active.frameSeq) return
+    this.stamp("presented")
+    this.stamp("settled")
+    this.finish()
+  }
+
+  cancel(): void {
+    if (!this.active) return
+    this.deps.clearTimeout(this.active.timer)
+    this.active = null
+  }
+
+  private stamp(stage: DashboardOpenStage): void {
+    const active = this.active
+    if (!active || active.trace.stages[stage] !== undefined) return
+    active.trace.stages[stage] = this.deps.now() - active.startedAt
+  }
+
+  private expire(): void {
+    const active = this.active
+    if (!active) return
+    if (active.trace.stages.showView === undefined) {
+      this.active = null
+      return
+    }
+    this.finish()
+  }
+
+  private finish(): void {
+    const active = this.active
+    if (!active) return
+    this.deps.clearTimeout(active.timer)
+    this.active = null
+    const {trace} = active
+    const stalledAt = REQUIRED_STAGES.find((stage) => trace.stages[stage] === undefined)
+    if (stalledAt) trace.stalledAt = stalledAt
+    else delete trace.reason
+    this.deps.onFinished(trace)
+  }
+}
+
+/** Notification title and body: the headline, the stage timeline, then the context that separates cold opens from warm ones. */
+export function formatDashboardOpenTrace(trace: DashboardOpenTrace): {title: string; body: string} {
+  const shown = trace.stages.presented
+  const title =
+    trace.stalledAt === undefined && shown !== undefined
+      ? `Dashboard opened in ${formatMs(shown)} ms`
+      : `Dashboard open stalled before ${STAGE_LABELS[trace.stalledAt ?? "presented"]}`
+
+  const gesture = trace.repeats > 0 ? `${trace.trigger} ×${trace.repeats + 1}` : trace.trigger
+  const timeline = [`${gesture} 0`]
+  for (const stage of DASHBOARD_OPEN_STAGES) {
+    const at = trace.stages[stage]
+    if (at !== undefined) timeline.push(`${STAGE_LABELS[stage]} +${formatMs(at)}`)
+  }
+
+  const context = [
+    trace.sinceLastOpenMs === null
+      ? "first open this session"
+      : `last open ${formatDuration(trace.sinceLastOpenMs)} ago`,
+  ]
+  if (trace.appUpMs !== null) {
+    context.push(
+      trace.appUpMs < 0
+        ? `dashboard app connected ${formatDuration(-trace.appUpMs)} after the gesture`
+        : `dashboard app up ${formatDuration(trace.appUpMs)}`,
+    )
+  }
+  if (trace.glassesUpMs !== null) context.push(`glasses up ${formatDuration(trace.glassesUpMs)}`)
+
+  const lines = [timeline.join(" · "), context.join(" · ")]
+  if (trace.reason) lines.push(`glasses: ${trace.reason}`)
+  return {title, body: lines.join("\n")}
+}
+
+/** 5210 → "5,210". Hand-rolled so it doesn't depend on the runtime's Intl. */
+function formatMs(ms: number): string {
+  return String(Math.round(ms)).replace(/\B(?=(\d{3})+(?!\d))/g, ",")
+}
+
+function formatDuration(ms: number): string {
+  if (ms < 1_000) return `${Math.round(ms)} ms`
+  if (ms < 60_000) return `${Math.round(ms / 1_000)} s`
+  if (ms < 3_600_000) return `${Math.round(ms / 60_000)} min`
+  const hours = Math.floor(ms / 3_600_000)
+  const minutes = Math.round((ms % 3_600_000) / 60_000)
+  return minutes > 0 ? `${hours} h ${minutes} min` : `${hours} h`
+}

package/src/services/effectiveCapabilities.ts

@@ -6,14 +6,18 @@
  * Native publishes the canvas into the glasses status (0 = none). Because
  * that path is phone-side rasterization, the stock firmware's container
  * pools (6 text / 4 image) don't bound a CFW frame either — element caps are
- * lifted alongside the canvas, bounded only to keep frames sane.
+ * lifted alongside the canvas, bounded only to keep frames sane. Firmware
+ * that draws vector shapes keeps 128 scene slots, so shape-heavy frames
+ * (a game board, a chart) get a larger shared text/shape budget.
  */
 import {useGlassesStore} from "../stores/glasses"
-import {DeviceTypes, getModelCapabilities, type Capabilities} from "../types"
-import {isGlasslyCfwFirmwareVersion} from "./CustomDashboardModel"
+import {SETTINGS, useSettingsStore} from "../stores/settings"
+import {ALL_DISPLAY_SHAPES, DeviceTypes, getModelCapabilities, type Capabilities} from "../types"
+import {resolveNativeNavigation} from "./nativeNavigationGate"
 
 const CFW_MAX_TEXT_ELEMENTS = 24
 const CFW_MAX_IMAGE_ELEMENTS = 16
+const CFW_VECTOR_MAX_ELEMENTS = 120
 
 export interface SceneCanvasSize {
   width: number
@@ -26,22 +30,37 @@ export function runtimeSceneCanvas(): SceneCanvasSize | null {
   return {width: sceneCanvasWidth, height: sceneCanvasHeight}
 }
 
+function forceNativeNavigationOnCfw(): boolean {
+  return useSettingsStore.getState().getSetting(SETTINGS.cfw_native_navigation.key) === true
+}
+
 export function getEffectiveCapabilities(model: DeviceTypes): Capabilities {
   const base = getModelCapabilities(model)
-  const canvas = runtimeSceneCanvas()
-  // 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
+  // Only G2 CFW publishes a canvas; never let a stale value reshape another model.
+  const canvas = model === DeviceTypes.G2 ? runtimeSceneCanvas() : null
+  if (!base.display || !canvas) return base
+  // Glassly CFW supports the complete vector contract, including SVG and rotation.
+  // Upstream g2flash publishes a raster canvas with sceneVector=false.
+  const vector = useGlassesStore.getState().sceneVector === true
   return {
     ...base,
+    hasNativeNavigation: resolveNativeNavigation(base.hasNativeNavigation, true, forceNativeNavigationOnCfw()),
     display: {
       ...base.display,
-      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),
+      width: canvas.width,
+      height: canvas.height,
+      maxTextElements: Math.max(
+        base.display.maxTextElements ?? 0,
+        vector ? CFW_VECTOR_MAX_ELEMENTS : CFW_MAX_TEXT_ELEMENTS,
+      ),
+      // Vector firmware draws an image as one cached slot, the same as a shape.
+      maxImageElements: Math.max(
+        base.display.maxImageElements ?? 0,
+        vector ? CFW_VECTOR_MAX_ELEMENTS : CFW_MAX_IMAGE_ELEMENTS,
+      ),
+      ...(vector
+        ? {shapes: [...ALL_DISPLAY_SHAPES, "svg" as const], animation: true, rotation: true, depth: true}
+        : {}),
     },
   }
 }

package/src/services/gestureClaims.ts

@@ -1,28 +1,77 @@
 /**
- * Gesture-claim arbitration (CLAIM_GESTURES), split out of
- * LocalMiniappRuntime so it is unit-testable — the runtime module itself
- * pulls a native import surface bun can't parse.
+ * Gesture registrations in claim order. Exactly one miniapp receives each
+ * gesture: the last registration containing it wins. Named scopes let an
+ * app temporarily claim gestures without overwriting its persistent shortcuts.
+ * Releasing a scope restores the preceding registration; stopping removes all
+ * of the app's scopes. This module has no native dependencies.
  */
+interface GestureRegistration {
+  packageName: string
+  scope: string
+  gestures: ReadonlySet<string>
+}
 
-/**
- * True iff the miniapp in front of the user has claimed `gesture`.
- *
- * "In front" spans both screens. Most claiming apps are glasses-side: the
- * terminal runs as a background miniapp with the phone pocketed, so gating on
- * the phone's Compositor foreground alone left its double_tap claim inert and
- * the system dashboard kept opening mid-session. Glasses ownership is the
- * primary signal; the phone foreground is still honored for apps driven from
- * the handset. A claimer that owns neither screen is background and never
- * hijacks a system gesture.
- */
-export function claimsGesture(
-  claims: ReadonlyMap<string, ReadonlySet<string>>,
-  gesture: string,
-  glassesOwner: string | null,
-  phoneForeground: string | null,
-): boolean {
-  for (const pkg of [glassesOwner, phoneForeground]) {
-    if (pkg && claims.get(pkg)?.has(gesture) === true) return true
+export interface GestureClaimState {
+  registrations: readonly GestureRegistration[]
+}
+
+export interface GestureClaimChange {
+  packageName: string
+  gesture: string
+  held: boolean
+}
+
+export function emptyGestureClaims(): GestureClaimState {
+  return {registrations: []}
+}
+
+/** The single receiver of this gesture, regardless of how many scopes registered it. */
+export function gestureClaimant(state: GestureClaimState, gesture: string): string | null {
+  for (let i = state.registrations.length - 1; i >= 0; i--) {
+    const registration = state.registrations[i]
+    if (registration.gestures.has(gesture)) return registration.packageName
   }
-  return false
+  return null
+}
+
+/** Registration and current ownership differ when another app claimed more recently. */
+export function hasGestureClaim(state: GestureClaimState, packageName: string, gesture: string): boolean {
+  return state.registrations.some((entry) => entry.packageName === packageName && entry.gestures.has(gesture))
+}
+
+function changesBetween(before: GestureClaimState, after: GestureClaimState): GestureClaimChange[] {
+  const gestures = new Set([...before.registrations, ...after.registrations].flatMap((entry) => [...entry.gestures]))
+  const changes: GestureClaimChange[] = []
+  for (const gesture of gestures) {
+    const was = gestureClaimant(before, gesture)
+    const now = gestureClaimant(after, gesture)
+    if (was === now) continue
+    if (was !== null) changes.push({packageName: was, gesture, held: false})
+    if (now !== null) changes.push({packageName: now, gesture, held: true})
+  }
+  return changes
+}
+
+/** Replace one scope's set. A nonempty registration always becomes the newest claim. */
+export function setGestureClaims(
+  state: GestureClaimState,
+  packageName: string,
+  gestures: readonly string[],
+  scope = "default",
+): {state: GestureClaimState; changes: GestureClaimChange[]} {
+  const registrations = state.registrations.filter(
+    (entry) => entry.packageName !== packageName || entry.scope !== scope,
+  )
+  if (gestures.length) registrations.push({packageName, scope, gestures: new Set(gestures)})
+  const after = {registrations}
+  return {state: after, changes: changesBetween(state, after)}
+}
+
+/** Stop removes every scope without notifying the stopped app. */
+export function dropGestureClaims(
+  state: GestureClaimState,
+  packageName: string,
+): {state: GestureClaimState; changes: GestureClaimChange[]} {
+  const after = {registrations: state.registrations.filter((entry) => entry.packageName !== packageName)}
+  return {state: after, changes: changesBetween(state, after).filter((change) => change.packageName !== packageName)}
 }

package/src/services/manifestFields.ts

@@ -0,0 +1,23 @@
+/**
+ * Pure normalizers for the free-text manifest fields (miniapp.json) that the
+ * installed-app projection carries onto ClientApp.
+ */
+
+/** A non-empty manifest string, trimmed; anything else is absent. */
+export function normalizeManifestText(raw: unknown): string | undefined {
+  if (typeof raw !== "string") return undefined
+  const trimmed = raw.trim()
+  return trimmed.length > 0 ? trimmed : undefined
+}
+
+/** Manifest tags: lowercase slugs, de-duplicated, non-strings dropped. */
+export function normalizeManifestTags(raw: unknown): string[] {
+  if (!Array.isArray(raw)) return []
+  const out: string[] = []
+  for (const tag of raw) {
+    if (typeof tag !== "string") continue
+    const slug = tag.trim().toLowerCase()
+    if (slug.length > 0 && !out.includes(slug)) out.push(slug)
+  }
+  return out
+}

package/src/services/memoryStoreInstance.ts

@@ -9,42 +9,10 @@ import {AppState} from "react-native"
 
 import {storage as mmkvStorage} from "../utils/storage/storage"
 import {cloudClientService} from "./CloudClientService"
-import {EXTENDED_RETENTION, MemoryStore, STANDARD_RETENTION} from "./MemoryStore"
-
-/**
- * Persisted "Plus/Pro memory retention" flag. Cached in MMKV so a paying user
- * who relaunches offline keeps their full read window; only a DEFINITIVE
- * subscription answer may change it (the RevenueCatSetup effect passes
- * nothing on unknown/null customer info).
- */
-const RETENTION_EXTENDED_KEY = "memory_retention_extended"
-
-let retentionExtended = ((): boolean => {
-  const result = mmkvStorage.load<boolean>(RETENTION_EXTENDED_KEY)
-  return result.is_ok() && result.value === true
-})()
-
-/** Whether the extended (Plus/Pro) retention window is active right now. */
-export function isMemoryRetentionExtended(): boolean {
-  return retentionExtended
-}
-
-/**
- * Flip the visible retention window. Called by the host app when the
- * subscription state resolves or changes. Downgrading freezes reads to the
- * standard window but deletes nothing — the older timeline stays stored and
- * reappears on re-upgrade (MemoryStore prunes at the extended bound for
- * every tier).
- */
-export function setMemoryRetentionExtended(extended: boolean): void {
-  if (retentionExtended === extended) return
-  retentionExtended = extended
-  mmkvStorage.save(RETENTION_EXTENDED_KEY, extended)
-}
+import {MemoryStore} from "./MemoryStore"
 
 export const memoryStore = new MemoryStore({
-  getUserId: () => cloudClientService.resolveGlasslyUserId(),
-  getRetention: () => (retentionExtended ? EXTENDED_RETENTION : STANDARD_RETENTION),
+  getUserId: () => cloudClientService.resolveUserId(),
   backend: {
     get(key: string): unknown | null {
       const result = mmkvStorage.load<unknown>(key)

package/src/services/mirrorSnapshot.ts

@@ -0,0 +1,116 @@
+import type {MirrorContent, MirrorElement, MirrorSnapshot} from "@glassly/miniapp"
+
+export interface MirrorSource {
+  event: unknown
+  canvas: {width: number; height: number} | null
+  connected: boolean
+  model: string | null
+  battery: number
+  measureChar: (char: string) => number
+  now: number
+}
+
+const object = (v: unknown): Record<string, unknown> =>
+  v !== null && typeof v === "object" && !Array.isArray(v) ? (v as Record<string, unknown>) : {}
+const number = (v: unknown, fallback = 0): number => (typeof v === "number" && Number.isFinite(v) ? v : fallback)
+const string = (v: unknown): string => (typeof v === "string" ? v : "")
+
+/** Copy and normalize host layouts at the public boundary; never leak store references. */
+export function buildMirrorSnapshot(source: MirrorSource, revision: number): MirrorSnapshot {
+  const {now, connected, model, measureChar} = source
+  const event = object(source.event)
+  const layout = object(event.layout)
+  let canvas = source.canvas
+  let content: MirrorContent = {kind: "empty"}
+  const widths: Record<string, number> = {}
+  const date = new Date(now)
+  const pad = (n: number) => String(n).padStart(2, "0")
+  const parseText = (value: unknown) => {
+    const text = string(value)
+      .replace(/\$DATE\$/g, `${pad(date.getMonth() + 1)}/${pad(date.getDate())}`)
+      .replace(/\$TIME12\$/g, `${pad(date.getHours() % 12 || 12)}:${pad(date.getMinutes())}`)
+      .replace(/\$TIME24\$/g, `${pad(date.getHours())}:${pad(date.getMinutes())}`)
+      .replace(/\$GBATT\$/g, source.battery >= 0 ? `${source.battery}%` : "")
+      .replace(/\$CONNECTION_STATUS\$/g, connected ? "Connected" : "Disconnected")
+    for (const char of text) widths[char] = measureChar(char)
+    return text
+  }
+  const textElement = (id: string, text: unknown, x: number, y: number, w: number, h: number): MirrorElement => ({
+    id,
+    type: "text",
+    text: parseText(text),
+    box: {x, y, w, h},
+    change: "created",
+  })
+  if (!canvas) content = {kind: "unavailable", reason: "no-display"}
+  else if (layout.layoutType === "unavailable")
+    content = {kind: "unavailable", reason: string(layout.reason) || "unknown"}
+  else if (layout.layoutType === "scene") {
+    canvas = {width: number(layout.width, canvas.width), height: number(layout.height, canvas.height)}
+    const elements: MirrorElement[] = []
+    for (const raw of Array.isArray(layout.elements) ? layout.elements : []) {
+      const el = object(raw)
+      if (typeof el.id !== "string" || typeof el.type !== "string" || !el.box) continue
+      // SceneRenderer produces validated FrameElements. Serialization strips
+      // references; private native compiler/hash fields stay inside the host.
+      const {path: _path, contentHash: _hash, ...copy} = JSON.parse(JSON.stringify(el))
+      if (copy.type === "text") copy.text = parseText(copy.text)
+      elements.push(copy as MirrorElement)
+    }
+    content = elements.length ? {kind: "scene", elements, epoch: number(layout.sceneEpoch)} : {kind: "empty"}
+  } else if (layout.layoutType === "bitmap_view") {
+    content = {kind: "bitmap", data: string(layout.data)}
+  } else if (layout.layoutType && layout.layoutType !== "clear_view") {
+    const {width: w, height: h} = canvas
+    let elements: MirrorElement[] | null = null
+    switch (layout.layoutType) {
+      case "text_wall":
+      case "text_line":
+        elements = [textElement("text", layout.text, 0, 0, w, h)]
+        break
+      case "text_rows":
+        elements = [textElement("text", Array.isArray(layout.text) ? layout.text.join("\n") : "", 0, 0, w, h)]
+        break
+      case "reference_card":
+        elements = [
+          textElement("text", [string(layout.title), string(layout.text)].filter(Boolean).join("\n"), 0, 0, w, h),
+        ]
+        break
+      case "double_text_wall":
+        elements = [
+          textElement("top", layout.topText, 0, 0, w, h / 2),
+          textElement("bottom", layout.bottomText, 0, h / 2, w, h / 2),
+        ]
+        break
+      case "positioned_text":
+        elements = [
+          {
+            ...textElement(
+              "text",
+              layout.text,
+              number(layout.x),
+              number(layout.y),
+              number(layout.width, w),
+              number(layout.height, h),
+            ),
+            style: {border: number(layout.borderWidth), radius: number(layout.borderRadius)},
+          },
+        ]
+        break
+    }
+    content = elements
+      ? {kind: "scene", elements, epoch: 0}
+      : {kind: "unavailable", reason: `unsupported-layout:${string(layout.layoutType)}`}
+  }
+  return {
+    revision,
+    updatedAt: now,
+    connected,
+    model,
+    canvas,
+    view: event.view === "dashboard" ? "dashboard" : canvas ? "main" : null,
+    appId: typeof layout.appId === "string" ? layout.appId : null,
+    content,
+    glyphWidths: widths,
+  }
+}

package/src/services/nativeNavigationGate.ts

@@ -0,0 +1,14 @@
+/**
+ * The firmware nav UI is a stock-firmware feature. Custom firmware publishes a
+ * scene canvas, so the navigation miniapp draws its own HUD there and reads
+ * session.compass directly; native nav mode would only cover that up. The
+ * debug knob forces it back on for comparing both UIs on hardware.
+ */
+export function resolveNativeNavigation(
+  modelSupports: boolean | undefined,
+  customFirmware: boolean,
+  forceOnCustomFirmware: boolean,
+): boolean | undefined {
+  if (modelSupports !== true) return modelSupports
+  return !customFirmware || forceOnCustomFirmware
+}

package/src/services/notificationAppCatalog.ts

@@ -0,0 +1,21 @@
+/**
+ * Seeded catalog of apps that post notifications, keyed by bundle id or
+ * package name. Where the phone cannot enumerate apps (iOS) the filter UI
+ * shows this catalog plus apps the glasses have reported, and firmware whose
+ * filter is an allowlist needs known ids so blocking one app does not take
+ * every not-yet-seen app down with it. Derived from the SDK's known-apps
+ * table so names live in one place.
+ */
+import {KNOWN_APPS} from "@glassly/miniapp/known-apps"
+import {Platform} from "react-native"
+
+export interface NotificationApp {
+  appId: string
+  displayName: string
+}
+
+/** The catalog for the current phone platform. */
+export function notificationAppCatalog(): NotificationApp[] {
+  const other = Platform.OS === "ios" ? "android" : "ios"
+  return KNOWN_APPS.filter((app) => app.platform !== other).map((app) => ({appId: app.id, displayName: app.name}))
+}