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

package/build/services/pages/overlayApps.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The overlay apps: the connected miniapps whose manifest type is
+ * "system_dashboard" (the dashboard, the notifications viewer). They alone
+ * may take the overlay slot through `session.display.showView("dashboard")`
+ * and have "dashboard" in their `display.views` capability while the
+ * glasses are eligible. The runtime adds an app when it connects and
+ * removes it when it stops; the engine never knows what any of them draws.
+ * Kept free of imports so the runtime and the notification policy can both
+ * read it without a cycle.
+ */
+export type DisplayView = "main" | "dashboard";
+export declare function isOverlayApp(packageName: string): boolean;
+export declare function overlayApps(): readonly string[];
+export declare function addOverlayApp(packageName: string): void;
+export declare function removeOverlayApp(packageName: string): void;
+/** Record whether an overlay app subscribes to phone notifications (it is a viewer while it does). */
+export declare function setOverlayViewer(packageName: string, listening: boolean): void;
+/** An overlay app that presents phone notifications is running. */
+export declare function overlayViewerRunning(): boolean;
+export declare function onOverlayAppsChange(listener: () => void): () => void;
+/** The views `packageName` may draw: main for everyone, the dashboard for overlay apps on eligible glasses. */
+export declare function displayViewsFor(packageName: string, eligible: boolean): DisplayView[];
+/** Tests only. */
+export declare function _resetOverlayAppsForTest(): void;
+//# sourceMappingURL=overlayApps.d.ts.map

package/build/services/pages/overlayApps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlayApps.d.ts","sourceRoot":"","sources":["../../../src/services/pages/overlayApps.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,WAAW,CAAA;AAO9C,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED,wBAAgB,WAAW,IAAI,SAAS,MAAM,EAAE,CAE/C;AAED,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAIvD;AAED,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAI1D;AAED,sGAAsG;AACtG,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,GAAG,IAAI,CAK9E;AAED,mEAAmE;AACnE,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAKpE;AAED,+GAA+G;AAC/G,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,WAAW,EAAE,CAErF;AAMD,kBAAkB;AAClB,wBAAgB,wBAAwB,IAAI,IAAI,CAG/C"}

package/build/services/pages/overlayApps.js

@@ -0,0 +1,66 @@
+/**
+ * The overlay apps: the connected miniapps whose manifest type is
+ * "system_dashboard" (the dashboard, the notifications viewer). They alone
+ * may take the overlay slot through `session.display.showView("dashboard")`
+ * and have "dashboard" in their `display.views` capability while the
+ * glasses are eligible. The runtime adds an app when it connects and
+ * removes it when it stops; the engine never knows what any of them draws.
+ * Kept free of imports so the runtime and the notification policy can both
+ * read it without a cycle.
+ */
+const apps = new Set();
+/** Overlay apps listening to the phone's notifications: something on the glasses presents them. */
+const viewers = new Set();
+const listeners = new Set();
+export function isOverlayApp(packageName) {
+    return apps.has(packageName);
+}
+export function overlayApps() {
+    return [...apps];
+}
+export function addOverlayApp(packageName) {
+    if (apps.has(packageName))
+        return;
+    apps.add(packageName);
+    emit();
+}
+export function removeOverlayApp(packageName) {
+    viewers.delete(packageName);
+    if (!apps.delete(packageName))
+        return;
+    emit();
+}
+/** Record whether an overlay app subscribes to phone notifications (it is a viewer while it does). */
+export function setOverlayViewer(packageName, listening) {
+    const was = viewers.has(packageName);
+    if (listening && apps.has(packageName))
+        viewers.add(packageName);
+    else
+        viewers.delete(packageName);
+    if (was !== viewers.has(packageName))
+        emit();
+}
+/** An overlay app that presents phone notifications is running. */
+export function overlayViewerRunning() {
+    return viewers.size > 0;
+}
+export function onOverlayAppsChange(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+/** The views `packageName` may draw: main for everyone, the dashboard for overlay apps on eligible glasses. */
+export function displayViewsFor(packageName, eligible) {
+    return apps.has(packageName) && eligible ? ["main", "dashboard"] : ["main"];
+}
+function emit() {
+    for (const listener of Array.from(listeners))
+        listener();
+}
+/** Tests only. */
+export function _resetOverlayAppsForTest() {
+    apps.clear();
+    viewers.clear();
+}
+//# sourceMappingURL=overlayApps.js.map

package/build/services/pages/overlayApps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlayApps.js","sourceRoot":"","sources":["../../../src/services/pages/overlayApps.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAA;AAC9B,mGAAmG;AACnG,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAA;AACjC,MAAM,SAAS,GAAG,IAAI,GAAG,EAAc,CAAA;AAEvC,MAAM,UAAU,YAAY,CAAC,WAAmB;IAC9C,OAAO,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAA;AAC9B,CAAC;AAED,MAAM,UAAU,WAAW;IACzB,OAAO,CAAC,GAAG,IAAI,CAAC,CAAA;AAClB,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,WAAmB;IAC/C,IAAI,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC;QAAE,OAAM;IACjC,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAA;IACrB,IAAI,EAAE,CAAA;AACR,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,WAAmB;IAClD,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAA;IAC3B,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;QAAE,OAAM;IACrC,IAAI,EAAE,CAAA;AACR,CAAC;AAED,sGAAsG;AACtG,MAAM,UAAU,gBAAgB,CAAC,WAAmB,EAAE,SAAkB;IACtE,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAAA;IACpC,IAAI,SAAS,IAAI,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC;QAAE,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAAA;;QAC3D,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAA;IAChC,IAAI,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC;QAAE,IAAI,EAAE,CAAA;AAC9C,CAAC;AAED,mEAAmE;AACnE,MAAM,UAAU,oBAAoB;IAClC,OAAO,OAAO,CAAC,IAAI,GAAG,CAAC,CAAA;AACzB,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,QAAoB;IACtD,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;IACvB,OAAO,GAAG,EAAE;QACV,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;IAC5B,CAAC,CAAA;AACH,CAAC;AAED,+GAA+G;AAC/G,MAAM,UAAU,eAAe,CAAC,WAAmB,EAAE,QAAiB;IACpE,OAAO,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAA;AAC7E,CAAC;AAED,SAAS,IAAI;IACX,KAAK,MAAM,QAAQ,IAAI,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC;QAAE,QAAQ,EAAE,CAAA;AAC1D,CAAC;AAED,kBAAkB;AAClB,MAAM,UAAU,wBAAwB;IACtC,IAAI,CAAC,KAAK,EAAE,CAAA;IACZ,OAAO,CAAC,KAAK,EAAE,CAAA;AACjB,CAAC","sourcesContent":["/**\n * The overlay apps: the connected miniapps whose manifest type is\n * \"system_dashboard\" (the dashboard, the notifications viewer). They alone\n * may take the overlay slot through `session.display.showView(\"dashboard\")`\n * and have \"dashboard\" in their `display.views` capability while the\n * glasses are eligible. The runtime adds an app when it connects and\n * removes it when it stops; the engine never knows what any of them draws.\n * Kept free of imports so the runtime and the notification policy can both\n * read it without a cycle.\n */\n\nexport type DisplayView = \"main\" | \"dashboard\"\n\nconst apps = new Set<string>()\n/** Overlay apps listening to the phone's notifications: something on the glasses presents them. */\nconst viewers = new Set<string>()\nconst listeners = new Set<() => void>()\n\nexport function isOverlayApp(packageName: string): boolean {\n  return apps.has(packageName)\n}\n\nexport function overlayApps(): readonly string[] {\n  return [...apps]\n}\n\nexport function addOverlayApp(packageName: string): void {\n  if (apps.has(packageName)) return\n  apps.add(packageName)\n  emit()\n}\n\nexport function removeOverlayApp(packageName: string): void {\n  viewers.delete(packageName)\n  if (!apps.delete(packageName)) return\n  emit()\n}\n\n/** Record whether an overlay app subscribes to phone notifications (it is a viewer while it does). */\nexport function setOverlayViewer(packageName: string, listening: boolean): void {\n  const was = viewers.has(packageName)\n  if (listening && apps.has(packageName)) viewers.add(packageName)\n  else viewers.delete(packageName)\n  if (was !== viewers.has(packageName)) emit()\n}\n\n/** An overlay app that presents phone notifications is running. */\nexport function overlayViewerRunning(): boolean {\n  return viewers.size > 0\n}\n\nexport function onOverlayAppsChange(listener: () => void): () => void {\n  listeners.add(listener)\n  return () => {\n    listeners.delete(listener)\n  }\n}\n\n/** The views `packageName` may draw: main for everyone, the dashboard for overlay apps on eligible glasses. */\nexport function displayViewsFor(packageName: string, eligible: boolean): DisplayView[] {\n  return apps.has(packageName) && eligible ? [\"main\", \"dashboard\"] : [\"main\"]\n}\n\nfunction emit(): void {\n  for (const listener of Array.from(listeners)) listener()\n}\n\n/** Tests only. */\nexport function _resetOverlayAppsForTest(): void {\n  apps.clear()\n  viewers.clear()\n}\n"]}

package/build/services/pages/pageEligibility.d.ts

@@ -0,0 +1,9 @@
+/** G2.swift appends this marker after the firmware advertises Glassly CFW capabilities. */
+export declare function isCfwFirmwareVersion(firmwareVersion: string | null | undefined): boolean;
+/** Stock G2 and NIMO are intentionally excluded. */
+export declare function isCustomDashboardEligible(info: {
+    model?: string | null;
+    firmwareVersion?: string | null;
+}): boolean;
+export declare function pagesEligible(): boolean;
+//# sourceMappingURL=pageEligibility.d.ts.map

package/build/services/pages/pageEligibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pageEligibility.d.ts","sourceRoot":"","sources":["../../../src/services/pages/pageEligibility.ts"],"names":[],"mappings":"AAYA,2FAA2F;AAC3F,wBAAgB,oBAAoB,CAAC,eAAe,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAExF;AAED,oDAAoD;AACpD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAC,GAAG,OAAO,CAEjH;AAED,wBAAgB,aAAa,IAAI,OAAO,CAOvC"}

package/build/services/pages/pageEligibility.js

@@ -0,0 +1,27 @@
+/**
+ * Whether the dashboard view may show right now: connected Glassly CFW
+ * glasses with the dashboard enabled. The page host reads it before showing
+ * a page and hides the showing page when it turns false; the miniapp runtime
+ * folds it into the designated app's `display.views` capability. Read at
+ * decision time, never cached.
+ */
+import { useGlassesStore } from "../../stores/glasses";
+import { SETTINGS, useSettingsStore } from "../../stores/settings";
+import { DeviceTypes } from "../../types/enums";
+import { isGlassesConnected } from "../GlassesReadiness";
+/** G2.swift appends this marker after the firmware advertises Glassly CFW capabilities. */
+export function isCfwFirmwareVersion(firmwareVersion) {
+    return firmwareVersion?.toLowerCase().includes("glassly cfw") === true;
+}
+/** Stock G2 and NIMO are intentionally excluded. */
+export function isCustomDashboardEligible(info) {
+    return info.model === DeviceTypes.G2 && isCfwFirmwareVersion(info.firmwareVersion);
+}
+export function pagesEligible() {
+    if (useSettingsStore.getState().getSetting(SETTINGS.custom_dashboard_enabled.key) === false)
+        return false;
+    const state = useGlassesStore.getState();
+    return (isGlassesConnected(state.connection) &&
+        isCustomDashboardEligible({ model: state.deviceModel, firmwareVersion: state.firmwareVersion }));
+}
+//# sourceMappingURL=pageEligibility.js.map

package/build/services/pages/pageEligibility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pageEligibility.js","sourceRoot":"","sources":["../../../src/services/pages/pageEligibility.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAA;AACpD,OAAO,EAAC,QAAQ,EAAE,gBAAgB,EAAC,MAAM,uBAAuB,CAAA;AAChE,OAAO,EAAC,WAAW,EAAC,MAAM,mBAAmB,CAAA;AAC7C,OAAO,EAAC,kBAAkB,EAAC,MAAM,qBAAqB,CAAA;AAEtD,2FAA2F;AAC3F,MAAM,UAAU,oBAAoB,CAAC,eAA0C;IAC7E,OAAO,eAAe,EAAE,WAAW,EAAE,CAAC,QAAQ,CAAC,aAAa,CAAC,KAAK,IAAI,CAAA;AACxE,CAAC;AAED,oDAAoD;AACpD,MAAM,UAAU,yBAAyB,CAAC,IAA8D;IACtG,OAAO,IAAI,CAAC,KAAK,KAAK,WAAW,CAAC,EAAE,IAAI,oBAAoB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAA;AACpF,CAAC;AAED,MAAM,UAAU,aAAa;IAC3B,IAAI,gBAAgB,CAAC,QAAQ,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,wBAAwB,CAAC,GAAG,CAAC,KAAK,KAAK;QAAE,OAAO,KAAK,CAAA;IACzG,MAAM,KAAK,GAAG,eAAe,CAAC,QAAQ,EAAE,CAAA;IACxC,OAAO,CACL,kBAAkB,CAAC,KAAK,CAAC,UAAU,CAAC;QACpC,yBAAyB,CAAC,EAAC,KAAK,EAAE,KAAK,CAAC,WAAW,EAAE,eAAe,EAAE,KAAK,CAAC,eAAe,EAAC,CAAC,CAC9F,CAAA;AACH,CAAC","sourcesContent":["/**\n * Whether the dashboard view may show right now: connected Glassly CFW\n * glasses with the dashboard enabled. The page host reads it before showing\n * a page and hides the showing page when it turns false; the miniapp runtime\n * folds it into the designated app's `display.views` capability. Read at\n * decision time, never cached.\n */\nimport {useGlassesStore} from \"../../stores/glasses\"\nimport {SETTINGS, useSettingsStore} from \"../../stores/settings\"\nimport {DeviceTypes} from \"../../types/enums\"\nimport {isGlassesConnected} from \"../GlassesReadiness\"\n\n/** G2.swift appends this marker after the firmware advertises Glassly CFW capabilities. */\nexport function isCfwFirmwareVersion(firmwareVersion: string | null | undefined): boolean {\n  return firmwareVersion?.toLowerCase().includes(\"glassly cfw\") === true\n}\n\n/** Stock G2 and NIMO are intentionally excluded. */\nexport function isCustomDashboardEligible(info: {model?: string | null; firmwareVersion?: string | null}): boolean {\n  return info.model === DeviceTypes.G2 && isCfwFirmwareVersion(info.firmwareVersion)\n}\n\nexport function pagesEligible(): boolean {\n  if (useSettingsStore.getState().getSetting(SETTINGS.custom_dashboard_enabled.key) === false) return false\n  const state = useGlassesStore.getState()\n  return (\n    isGlassesConnected(state.connection) &&\n    isCustomDashboardEligible({model: state.deviceModel, firmwareVersion: state.firmwareVersion})\n  )\n}\n"]}

package/build/services/settingsBridge.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The settings bridge's vocabulary (session.settings): which engine settings
+ * a system miniapp may read or write, the derived read-only keys the engine
+ * computes rather than stores, and the request validation. Pure, so the
+ * runtime's handlers stay thin and this can be tested without the native
+ * import surface the runtime pulls in.
+ *
+ * The dashboard miniapp is the consumer: it edits the same dashboard,
+ * 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.
+ */
+export type SettingsBridgeAccess = "read" | "write";
+/** Stored settings the bridge serves, by key, with what a system app may do to each. */
+export declare 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, and the ring's
+ * battery. They change on their own clocks; the runtime pushes them like
+ * stored keys.
+ */
+export declare const DERIVED_SETTINGS_KEYS: readonly ["phone_active", "foreground_app_on_screen", "ring_battery"];
+export type DerivedSettingsKey = (typeof DERIVED_SETTINGS_KEYS)[number];
+export declare function isDerivedSettingsKey(key: string): key is DerivedSettingsKey;
+/** What a system app may do with `key`, or null when the bridge does not serve it. */
+export declare function settingsBridgeAccess(key: string): SettingsBridgeAccess | null;
+/** Every key the bridge serves, stored then derived. */
+export declare function allSettingsBridgeKeys(): string[];
+/**
+ * The keys a SETTINGS_GET asks for: everything when `requested` is absent,
+ * else the known ones among the requested strings (unknown keys are left
+ * out, never rejected).
+ */
+export declare function selectSettingsBridgeKeys(requested: unknown): string[];
+export type SettingsSetValidation = {
+    ok: true;
+    key: string;
+    value: unknown;
+} | {
+    ok: false;
+    code: "INVALID_ARGUMENT" | "NOT_PERMITTED";
+    message: string;
+};
+/** A SETTINGS_SET payload: a writable key and a JSON value (undefined is not a value). */
+export declare function validateSettingsSet(payload: Record<string, unknown>): SettingsSetValidation;
+/** The ring's battery as the dashboard shows it: the relayed ring first, else the controller. */
+export interface RingBattery {
+    connected: boolean;
+    /** -1 when unknown. */
+    level: number;
+}
+export declare function ringBatteryFrom(glasses: {
+    ringConnected: boolean;
+    ringBatteryLevel: number;
+    controllerConnected: boolean;
+    controllerBatteryLevel: number;
+}): RingBattery;
+//# sourceMappingURL=settingsBridge.d.ts.map

package/build/services/settingsBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settingsBridge.d.ts","sourceRoot":"","sources":["../../src/services/settingsBridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,OAAO,CAAA;AAEnD,wFAAwF;AACxF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAoB/E,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,uEAAwE,CAAA;AAC1G,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEvE,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,IAAI,kBAAkB,CAE3E;AAED,sFAAsF;AACtF,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB,GAAG,IAAI,CAG7E;AAED,wDAAwD;AACxD,wBAAgB,qBAAqB,IAAI,MAAM,EAAE,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,EAAE,CAIrE;AAED,MAAM,MAAM,qBAAqB,GAC7B;IAAC,EAAE,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAC,GACvC;IAAC,EAAE,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,kBAAkB,GAAG,eAAe,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAAA;AAE5E,0FAA0F;AAC1F,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,qBAAqB,CAY3F;AAED,iGAAiG;AACjG,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,OAAO,CAAA;IAClB,uBAAuB;IACvB,KAAK,EAAE,MAAM,CAAA;CACd;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE;IACvC,aAAa,EAAE,OAAO,CAAA;IACtB,gBAAgB,EAAE,MAAM,CAAA;IACxB,mBAAmB,EAAE,OAAO,CAAA;IAC5B,sBAAsB,EAAE,MAAM,CAAA;CAC/B,GAAG,WAAW,CAMd"}

package/build/services/settingsBridge.js

@@ -0,0 +1,90 @@
+/**
+ * The settings bridge's vocabulary (session.settings): which engine settings
+ * a system miniapp may read or write, the derived read-only keys the engine
+ * computes rather than stores, and the request validation. Pure, so the
+ * runtime's handlers stay thin and this can be tested without the native
+ * import surface the runtime pulls in.
+ *
+ * The dashboard miniapp is the consumer: it edits the same dashboard,
+ * 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.
+ */
+/** Stored settings the bridge serves, by key, with what a system app may do to each. */
+export const SETTINGS_BRIDGE_KEYS = {
+    // The dashboard's master switch is a phone-side debug knob.
+    custom_dashboard_enabled: "read",
+    custom_dashboard_clock_style: "write",
+    custom_dashboard_clock_show_date: "write",
+    custom_dashboard_battery_style: "write",
+    custom_dashboard_layout: "write",
+    custom_dashboard_calendar_event_count: "write",
+    custom_dashboard_calendar_days_ahead: "write",
+    contextual_dashboard: "write",
+    twelve_hour_time: "write",
+    menu_apps: "write",
+    notifications_enabled: "write",
+    notifications_popups: "write",
+    notifications_popup_seconds: "write",
+    notifications_hold_during_apps: "write",
+    notifications_ignore_while_active: "write",
+    notifications_blocklist: "write",
+    // Apps the glasses reported posting notifications; the engine records it.
+    notification_seen_apps: "read",
+};
+/**
+ * Read-only keys the engine computes: whether the wearer can see the phone,
+ * 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"];
+export function isDerivedSettingsKey(key) {
+    return DERIVED_SETTINGS_KEYS.includes(key);
+}
+/** What a system app may do with `key`, or null when the bridge does not serve it. */
+export function settingsBridgeAccess(key) {
+    if (isDerivedSettingsKey(key))
+        return "read";
+    return SETTINGS_BRIDGE_KEYS[key] ?? null;
+}
+/** Every key the bridge serves, stored then derived. */
+export function allSettingsBridgeKeys() {
+    return [...Object.keys(SETTINGS_BRIDGE_KEYS), ...DERIVED_SETTINGS_KEYS];
+}
+/**
+ * The keys a SETTINGS_GET asks for: everything when `requested` is absent,
+ * else the known ones among the requested strings (unknown keys are left
+ * out, never rejected).
+ */
+export function selectSettingsBridgeKeys(requested) {
+    if (requested === undefined || requested === null)
+        return allSettingsBridgeKeys();
+    if (!Array.isArray(requested))
+        return [];
+    return requested.filter((key) => typeof key === "string" && settingsBridgeAccess(key) !== null);
+}
+/** A SETTINGS_SET payload: a writable key and a JSON value (undefined is not a value). */
+export function validateSettingsSet(payload) {
+    const key = payload.key;
+    if (typeof key !== "string" || !key) {
+        return { ok: false, code: "INVALID_ARGUMENT", message: "settings.set requires a key" };
+    }
+    const access = settingsBridgeAccess(key);
+    if (access === null)
+        return { ok: false, code: "INVALID_ARGUMENT", message: `Unknown setting "${key}"` };
+    if (access !== "write")
+        return { ok: false, code: "NOT_PERMITTED", message: `Setting "${key}" is read-only` };
+    if (!("value" in payload) || payload.value === undefined) {
+        return { ok: false, code: "INVALID_ARGUMENT", message: "settings.set requires a value" };
+    }
+    return { ok: true, key, value: payload.value };
+}
+export function ringBatteryFrom(glasses) {
+    const relayed = glasses.ringConnected && glasses.ringBatteryLevel >= 0;
+    return {
+        connected: relayed || glasses.controllerConnected,
+        level: relayed ? glasses.ringBatteryLevel : glasses.controllerBatteryLevel,
+    };
+}
+//# sourceMappingURL=settingsBridge.js.map

package/build/services/settingsBridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settingsBridge.js","sourceRoot":"","sources":["../../src/services/settingsBridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,wFAAwF;AACxF,MAAM,CAAC,MAAM,oBAAoB,GAAmD;IAClF,4DAA4D;IAC5D,wBAAwB,EAAE,MAAM;IAChC,4BAA4B,EAAE,OAAO;IACrC,gCAAgC,EAAE,OAAO;IACzC,8BAA8B,EAAE,OAAO;IACvC,uBAAuB,EAAE,OAAO;IAChC,qCAAqC,EAAE,OAAO;IAC9C,oCAAoC,EAAE,OAAO;IAC7C,oBAAoB,EAAE,OAAO;IAC7B,gBAAgB,EAAE,OAAO;IACzB,SAAS,EAAE,OAAO;IAClB,qBAAqB,EAAE,OAAO;IAC9B,oBAAoB,EAAE,OAAO;IAC7B,2BAA2B,EAAE,OAAO;IACpC,8BAA8B,EAAE,OAAO;IACvC,iCAAiC,EAAE,OAAO;IAC1C,uBAAuB,EAAE,OAAO;IAChC,0EAA0E;IAC1E,sBAAsB,EAAE,MAAM;CAC/B,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,cAAc,EAAE,0BAA0B,EAAE,cAAc,CAAU,CAAA;AAG1G,MAAM,UAAU,oBAAoB,CAAC,GAAW;IAC9C,OAAQ,qBAA2C,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAA;AACnE,CAAC;AAED,sFAAsF;AACtF,MAAM,UAAU,oBAAoB,CAAC,GAAW;IAC9C,IAAI,oBAAoB,CAAC,GAAG,CAAC;QAAE,OAAO,MAAM,CAAA;IAC5C,OAAO,oBAAoB,CAAC,GAAG,CAAC,IAAI,IAAI,CAAA;AAC1C,CAAC;AAED,wDAAwD;AACxD,MAAM,UAAU,qBAAqB;IACnC,OAAO,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,oBAAoB,CAAC,EAAE,GAAG,qBAAqB,CAAC,CAAA;AACzE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,wBAAwB,CAAC,SAAkB;IACzD,IAAI,SAAS,KAAK,SAAS,IAAI,SAAS,KAAK,IAAI;QAAE,OAAO,qBAAqB,EAAE,CAAA;IACjF,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC;QAAE,OAAO,EAAE,CAAA;IACxC,OAAO,SAAS,CAAC,MAAM,CAAC,CAAC,GAAG,EAAiB,EAAE,CAAC,OAAO,GAAG,KAAK,QAAQ,IAAI,oBAAoB,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC,CAAA;AAChH,CAAC;AAMD,0FAA0F;AAC1F,MAAM,UAAU,mBAAmB,CAAC,OAAgC;IAClE,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAA;IACvB,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,GAAG,EAAE,CAAC;QACpC,OAAO,EAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,kBAAkB,EAAE,OAAO,EAAE,6BAA6B,EAAC,CAAA;IACtF,CAAC;IACD,MAAM,MAAM,GAAG,oBAAoB,CAAC,GAAG,CAAC,CAAA;IACxC,IAAI,MAAM,KAAK,IAAI;QAAE,OAAO,EAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,kBAAkB,EAAE,OAAO,EAAE,oBAAoB,GAAG,GAAG,EAAC,CAAA;IACtG,IAAI,MAAM,KAAK,OAAO;QAAE,OAAO,EAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,YAAY,GAAG,gBAAgB,EAAC,CAAA;IAC3G,IAAI,CAAC,CAAC,OAAO,IAAI,OAAO,CAAC,IAAI,OAAO,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;QACzD,OAAO,EAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,kBAAkB,EAAE,OAAO,EAAE,+BAA+B,EAAC,CAAA;IACxF,CAAC;IACD,OAAO,EAAC,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAC,CAAA;AAC9C,CAAC;AASD,MAAM,UAAU,eAAe,CAAC,OAK/B;IACC,MAAM,OAAO,GAAG,OAAO,CAAC,aAAa,IAAI,OAAO,CAAC,gBAAgB,IAAI,CAAC,CAAA;IACtE,OAAO;QACL,SAAS,EAAE,OAAO,IAAI,OAAO,CAAC,mBAAmB;QACjD,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,OAAO,CAAC,sBAAsB;KAC3E,CAAA;AACH,CAAC","sourcesContent":["/**\n * The settings bridge's vocabulary (session.settings): which engine settings\n * a system miniapp may read or write, the derived read-only keys the engine\n * computes rather than stores, and the request validation. Pure, so the\n * runtime's handlers stay thin and this can be tested without the native\n * import surface the runtime pulls in.\n *\n * The dashboard miniapp is the consumer: it edits the same dashboard,\n * notification and glasses-menu keys the phone's settings screens used to,\n * through the store, so persistence, server sync and the Bluetooth sync of\n * `menu_apps` behave as if a phone screen wrote them.\n */\n\nexport type SettingsBridgeAccess = \"read\" | \"write\"\n\n/** Stored settings the bridge serves, by key, with what a system app may do to each. */\nexport const SETTINGS_BRIDGE_KEYS: Readonly<Record<string, SettingsBridgeAccess>> = {\n  // The dashboard's master switch is a phone-side debug knob.\n  custom_dashboard_enabled: \"read\",\n  custom_dashboard_clock_style: \"write\",\n  custom_dashboard_clock_show_date: \"write\",\n  custom_dashboard_battery_style: \"write\",\n  custom_dashboard_layout: \"write\",\n  custom_dashboard_calendar_event_count: \"write\",\n  custom_dashboard_calendar_days_ahead: \"write\",\n  contextual_dashboard: \"write\",\n  twelve_hour_time: \"write\",\n  menu_apps: \"write\",\n  notifications_enabled: \"write\",\n  notifications_popups: \"write\",\n  notifications_popup_seconds: \"write\",\n  notifications_hold_during_apps: \"write\",\n  notifications_ignore_while_active: \"write\",\n  notifications_blocklist: \"write\",\n  // Apps the glasses reported posting notifications; the engine records it.\n  notification_seen_apps: \"read\",\n}\n\n/**\n * Read-only keys the engine computes: whether the wearer can see the phone,\n * whether the foreground miniapp is drawing on the glasses, and the ring's\n * battery. They change on their own clocks; the runtime pushes them like\n * stored keys.\n */\nexport const DERIVED_SETTINGS_KEYS = [\"phone_active\", \"foreground_app_on_screen\", \"ring_battery\"] as const\nexport type DerivedSettingsKey = (typeof DERIVED_SETTINGS_KEYS)[number]\n\nexport function isDerivedSettingsKey(key: string): key is DerivedSettingsKey {\n  return (DERIVED_SETTINGS_KEYS as readonly string[]).includes(key)\n}\n\n/** What a system app may do with `key`, or null when the bridge does not serve it. */\nexport function settingsBridgeAccess(key: string): SettingsBridgeAccess | null {\n  if (isDerivedSettingsKey(key)) return \"read\"\n  return SETTINGS_BRIDGE_KEYS[key] ?? null\n}\n\n/** Every key the bridge serves, stored then derived. */\nexport function allSettingsBridgeKeys(): string[] {\n  return [...Object.keys(SETTINGS_BRIDGE_KEYS), ...DERIVED_SETTINGS_KEYS]\n}\n\n/**\n * The keys a SETTINGS_GET asks for: everything when `requested` is absent,\n * else the known ones among the requested strings (unknown keys are left\n * out, never rejected).\n */\nexport function selectSettingsBridgeKeys(requested: unknown): string[] {\n  if (requested === undefined || requested === null) return allSettingsBridgeKeys()\n  if (!Array.isArray(requested)) return []\n  return requested.filter((key): key is string => typeof key === \"string\" && settingsBridgeAccess(key) !== null)\n}\n\nexport type SettingsSetValidation =\n  | {ok: true; key: string; value: unknown}\n  | {ok: false; code: \"INVALID_ARGUMENT\" | \"NOT_PERMITTED\"; message: string}\n\n/** A SETTINGS_SET payload: a writable key and a JSON value (undefined is not a value). */\nexport function validateSettingsSet(payload: Record<string, unknown>): SettingsSetValidation {\n  const key = payload.key\n  if (typeof key !== \"string\" || !key) {\n    return {ok: false, code: \"INVALID_ARGUMENT\", message: \"settings.set requires a key\"}\n  }\n  const access = settingsBridgeAccess(key)\n  if (access === null) return {ok: false, code: \"INVALID_ARGUMENT\", message: `Unknown setting \"${key}\"`}\n  if (access !== \"write\") return {ok: false, code: \"NOT_PERMITTED\", message: `Setting \"${key}\" is read-only`}\n  if (!(\"value\" in payload) || payload.value === undefined) {\n    return {ok: false, code: \"INVALID_ARGUMENT\", message: \"settings.set requires a value\"}\n  }\n  return {ok: true, key, value: payload.value}\n}\n\n/** The ring's battery as the dashboard shows it: the relayed ring first, else the controller. */\nexport interface RingBattery {\n  connected: boolean\n  /** -1 when unknown. */\n  level: number\n}\n\nexport function ringBatteryFrom(glasses: {\n  ringConnected: boolean\n  ringBatteryLevel: number\n  controllerConnected: boolean\n  controllerBatteryLevel: number\n}): RingBattery {\n  const relayed = glasses.ringConnected && glasses.ringBatteryLevel >= 0\n  return {\n    connected: relayed || glasses.controllerConnected,\n    level: relayed ? glasses.ringBatteryLevel : glasses.controllerBatteryLevel,\n  }\n}\n"]}

package/build/services/speakerProfileStoreInstance.js

@@ -7,7 +7,7 @@ import { storage as mmkvStorage } from "../utils/storage/storage";
 import { cloudClientService } from "./CloudClientService";
 import { SpeakerProfileStore } from "./SpeakerProfileStore";
 export const speakerProfileStore = new SpeakerProfileStore({
-    getUserId: () => cloudClientService.resolveGlasslyUserId(),
+    getUserId: () => cloudClientService.resolveUserId(),
     backend: {
         get(key) {
             const result = mmkvStorage.load(key);

package/build/services/speakerProfileStoreInstance.js.map

@@ -1 +1 @@
-{"version":3,"file":"speakerProfileStoreInstance.js","sourceRoot":"","sources":["../../src/services/speakerProfileStoreInstance.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAC,OAAO,IAAI,WAAW,EAAC,MAAM,0BAA0B,CAAA;AAC/D,OAAO,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAC,mBAAmB,EAAC,MAAM,uBAAuB,CAAA;AAEzD,MAAM,CAAC,MAAM,mBAAmB,GAAG,IAAI,mBAAmB,CAAC;IACzD,SAAS,EAAE,GAAG,EAAE,CAAC,kBAAkB,CAAC,oBAAoB,EAAE;IAC1D,OAAO,EAAE;QACP,GAAG,CAAC,GAAW;YACb,MAAM,MAAM,GAAG,WAAW,CAAC,IAAI,CAAU,GAAG,CAAC,CAAA;YAC7C,OAAO,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAA;QAC7C,CAAC;QACD,GAAG,CAAC,GAAW,EAAE,KAAc;YAC7B,WAAW,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;QAC9B,CAAC;QACD,MAAM,CAAC,GAAW;YAChB,WAAW,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;QACzB,CAAC;KACF;CACF,CAAC,CAAA","sourcesContent":["/**\n * The engine's singleton SpeakerProfileStore — device-local voice profiles\n * behind engine.speakers. Lives in its own module (not SpeakerProfileStore.ts)\n * so the store class stays dependency-free for tests.\n */\n\nimport {storage as mmkvStorage} from \"../utils/storage/storage\"\nimport {cloudClientService} from \"./CloudClientService\"\nimport {SpeakerProfileStore} from \"./SpeakerProfileStore\"\n\nexport const speakerProfileStore = new SpeakerProfileStore({\n  getUserId: () => cloudClientService.resolveGlasslyUserId(),\n  backend: {\n    get(key: string): unknown | null {\n      const result = mmkvStorage.load<unknown>(key)\n      return result.is_ok() ? result.value : null\n    },\n    set(key: string, value: unknown): void {\n      mmkvStorage.save(key, value)\n    },\n    remove(key: string): void {\n      mmkvStorage.remove(key)\n    },\n  },\n})\n"]}
+{"version":3,"file":"speakerProfileStoreInstance.js","sourceRoot":"","sources":["../../src/services/speakerProfileStoreInstance.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAC,OAAO,IAAI,WAAW,EAAC,MAAM,0BAA0B,CAAA;AAC/D,OAAO,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAC,mBAAmB,EAAC,MAAM,uBAAuB,CAAA;AAEzD,MAAM,CAAC,MAAM,mBAAmB,GAAG,IAAI,mBAAmB,CAAC;IACzD,SAAS,EAAE,GAAG,EAAE,CAAC,kBAAkB,CAAC,aAAa,EAAE;IACnD,OAAO,EAAE;QACP,GAAG,CAAC,GAAW;YACb,MAAM,MAAM,GAAG,WAAW,CAAC,IAAI,CAAU,GAAG,CAAC,CAAA;YAC7C,OAAO,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAA;QAC7C,CAAC;QACD,GAAG,CAAC,GAAW,EAAE,KAAc;YAC7B,WAAW,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;QAC9B,CAAC;QACD,MAAM,CAAC,GAAW;YAChB,WAAW,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;QACzB,CAAC;KACF;CACF,CAAC,CAAA","sourcesContent":["/**\n * The engine's singleton SpeakerProfileStore — device-local voice profiles\n * behind engine.speakers. Lives in its own module (not SpeakerProfileStore.ts)\n * so the store class stays dependency-free for tests.\n */\n\nimport {storage as mmkvStorage} from \"../utils/storage/storage\"\nimport {cloudClientService} from \"./CloudClientService\"\nimport {SpeakerProfileStore} from \"./SpeakerProfileStore\"\n\nexport const speakerProfileStore = new SpeakerProfileStore({\n  getUserId: () => cloudClientService.resolveUserId(),\n  backend: {\n    get(key: string): unknown | null {\n      const result = mmkvStorage.load<unknown>(key)\n      return result.is_ok() ? result.value : null\n    },\n    set(key: string, value: unknown): void {\n      mmkvStorage.save(key, value)\n    },\n    remove(key: string): void {\n      mmkvStorage.remove(key)\n    },\n  },\n})\n"]}

package/build/services/uiShim.d.ts

@@ -10,7 +10,7 @@
  *   - Buffers `glassly.send(channel, payload)` calls until `glassly.ready()`
  *     fires + the host acks the channel is open. WebView-side BUFFERS (the
  *     WebView is the short-lived side and shouldn't drop user input).
- *   - Installs `window.__glassly.recv(envelope)` for the host to push
+ *   - Installs `window.__host.recv(envelope)` for the host to push
  *     background → WebView messages via `webview.injectJavaScript(...)`.
  *   - Sends `__heartbeat__` every 5s; host considers the WebView gone
  *     after 15s of silence.

package/build/services/uiShim.js

@@ -10,7 +10,7 @@
  *   - Buffers `glassly.send(channel, payload)` calls until `glassly.ready()`
  *     fires + the host acks the channel is open. WebView-side BUFFERS (the
  *     WebView is the short-lived side and shouldn't drop user input).
- *   - Installs `window.__glassly.recv(envelope)` for the host to push
+ *   - Installs `window.__host.recv(envelope)` for the host to push
  *     background → WebView messages via `webview.injectJavaScript(...)`.
  *   - Sends `__heartbeat__` every 5s; host considers the WebView gone
  *     after 15s of silence.
@@ -32,12 +32,12 @@
 export function buildUiShim(options) {
     const packageNameJson = JSON.stringify(options.packageName);
     // The IIFE assembles a typed `glassly` global plus an internal
-    // `__glassly` for host inbound calls. Quoted strings are JSON-safe so
+    // `__host` for host inbound calls. Quoted strings are JSON-safe so
     // direct injection inside another JS literal also works.
     return `
 (function () {
   if (typeof window === 'undefined') return;
-  if (window.glassly && window.__glassly) return;
+  if (window.glassly && window.__host) return;
   var packageName = ${packageNameJson};
   // Resolve window.ReactNativeWebView.postMessage LAZILY, not once at shim-eval.
   // On Android the shim is injected as a WebViewCompat document-start script
@@ -362,7 +362,7 @@ export function buildUiShim(options) {
     /** @internal — packageName for diagnostic logs only. */
     _packageName: packageName,
   };
-  window.__glassly = { recv: recv };
+  window.__host = { recv: recv };
 })();
 `.trim();
 }

package/build/services/uiShim.js.map

@@ -1 +1 @@
-{"version":3,"file":"uiShim.js","sourceRoot":"","sources":["../../src/services/uiShim.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAQH,MAAM,UAAU,WAAW,CAAC,OAAsB;IAChD,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,WAAW,CAAC,CAAA;IAC3D,+DAA+D;IAC/D,sEAAsE;IACtE,yDAAyD;IACzD,OAAO;;;;sBAIa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsUpC,CAAC,IAAI,EAAE,CAAA;AACR,CAAC","sourcesContent":["/**\n * window.glassly — WebView-side bridge to the per-miniapp background JSContext.\n *\n * Injected into every UI WebView via `injectedJavaScriptBeforeContentLoaded`\n * (iOS) or `injectedJavaScriptObject` + a bundler-emitted inline `<script>`\n * (Android, where the `BeforeContentLoaded` prop is documented unreliable\n * per react-native-webview issues #1099 / #1609).\n *\n * The shim:\n *   - Buffers `glassly.send(channel, payload)` calls until `glassly.ready()`\n *     fires + the host acks the channel is open. WebView-side BUFFERS (the\n *     WebView is the short-lived side and shouldn't drop user input).\n *   - Installs `window.__glassly.recv(envelope)` for the host to push\n *     background → WebView messages via `webview.injectJavaScript(...)`.\n *   - Sends `__heartbeat__` every 5s; host considers the WebView gone\n *     after 15s of silence.\n *   - Maintains monotonic seq numbers; the host's per-WebView dedup window\n *     drops replays during reconnect.\n *\n * This file exports a `buildUiShim()` function returning the JS\n * source as a string. The host's UIRouter wraps it inside the\n * existing WebView setup so a single bundler-time string emission covers\n * both platforms.\n *\n * IMPORTANT: the shim runs in the WebView's bare ECMAScript scope before\n * the miniapp's bundle. It must not import anything; the source is one\n * IIFE. The only injected dependencies are\n * `window.ReactNativeWebView.postMessage` (provided by react-native-webview)\n * and (on Android) `window.ReactNativeWebView.injectedObjectJson()`\n * (provided when the host sets `injectedJavaScriptObject`).\n */\n\nexport interface UiShimOptions {\n  packageName: string\n  /** @deprecated No longer used — heartbeat removed since WebViews are foreground-only. */\n  heartbeatIntervalMs?: number\n}\n\nexport function buildUiShim(options: UiShimOptions): string {\n  const packageNameJson = JSON.stringify(options.packageName)\n  // The IIFE assembles a typed `glassly` global plus an internal\n  // `__glassly` for host inbound calls. Quoted strings are JSON-safe so\n  // direct injection inside another JS literal also works.\n  return `\n(function () {\n  if (typeof window === 'undefined') return;\n  if (window.glassly && window.__glassly) return;\n  var packageName = ${packageNameJson};\n  // Resolve window.ReactNativeWebView.postMessage LAZILY, not once at shim-eval.\n  // On Android the shim is injected as a WebViewCompat document-start script\n  // (so it beats the page bundle and the ready handshake can't be raced — see\n  // the react-native-webview patch). But the order in which that document-start\n  // script runs vs. the WebMessageListener that installs\n  // window.ReactNativeWebView is not contractually fixed on Android the way it\n  // is on iOS (postMessageScript is registered before atStartScript there). If\n  // we captured rnPost once and the bridge object wasn't installed yet, every\n  // postMessage — including {type:'ready'} — would be silently dropped and the\n  // splash would hang forever. Resolving per-call means we always pick up the\n  // bridge once it exists, which it reliably does by the time the bundle mounts\n  // and calls glassly.ready().\n  function getRnPost() {\n    try {\n      return window.ReactNativeWebView && typeof window.ReactNativeWebView.postMessage === 'function'\n        ? window.ReactNativeWebView.postMessage.bind(window.ReactNativeWebView)\n        : null;\n    } catch (e) { return null; }\n  }\n\n  // Outbound seq number — purely a log-correlation aid (the host's\n  // router doesn't dedup anymore since reconnect can't happen: one\n  // WebView, foreground-only, destroyed on close → fresh shim on\n  // next open).\n  var outboundSeq = 1;\n  var ready = false;\n  var channelHandlers = Object.create(null);\n  var openHandlers = [];\n  var closeHandlers = [];\n  // Queued glassly.send calls before glassly.ready() acks. FIFO drained\n  // on ack. Buffered so user input (button taps, etc.) isn't dropped\n  // when the WebView mounts faster than the host expects.\n  var outboundQueue = [];\n  // Inbound payloads that arrived before any glassly.on subscriber was\n  // registered for the channel. The background side fires\n  // session.ui.onOpen handlers as soon as the WebView posts {type:'ready'},\n  // and on a fast bridge the resulting ui.send round-trips back before\n  // React useEffects have had a chance to attach listeners. Without\n  // buffering, the very first snapshot (the one a controller pushes from\n  // its ui.onOpen handler to hydrate the fresh UI) is silently dropped.\n  //\n  // Drain policy: the queue for a channel is flushed into the FIRST\n  // glassly.on(channel, ...) subscriber, then discarded. Subsequent\n  // sends with no listener fall back to the old drop-on-floor behaviour\n  // — we don't want a re-subscribe to replay stale state.\n  //\n  // Cap: 32 entries per channel, oldest dropped on overflow. Bounds the\n  // memory cost when a controller pushes to a channel that no UI page\n  // ever subscribes to.\n  var pendingByChannel = Object.create(null);\n  var PENDING_CAP_PER_CHANNEL = 32;\n\n  function postEnvelope(envelope) {\n    var rnPost = getRnPost();\n    if (!rnPost) return;\n    try { rnPost(JSON.stringify(envelope)); } catch (_) {}\n  }\n\n  function send(channel, payload) {\n    var seq = outboundSeq++;\n    var envelope = { type: 'msg', seq: seq, channel: String(channel), payload: payload };\n    if (!ready) {\n      outboundQueue.push(envelope);\n      return;\n    }\n    postEnvelope(envelope);\n  }\n\n  function flushQueue() {\n    while (outboundQueue.length > 0) {\n      postEnvelope(outboundQueue.shift());\n    }\n  }\n\n  // NOTE: console.* tap lives in miniappGlobals.ts (injected alongside\n  // this shim for every UI WebView, two-layer or single-bundle). That\n  // shim posts {payload:{type:\"dev_log\", ...}} envelopes which\n  // LocalMiniappRuntime forwards to the dev sidecar tagged source:\"ui\".\n  // We don't re-wrap here to avoid double-delivery.\n\n  function on(channel, cb) {\n    if (typeof cb !== 'function') return function () {};\n    var list = channelHandlers[channel];\n    var firstSubscriber = !list || list.length === 0;\n    if (!list) { list = []; channelHandlers[channel] = list; }\n    list.push(cb);\n    // Drain any payloads buffered before this channel had a listener.\n    // Only fired on the first subscriber for the channel — a later\n    // re-subscribe (after an unsubscribe) does NOT replay history.\n    if (firstSubscriber) {\n      var pending = pendingByChannel[channel];\n      if (pending) {\n        delete pendingByChannel[channel];\n        for (var i = 0; i < pending.length; i++) {\n          try { cb(pending[i]); } catch (e) {}\n        }\n      }\n    }\n    return function () {\n      var idx = list.indexOf(cb);\n      if (idx >= 0) list.splice(idx, 1);\n    };\n  }\n\n  // ── RPC ─────────────────────────────────────────────────────────────\n  // Outbound RPC: every glassly.request() generates a request id, sends a\n  // 'msg' envelope tagged with requestId, and stashes a one-shot resolver\n  // keyed on the id. The background-side reply is a recv('msg') with the\n  // same channel + requestId; we route it directly to the resolver.\n  //\n  // Cancellation: caller's AbortSignal triggers a 'cancel' envelope to\n  // background and rejects the local promise with a DOM-standard\n  // AbortError. The background side's UI_CANCEL handler aborts the\n  // handler's ctx.signal and drops the reply.\n  var rpcCounter = 0;\n  var rpcInflight = Object.create(null);\n\n  function makeRequestId() {\n    rpcCounter += 1;\n    return 'r' + rpcCounter + '-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 8);\n  }\n\n  function RpcError(message, code, stage, transport) {\n    var e = new Error(message);\n    e.name = 'RpcError';\n    if (code) {\n      try { e.cause = {code: code}; } catch (_) { /* old runtimes */ }\n      e.code = code;\n    }\n    // Diagnostic fields ride as own props so a miniapp can show exactly which\n    // pipeline stage and transport failed, not just a message string.\n    if (stage) e.stage = stage;\n    if (transport) e.transport = transport;\n    return e;\n  }\n\n  function RpcTimeoutError(message) {\n    var e = new Error(message || 'RPC timed out');\n    e.name = 'RpcTimeoutError';\n    return e;\n  }\n\n  function makeAbortError() {\n    var e;\n    try { e = new DOMException('aborted', 'AbortError'); } catch (_) {\n      e = new Error('aborted');\n      e.name = 'AbortError';\n    }\n    return e;\n  }\n\n  function request(channel, payload, options) {\n    var opts = options || {};\n    var signal = opts.signal;\n    var timeoutMs = typeof opts.timeout === 'number' ? opts.timeout : null;\n    var id = makeRequestId();\n\n    return new Promise(function (resolve, reject) {\n      var done = false;\n      var timeoutHandle = null;\n      var abortListener = null;\n\n      function cleanup() {\n        if (done) return;\n        done = true;\n        delete rpcInflight[id];\n        if (timeoutHandle != null) { clearTimeout(timeoutHandle); timeoutHandle = null; }\n        if (signal && abortListener) {\n          try { signal.removeEventListener('abort', abortListener); } catch (_) {}\n        }\n      }\n\n      function settle(envelope) {\n        if (done) return;\n        cleanup();\n        if (envelope && envelope.ok === true) {\n          resolve(envelope.result);\n        } else if (envelope && envelope.ok === false) {\n          reject(RpcError(envelope.error && envelope.error.message || 'RPC failed', envelope.error && envelope.error.code, envelope.error && envelope.error.stage, envelope.error && envelope.error.transport));\n        } else {\n          reject(RpcError('malformed RPC reply'));\n        }\n      }\n\n      rpcInflight[id] = settle;\n\n      if (signal) {\n        if (signal.aborted) {\n          cleanup();\n          reject(makeAbortError());\n          return;\n        }\n        abortListener = function () {\n          if (done) return;\n          cleanup();\n          postEnvelope({type: 'cancel', requestId: id});\n          reject(makeAbortError());\n        };\n        try { signal.addEventListener('abort', abortListener); } catch (_) {}\n      }\n\n      if (timeoutMs != null) {\n        timeoutHandle = setTimeout(function () {\n          if (done) return;\n          cleanup();\n          postEnvelope({type: 'cancel', requestId: id});\n          reject(RpcTimeoutError());\n        }, timeoutMs);\n      }\n\n      var envelope = {type: 'msg', seq: outboundSeq++, channel: String(channel), payload: payload, requestId: id};\n      if (!ready) {\n        outboundQueue.push(envelope);\n        return;\n      }\n      postEnvelope(envelope);\n    });\n  }\n\n  function onOpen(cb) {\n    if (typeof cb !== 'function') return function () {};\n    openHandlers.push(cb);\n    if (ready) {\n      try { cb(); } catch (e) {}\n    }\n    return function () {\n      var idx = openHandlers.indexOf(cb);\n      if (idx >= 0) openHandlers.splice(idx, 1);\n    };\n  }\n\n  function onClose(cb) {\n    if (typeof cb !== 'function') return function () {};\n    closeHandlers.push(cb);\n    return function () {\n      var idx = closeHandlers.indexOf(cb);\n      if (idx >= 0) closeHandlers.splice(idx, 1);\n    };\n  }\n\n  function readyFn() {\n    if (ready) return;\n    ready = true;\n    postEnvelope({ type: 'ready' });\n    flushQueue();\n    for (var i = 0; i < openHandlers.length; i++) {\n      try { openHandlers[i](); } catch (e) {}\n    }\n  }\n\n  function setBackgroundColorFn(color) {\n    // Tells the host what to paint the native WebView layer (the surface\n    // exposed during keyboard push-up / resize animations, which page CSS\n    // cannot reach). Host validates and falls back to its theme background.\n    if (typeof color !== 'string' || !color) return;\n    postEnvelope({ type: 'set_background', color: color });\n  }\n\n  function fireChannel(channel, payload) {\n    var list = channelHandlers[channel];\n    if (!list || list.length === 0) {\n      // No subscriber yet — stash for the first glassly.on(channel, ...).\n      // Bounded FIFO: drop the oldest when capped so a stuck channel\n      // can't grow unbounded.\n      var q = pendingByChannel[channel];\n      if (!q) { q = []; pendingByChannel[channel] = q; }\n      q.push(payload);\n      if (q.length > PENDING_CAP_PER_CHANNEL) q.shift();\n      return;\n    }\n    for (var i = 0; i < list.length; i++) {\n      try { list[i](payload); } catch (e) {}\n    }\n  }\n\n  function recv(envelope) {\n    if (!envelope || typeof envelope !== 'object') return;\n    var type = envelope.type;\n    if (type === 'msg' && typeof envelope.channel === 'string') {\n      // RPC frames carry a requestId; broadcast frames don't. Treat them\n      // as disjoint — never fall through from RPC to broadcast. An orphan\n      // RPC reply (caller already aborted/timed out) is silently dropped.\n      if (typeof envelope.requestId === 'string') {\n        var settle = rpcInflight[envelope.requestId];\n        if (settle) settle(envelope.payload);\n        return;\n      }\n      fireChannel(envelope.channel, envelope.payload);\n      return;\n    }\n    if (type === 'open') {\n      for (var j = 0; j < openHandlers.length; j++) {\n        try { openHandlers[j](); } catch (e) {}\n      }\n      return;\n    }\n    if (type === 'close') {\n      for (var k = 0; k < closeHandlers.length; k++) {\n        try { closeHandlers[k](); } catch (e) {}\n      }\n      return;\n    }\n    if (type === 'cancel' && typeof envelope.requestId === 'string') {\n      // Background-side cancel (reserved; currently unused). If we had a\n      // future bidirectional RPC this would abort an in-flight UI handler.\n      return;\n    }\n    if (type === 'ack') {\n      return;\n    }\n  }\n\n  window.glassly = {\n    send: send,\n    on: on,\n    request: request,\n    onOpen: onOpen,\n    onClose: onClose,\n    ready: readyFn,\n    setBackgroundColor: setBackgroundColorFn,\n    /** @internal — packageName for diagnostic logs only. */\n    _packageName: packageName,\n  };\n  window.__glassly = { recv: recv };\n})();\n`.trim()\n}\n"]}
+{"version":3,"file":"uiShim.js","sourceRoot":"","sources":["../../src/services/uiShim.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAQH,MAAM,UAAU,WAAW,CAAC,OAAsB;IAChD,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,WAAW,CAAC,CAAA;IAC3D,+DAA+D;IAC/D,mEAAmE;IACnE,yDAAyD;IACzD,OAAO;;;;sBAIa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsUpC,CAAC,IAAI,EAAE,CAAA;AACR,CAAC","sourcesContent":["/**\n * window.glassly — WebView-side bridge to the per-miniapp background JSContext.\n *\n * Injected into every UI WebView via `injectedJavaScriptBeforeContentLoaded`\n * (iOS) or `injectedJavaScriptObject` + a bundler-emitted inline `<script>`\n * (Android, where the `BeforeContentLoaded` prop is documented unreliable\n * per react-native-webview issues #1099 / #1609).\n *\n * The shim:\n *   - Buffers `glassly.send(channel, payload)` calls until `glassly.ready()`\n *     fires + the host acks the channel is open. WebView-side BUFFERS (the\n *     WebView is the short-lived side and shouldn't drop user input).\n *   - Installs `window.__host.recv(envelope)` for the host to push\n *     background → WebView messages via `webview.injectJavaScript(...)`.\n *   - Sends `__heartbeat__` every 5s; host considers the WebView gone\n *     after 15s of silence.\n *   - Maintains monotonic seq numbers; the host's per-WebView dedup window\n *     drops replays during reconnect.\n *\n * This file exports a `buildUiShim()` function returning the JS\n * source as a string. The host's UIRouter wraps it inside the\n * existing WebView setup so a single bundler-time string emission covers\n * both platforms.\n *\n * IMPORTANT: the shim runs in the WebView's bare ECMAScript scope before\n * the miniapp's bundle. It must not import anything; the source is one\n * IIFE. The only injected dependencies are\n * `window.ReactNativeWebView.postMessage` (provided by react-native-webview)\n * and (on Android) `window.ReactNativeWebView.injectedObjectJson()`\n * (provided when the host sets `injectedJavaScriptObject`).\n */\n\nexport interface UiShimOptions {\n  packageName: string\n  /** @deprecated No longer used — heartbeat removed since WebViews are foreground-only. */\n  heartbeatIntervalMs?: number\n}\n\nexport function buildUiShim(options: UiShimOptions): string {\n  const packageNameJson = JSON.stringify(options.packageName)\n  // The IIFE assembles a typed `glassly` global plus an internal\n  // `__host` for host inbound calls. Quoted strings are JSON-safe so\n  // direct injection inside another JS literal also works.\n  return `\n(function () {\n  if (typeof window === 'undefined') return;\n  if (window.glassly && window.__host) return;\n  var packageName = ${packageNameJson};\n  // Resolve window.ReactNativeWebView.postMessage LAZILY, not once at shim-eval.\n  // On Android the shim is injected as a WebViewCompat document-start script\n  // (so it beats the page bundle and the ready handshake can't be raced — see\n  // the react-native-webview patch). But the order in which that document-start\n  // script runs vs. the WebMessageListener that installs\n  // window.ReactNativeWebView is not contractually fixed on Android the way it\n  // is on iOS (postMessageScript is registered before atStartScript there). If\n  // we captured rnPost once and the bridge object wasn't installed yet, every\n  // postMessage — including {type:'ready'} — would be silently dropped and the\n  // splash would hang forever. Resolving per-call means we always pick up the\n  // bridge once it exists, which it reliably does by the time the bundle mounts\n  // and calls glassly.ready().\n  function getRnPost() {\n    try {\n      return window.ReactNativeWebView && typeof window.ReactNativeWebView.postMessage === 'function'\n        ? window.ReactNativeWebView.postMessage.bind(window.ReactNativeWebView)\n        : null;\n    } catch (e) { return null; }\n  }\n\n  // Outbound seq number — purely a log-correlation aid (the host's\n  // router doesn't dedup anymore since reconnect can't happen: one\n  // WebView, foreground-only, destroyed on close → fresh shim on\n  // next open).\n  var outboundSeq = 1;\n  var ready = false;\n  var channelHandlers = Object.create(null);\n  var openHandlers = [];\n  var closeHandlers = [];\n  // Queued glassly.send calls before glassly.ready() acks. FIFO drained\n  // on ack. Buffered so user input (button taps, etc.) isn't dropped\n  // when the WebView mounts faster than the host expects.\n  var outboundQueue = [];\n  // Inbound payloads that arrived before any glassly.on subscriber was\n  // registered for the channel. The background side fires\n  // session.ui.onOpen handlers as soon as the WebView posts {type:'ready'},\n  // and on a fast bridge the resulting ui.send round-trips back before\n  // React useEffects have had a chance to attach listeners. Without\n  // buffering, the very first snapshot (the one a controller pushes from\n  // its ui.onOpen handler to hydrate the fresh UI) is silently dropped.\n  //\n  // Drain policy: the queue for a channel is flushed into the FIRST\n  // glassly.on(channel, ...) subscriber, then discarded. Subsequent\n  // sends with no listener fall back to the old drop-on-floor behaviour\n  // — we don't want a re-subscribe to replay stale state.\n  //\n  // Cap: 32 entries per channel, oldest dropped on overflow. Bounds the\n  // memory cost when a controller pushes to a channel that no UI page\n  // ever subscribes to.\n  var pendingByChannel = Object.create(null);\n  var PENDING_CAP_PER_CHANNEL = 32;\n\n  function postEnvelope(envelope) {\n    var rnPost = getRnPost();\n    if (!rnPost) return;\n    try { rnPost(JSON.stringify(envelope)); } catch (_) {}\n  }\n\n  function send(channel, payload) {\n    var seq = outboundSeq++;\n    var envelope = { type: 'msg', seq: seq, channel: String(channel), payload: payload };\n    if (!ready) {\n      outboundQueue.push(envelope);\n      return;\n    }\n    postEnvelope(envelope);\n  }\n\n  function flushQueue() {\n    while (outboundQueue.length > 0) {\n      postEnvelope(outboundQueue.shift());\n    }\n  }\n\n  // NOTE: console.* tap lives in miniappGlobals.ts (injected alongside\n  // this shim for every UI WebView, two-layer or single-bundle). That\n  // shim posts {payload:{type:\"dev_log\", ...}} envelopes which\n  // LocalMiniappRuntime forwards to the dev sidecar tagged source:\"ui\".\n  // We don't re-wrap here to avoid double-delivery.\n\n  function on(channel, cb) {\n    if (typeof cb !== 'function') return function () {};\n    var list = channelHandlers[channel];\n    var firstSubscriber = !list || list.length === 0;\n    if (!list) { list = []; channelHandlers[channel] = list; }\n    list.push(cb);\n    // Drain any payloads buffered before this channel had a listener.\n    // Only fired on the first subscriber for the channel — a later\n    // re-subscribe (after an unsubscribe) does NOT replay history.\n    if (firstSubscriber) {\n      var pending = pendingByChannel[channel];\n      if (pending) {\n        delete pendingByChannel[channel];\n        for (var i = 0; i < pending.length; i++) {\n          try { cb(pending[i]); } catch (e) {}\n        }\n      }\n    }\n    return function () {\n      var idx = list.indexOf(cb);\n      if (idx >= 0) list.splice(idx, 1);\n    };\n  }\n\n  // ── RPC ─────────────────────────────────────────────────────────────\n  // Outbound RPC: every glassly.request() generates a request id, sends a\n  // 'msg' envelope tagged with requestId, and stashes a one-shot resolver\n  // keyed on the id. The background-side reply is a recv('msg') with the\n  // same channel + requestId; we route it directly to the resolver.\n  //\n  // Cancellation: caller's AbortSignal triggers a 'cancel' envelope to\n  // background and rejects the local promise with a DOM-standard\n  // AbortError. The background side's UI_CANCEL handler aborts the\n  // handler's ctx.signal and drops the reply.\n  var rpcCounter = 0;\n  var rpcInflight = Object.create(null);\n\n  function makeRequestId() {\n    rpcCounter += 1;\n    return 'r' + rpcCounter + '-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 8);\n  }\n\n  function RpcError(message, code, stage, transport) {\n    var e = new Error(message);\n    e.name = 'RpcError';\n    if (code) {\n      try { e.cause = {code: code}; } catch (_) { /* old runtimes */ }\n      e.code = code;\n    }\n    // Diagnostic fields ride as own props so a miniapp can show exactly which\n    // pipeline stage and transport failed, not just a message string.\n    if (stage) e.stage = stage;\n    if (transport) e.transport = transport;\n    return e;\n  }\n\n  function RpcTimeoutError(message) {\n    var e = new Error(message || 'RPC timed out');\n    e.name = 'RpcTimeoutError';\n    return e;\n  }\n\n  function makeAbortError() {\n    var e;\n    try { e = new DOMException('aborted', 'AbortError'); } catch (_) {\n      e = new Error('aborted');\n      e.name = 'AbortError';\n    }\n    return e;\n  }\n\n  function request(channel, payload, options) {\n    var opts = options || {};\n    var signal = opts.signal;\n    var timeoutMs = typeof opts.timeout === 'number' ? opts.timeout : null;\n    var id = makeRequestId();\n\n    return new Promise(function (resolve, reject) {\n      var done = false;\n      var timeoutHandle = null;\n      var abortListener = null;\n\n      function cleanup() {\n        if (done) return;\n        done = true;\n        delete rpcInflight[id];\n        if (timeoutHandle != null) { clearTimeout(timeoutHandle); timeoutHandle = null; }\n        if (signal && abortListener) {\n          try { signal.removeEventListener('abort', abortListener); } catch (_) {}\n        }\n      }\n\n      function settle(envelope) {\n        if (done) return;\n        cleanup();\n        if (envelope && envelope.ok === true) {\n          resolve(envelope.result);\n        } else if (envelope && envelope.ok === false) {\n          reject(RpcError(envelope.error && envelope.error.message || 'RPC failed', envelope.error && envelope.error.code, envelope.error && envelope.error.stage, envelope.error && envelope.error.transport));\n        } else {\n          reject(RpcError('malformed RPC reply'));\n        }\n      }\n\n      rpcInflight[id] = settle;\n\n      if (signal) {\n        if (signal.aborted) {\n          cleanup();\n          reject(makeAbortError());\n          return;\n        }\n        abortListener = function () {\n          if (done) return;\n          cleanup();\n          postEnvelope({type: 'cancel', requestId: id});\n          reject(makeAbortError());\n        };\n        try { signal.addEventListener('abort', abortListener); } catch (_) {}\n      }\n\n      if (timeoutMs != null) {\n        timeoutHandle = setTimeout(function () {\n          if (done) return;\n          cleanup();\n          postEnvelope({type: 'cancel', requestId: id});\n          reject(RpcTimeoutError());\n        }, timeoutMs);\n      }\n\n      var envelope = {type: 'msg', seq: outboundSeq++, channel: String(channel), payload: payload, requestId: id};\n      if (!ready) {\n        outboundQueue.push(envelope);\n        return;\n      }\n      postEnvelope(envelope);\n    });\n  }\n\n  function onOpen(cb) {\n    if (typeof cb !== 'function') return function () {};\n    openHandlers.push(cb);\n    if (ready) {\n      try { cb(); } catch (e) {}\n    }\n    return function () {\n      var idx = openHandlers.indexOf(cb);\n      if (idx >= 0) openHandlers.splice(idx, 1);\n    };\n  }\n\n  function onClose(cb) {\n    if (typeof cb !== 'function') return function () {};\n    closeHandlers.push(cb);\n    return function () {\n      var idx = closeHandlers.indexOf(cb);\n      if (idx >= 0) closeHandlers.splice(idx, 1);\n    };\n  }\n\n  function readyFn() {\n    if (ready) return;\n    ready = true;\n    postEnvelope({ type: 'ready' });\n    flushQueue();\n    for (var i = 0; i < openHandlers.length; i++) {\n      try { openHandlers[i](); } catch (e) {}\n    }\n  }\n\n  function setBackgroundColorFn(color) {\n    // Tells the host what to paint the native WebView layer (the surface\n    // exposed during keyboard push-up / resize animations, which page CSS\n    // cannot reach). Host validates and falls back to its theme background.\n    if (typeof color !== 'string' || !color) return;\n    postEnvelope({ type: 'set_background', color: color });\n  }\n\n  function fireChannel(channel, payload) {\n    var list = channelHandlers[channel];\n    if (!list || list.length === 0) {\n      // No subscriber yet — stash for the first glassly.on(channel, ...).\n      // Bounded FIFO: drop the oldest when capped so a stuck channel\n      // can't grow unbounded.\n      var q = pendingByChannel[channel];\n      if (!q) { q = []; pendingByChannel[channel] = q; }\n      q.push(payload);\n      if (q.length > PENDING_CAP_PER_CHANNEL) q.shift();\n      return;\n    }\n    for (var i = 0; i < list.length; i++) {\n      try { list[i](payload); } catch (e) {}\n    }\n  }\n\n  function recv(envelope) {\n    if (!envelope || typeof envelope !== 'object') return;\n    var type = envelope.type;\n    if (type === 'msg' && typeof envelope.channel === 'string') {\n      // RPC frames carry a requestId; broadcast frames don't. Treat them\n      // as disjoint — never fall through from RPC to broadcast. An orphan\n      // RPC reply (caller already aborted/timed out) is silently dropped.\n      if (typeof envelope.requestId === 'string') {\n        var settle = rpcInflight[envelope.requestId];\n        if (settle) settle(envelope.payload);\n        return;\n      }\n      fireChannel(envelope.channel, envelope.payload);\n      return;\n    }\n    if (type === 'open') {\n      for (var j = 0; j < openHandlers.length; j++) {\n        try { openHandlers[j](); } catch (e) {}\n      }\n      return;\n    }\n    if (type === 'close') {\n      for (var k = 0; k < closeHandlers.length; k++) {\n        try { closeHandlers[k](); } catch (e) {}\n      }\n      return;\n    }\n    if (type === 'cancel' && typeof envelope.requestId === 'string') {\n      // Background-side cancel (reserved; currently unused). If we had a\n      // future bidirectional RPC this would abort an in-flight UI handler.\n      return;\n    }\n    if (type === 'ack') {\n      return;\n    }\n  }\n\n  window.glassly = {\n    send: send,\n    on: on,\n    request: request,\n    onOpen: onOpen,\n    onClose: onClose,\n    ready: readyFn,\n    setBackgroundColor: setBackgroundColorFn,\n    /** @internal — packageName for diagnostic logs only. */\n    _packageName: packageName,\n  };\n  window.__host = { recv: recv };\n})();\n`.trim()\n}\n"]}

package/build/stores/appVisibility.d.ts

@@ -1,3 +1,31 @@
 /** Combine registry-enforced visibility with the user's home-screen choice. */
 export declare const resolveHiddenStatus: (registryHidden: boolean, userHidden: boolean) => boolean;
+/**
+ * Miniapps that start off the primary home screen. They stay listed under
+ * "view all apps", where "Add to Home" saves an explicit choice that wins
+ * over this default from then on.
+ */
+export declare const DEFAULT_HIDDEN_PACKAGES: ReadonlySet<string>;
+/** The home-screen visibility of an app the user has never hidden or added. */
+export declare const defaultHiddenStatus: (packageName: string) => boolean;
+/**
+ * Miniapps that exist only for developers: the Miniapp Developer launcher and
+ * the bundled sample/test miniapps. They are projected into the app store
+ * only while the `dev_tools` setting is on; off, they are absent from every
+ * launcher surface (home, all apps, glasses menu, AI listing), not merely
+ * hidden from the primary home screen.
+ */
+export declare const DEV_TOOLS_PACKAGES: ReadonlySet<string>;
+/** True when the app is dev-only and developer tools are off. */
+export declare const isGatedByDevTools: (packageName: string, devToolsEnabled: boolean) => boolean;
+/**
+ * Miniapps that unlock once a real pair of glasses has been paired on this
+ * phone (`has_paired_glasses`, latched by PairedGlassesLatch and never
+ * cleared, so forgetting the glasses keeps them). Developer tools open them
+ * early. Until either, they are absent from every launcher surface like the
+ * dev-only set above.
+ */
+export declare const PAIRED_GLASSES_PACKAGES: ReadonlySet<string>;
+/** True when the app waits on a pairing that hasn't happened and dev tools are off. */
+export declare const isGatedUntilPaired: (packageName: string, devToolsEnabled: boolean, hasPairedGlasses: boolean) => boolean;
 //# sourceMappingURL=appVisibility.d.ts.map

package/build/stores/appVisibility.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"appVisibility.d.ts","sourceRoot":"","sources":["../../src/stores/appVisibility.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,eAAO,MAAM,mBAAmB,GAAI,gBAAgB,OAAO,EAAE,YAAY,OAAO,KAAG,OACrD,CAAA"}
+{"version":3,"file":"appVisibility.d.ts","sourceRoot":"","sources":["../../src/stores/appVisibility.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,eAAO,MAAM,mBAAmB,GAAI,gBAAgB,OAAO,EAAE,YAAY,OAAO,KAAG,OACrD,CAAA;AAE9B;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,WAAW,CAAC,MAAM,CAA2D,CAAA;AAEnH,+EAA+E;AAC/E,eAAO,MAAM,mBAAmB,GAAI,aAAa,MAAM,KAAG,OAAmD,CAAA;AAE7G;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC,MAAM,CAMjD,CAAA;AAEF,iEAAiE;AACjE,eAAO,MAAM,iBAAiB,GAAI,aAAa,MAAM,EAAE,iBAAiB,OAAO,KAAG,OACzB,CAAA;AAEzD;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,EAAE,WAAW,CAAC,MAAM,CAAkC,CAAA;AAE1F,uFAAuF;AACvF,eAAO,MAAM,kBAAkB,GAC7B,aAAa,MAAM,EACnB,iBAAiB,OAAO,EACxB,kBAAkB,OAAO,KACxB,OAA4F,CAAA"}

package/build/stores/appVisibility.js

@@ -1,3 +1,37 @@
 /** Combine registry-enforced visibility with the user's home-screen choice. */
 export const resolveHiddenStatus = (registryHidden, userHidden) => registryHidden || userHidden;
+/**
+ * Miniapps that start off the primary home screen. They stay listed under
+ * "view all apps", where "Add to Home" saves an explicit choice that wins
+ * over this default from then on.
+ */
+export const DEFAULT_HIDDEN_PACKAGES = new Set(["com.glassly.camera", "com.glassly.recorder"]);
+/** The home-screen visibility of an app the user has never hidden or added. */
+export const defaultHiddenStatus = (packageName) => DEFAULT_HIDDEN_PACKAGES.has(packageName);
+/**
+ * Miniapps that exist only for developers: the Miniapp Developer launcher and
+ * the bundled sample/test miniapps. They are projected into the app store
+ * only while the `dev_tools` setting is on; off, they are absent from every
+ * launcher surface (home, all apps, glasses menu, AI listing), not merely
+ * hidden from the primary home screen.
+ */
+export const DEV_TOOLS_PACKAGES = new Set([
+    "com.glassly.miniappdev",
+    "com.glassly.example",
+    "com.glassly.tetris",
+    "com.glassly.compass",
+    "com.glassly.showcase",
+]);
+/** True when the app is dev-only and developer tools are off. */
+export const isGatedByDevTools = (packageName, devToolsEnabled) => !devToolsEnabled && DEV_TOOLS_PACKAGES.has(packageName);
+/**
+ * Miniapps that unlock once a real pair of glasses has been paired on this
+ * phone (`has_paired_glasses`, latched by PairedGlassesLatch and never
+ * cleared, so forgetting the glasses keeps them). Developer tools open them
+ * early. Until either, they are absent from every launcher surface like the
+ * dev-only set above.
+ */
+export const PAIRED_GLASSES_PACKAGES = new Set(["com.glassly.store"]);
+/** True when the app waits on a pairing that hasn't happened and dev tools are off. */
+export const isGatedUntilPaired = (packageName, devToolsEnabled, hasPairedGlasses) => !devToolsEnabled && !hasPairedGlasses && PAIRED_GLASSES_PACKAGES.has(packageName);
 //# sourceMappingURL=appVisibility.js.map

package/build/stores/appVisibility.js.map

@@ -1 +1 @@
-{"version":3,"file":"appVisibility.js","sourceRoot":"","sources":["../../src/stores/appVisibility.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,cAAuB,EAAE,UAAmB,EAAW,EAAE,CAC3F,cAAc,IAAI,UAAU,CAAA","sourcesContent":["/** Combine registry-enforced visibility with the user's home-screen choice. */\nexport const resolveHiddenStatus = (registryHidden: boolean, userHidden: boolean): boolean =>\n  registryHidden || userHidden\n"]}
+{"version":3,"file":"appVisibility.js","sourceRoot":"","sources":["../../src/stores/appVisibility.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,cAAuB,EAAE,UAAmB,EAAW,EAAE,CAC3F,cAAc,IAAI,UAAU,CAAA;AAE9B;;;;GAIG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAwB,IAAI,GAAG,CAAC,CAAC,oBAAoB,EAAE,sBAAsB,CAAC,CAAC,CAAA;AAEnH,+EAA+E;AAC/E,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,WAAmB,EAAW,EAAE,CAAC,uBAAuB,CAAC,GAAG,CAAC,WAAW,CAAC,CAAA;AAE7G;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAwB,IAAI,GAAG,CAAC;IAC7D,wBAAwB;IACxB,qBAAqB;IACrB,oBAAoB;IACpB,qBAAqB;IACrB,sBAAsB;CACvB,CAAC,CAAA;AAEF,iEAAiE;AACjE,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,WAAmB,EAAE,eAAwB,EAAW,EAAE,CAC1F,CAAC,eAAe,IAAI,kBAAkB,CAAC,GAAG,CAAC,WAAW,CAAC,CAAA;AAEzD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAwB,IAAI,GAAG,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAA;AAE1F,uFAAuF;AACvF,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,WAAmB,EACnB,eAAwB,EACxB,gBAAyB,EAChB,EAAE,CAAC,CAAC,eAAe,IAAI,CAAC,gBAAgB,IAAI,uBAAuB,CAAC,GAAG,CAAC,WAAW,CAAC,CAAA","sourcesContent":["/** Combine registry-enforced visibility with the user's home-screen choice. */\nexport const resolveHiddenStatus = (registryHidden: boolean, userHidden: boolean): boolean =>\n  registryHidden || userHidden\n\n/**\n * Miniapps that start off the primary home screen. They stay listed under\n * \"view all apps\", where \"Add to Home\" saves an explicit choice that wins\n * over this default from then on.\n */\nexport const DEFAULT_HIDDEN_PACKAGES: ReadonlySet<string> = new Set([\"com.glassly.camera\", \"com.glassly.recorder\"])\n\n/** The home-screen visibility of an app the user has never hidden or added. */\nexport const defaultHiddenStatus = (packageName: string): boolean => DEFAULT_HIDDEN_PACKAGES.has(packageName)\n\n/**\n * Miniapps that exist only for developers: the Miniapp Developer launcher and\n * the bundled sample/test miniapps. They are projected into the app store\n * only while the `dev_tools` setting is on; off, they are absent from every\n * launcher surface (home, all apps, glasses menu, AI listing), not merely\n * hidden from the primary home screen.\n */\nexport const DEV_TOOLS_PACKAGES: ReadonlySet<string> = new Set([\n  \"com.glassly.miniappdev\",\n  \"com.glassly.example\",\n  \"com.glassly.tetris\",\n  \"com.glassly.compass\",\n  \"com.glassly.showcase\",\n])\n\n/** True when the app is dev-only and developer tools are off. */\nexport const isGatedByDevTools = (packageName: string, devToolsEnabled: boolean): boolean =>\n  !devToolsEnabled && DEV_TOOLS_PACKAGES.has(packageName)\n\n/**\n * Miniapps that unlock once a real pair of glasses has been paired on this\n * phone (`has_paired_glasses`, latched by PairedGlassesLatch and never\n * cleared, so forgetting the glasses keeps them). Developer tools open them\n * early. Until either, they are absent from every launcher surface like the\n * dev-only set above.\n */\nexport const PAIRED_GLASSES_PACKAGES: ReadonlySet<string> = new Set([\"com.glassly.store\"])\n\n/** True when the app waits on a pairing that hasn't happened and dev tools are off. */\nexport const isGatedUntilPaired = (\n  packageName: string,\n  devToolsEnabled: boolean,\n  hasPairedGlasses: boolean,\n): boolean => !devToolsEnabled && !hasPairedGlasses && PAIRED_GLASSES_PACKAGES.has(packageName)\n"]}

package/build/stores/apps.d.ts

@@ -11,8 +11,11 @@
  */
 import { AsyncResult, Result } from "typesafe-ts";
 import type { ClientApp } from "../types/applet";
+import type { MiniappLaunchSource } from "@glassly/miniapp";
 export interface StartOptions {
     skipNavigation?: boolean;
+    /** Reported to the miniapp on connect. Defaults to "phone". */
+    launchSource?: MiniappLaunchSource;
 }
 export interface AppStoreHooks {
     /**
@@ -60,6 +63,13 @@ interface AppStatusState {
     saveScreenshot: (packageName: string, screenshot: string) => Promise<void>;
     setHiddenStatus: (packageName: string, status: boolean) => void;
     getHiddenStatus: (packageName: string) => boolean;
+    /**
+     * Mark a miniapp persistent: it starts at launch and only stops from the
+     * app switcher's persistent pill (its card cannot be swiped away and the
+     * capsule close minimizes it). Turning it on starts the app; turning it
+     * off leaves it running. Persists the wearer's choice beside the hidden flag.
+     */
+    setPersistent: (packageName: string, status: boolean) => Promise<void>;
     /** Replace the whole apps array. Hosts use this when their extra source changes. */
     setApps: (apps: ClientApp[]) => void;
 }
@@ -85,7 +95,10 @@ export declare const useInstall: () => (url: string, opts?: {
     versionOverride?: string;
 }) => AsyncResult<void, Error>;
 export declare const useUninstall: () => (packageName: string, version?: string) => AsyncResult<void, Error>;
+/** Every running app; each one has a card in the app switcher tray. */
 export declare const useActiveApps: () => ClientApp[];
+/** Persistent apps whose background task is running, card or no card. */
+export declare const useRunningPersistentApps: () => ClientApp[];
 export declare const useActiveBackgroundApps: () => ClientApp[];
 export declare const useBackgroundApps: () => {
     active: ClientApp[];