@glassly/engine 0.3.0-beta.487 → 0.3.0-dev.460

package/src/services/pages/overlayApps.ts

@@ -1,71 +1,51 @@
 /**
- * The overlay app: the connected miniapp that holds the dashboard role
- * (ADR-0009). It alone may take the overlay slot through
- * `session.display.showView("dashboard")` and has "dashboard" in its
- * `display.views` capability while the glasses are eligible. The runtime
- * records each dashboard miniapp (manifest type "dashboard") as it connects
- * and stops, and who holds the role; the engine never knows what a dashboard
- * draws. Kept free of imports so the runtime and the notification policy can
- * both read it without a cycle.
+ * The overlay apps: the connected miniapps whose manifest type is
+ * "system_dashboard" (the dashboard). 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"
 
-/** Connected dashboard miniapps, role or not. */
-const connected = new Set<string>()
-/** Connected dashboards listening to the phone's notifications. */
-const listening = new Set<string>()
-let active: string | null = null
+const apps = new Set<string>()
+/** Overlay apps listening to the phone's notifications: something on the glasses presents them. */
+const viewers = new Set<string>()
 const listeners = new Set<() => void>()
 
-/** `packageName` holds the dashboard role and is connected. */
 export function isOverlayApp(packageName: string): boolean {
-  return packageName === active && connected.has(packageName)
-}
-
-/** `packageName` is a connected dashboard miniapp, whether or not it holds the role. */
-export function isDashboardApp(packageName: string): boolean {
-  return connected.has(packageName)
+  return apps.has(packageName)
 }
 
 export function overlayApps(): readonly string[] {
-  return active !== null && connected.has(active) ? [active] : []
-}
-
-/** The package that holds the dashboard role, connected or not. */
-export function activeDashboard(): string | null {
-  return active
-}
-
-export function setActiveDashboard(packageName: string | null): void {
-  if (active === packageName) return
-  active = packageName
-  emit()
+  return [...apps]
 }
 
-export function addDashboardApp(packageName: string): void {
-  if (connected.has(packageName)) return
-  connected.add(packageName)
+export function addOverlayApp(packageName: string): void {
+  if (apps.has(packageName)) return
+  apps.add(packageName)
   emit()
 }
 
-export function removeDashboardApp(packageName: string): void {
-  listening.delete(packageName)
-  if (!connected.delete(packageName)) return
+export function removeOverlayApp(packageName: string): void {
+  viewers.delete(packageName)
+  if (!apps.delete(packageName)) return
   emit()
 }
 
-/** Record whether a dashboard subscribes to phone notifications (the overlay app is the viewer while it does). */
-export function setOverlayViewer(packageName: string, subscribed: boolean): void {
-  const was = overlayViewerRunning()
-  if (subscribed && connected.has(packageName)) listening.add(packageName)
-  else listening.delete(packageName)
-  if (was !== overlayViewerRunning()) emit()
+/** Record whether an overlay app subscribes to phone notifications (it is a viewer while it does). */
+export function setOverlayViewer(packageName: string, listening: boolean): void {
+  const was = viewers.has(packageName)
+  if (listening && apps.has(packageName)) viewers.add(packageName)
+  else viewers.delete(packageName)
+  if (was !== viewers.has(packageName)) emit()
 }
 
-/** The overlay app presents phone notifications. */
+/** An overlay app that presents phone notifications is running. */
 export function overlayViewerRunning(): boolean {
-  return active !== null && connected.has(active) && listening.has(active)
+  return viewers.size > 0
 }
 
 export function onOverlayAppsChange(listener: () => void): () => void {
@@ -75,9 +55,9 @@ export function onOverlayAppsChange(listener: () => void): () => void {
   }
 }
 
-/** The views `packageName` may draw: main for everyone, the dashboard for the overlay app on eligible glasses. */
+/** The views `packageName` may draw: main for everyone, the dashboard for overlay apps on eligible glasses. */
 export function displayViewsFor(packageName: string, eligible: boolean): DisplayView[] {
-  return isOverlayApp(packageName) && eligible ? ["main", "dashboard"] : ["main"]
+  return apps.has(packageName) && eligible ? ["main", "dashboard"] : ["main"]
 }
 
 function emit(): void {
@@ -86,7 +66,6 @@ function emit(): void {
 
 /** Tests only. */
 export function _resetOverlayAppsForTest(): void {
-  connected.clear()
-  listening.clear()
-  active = null
+  apps.clear()
+  viewers.clear()
 }

package/src/services/settingsBridge.ts

@@ -1,23 +1,28 @@
 /**
  * The settings bridge's vocabulary (session.settings): which engine settings
- * a miniapp with the PLATFORM_SETTINGS permission 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.
+ * 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.
  *
- * A dashboard miniapp is the usual consumer: it edits the notification and
- * glasses-menu keys the phone's settings screens used to, through the store,
- * so persistence, server sync and the Bluetooth sync of `menu_apps` behave as
- * if a phone screen wrote them. A dashboard's own look is not here; it keeps
- * that in its storage.
+ * 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 permitted app may do to each. */
+/** Stored settings the bridge serves, by key, with what a system app may do to each. */
 export const SETTINGS_BRIDGE_KEYS: Readonly<Record<string, SettingsBridgeAccess>> = {
   // 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",
@@ -33,23 +38,18 @@ export const SETTINGS_BRIDGE_KEYS: Readonly<Record<string, SettingsBridgeAccess>
 
 /**
  * Read-only keys the engine computes: whether the wearer can see the phone,
- * whether the foreground miniapp is drawing on the glasses, the ring's
- * battery, and the package that holds the dashboard role (null for nobody).
- * They change on their own clocks; the runtime pushes them like stored keys.
+ * whether the foreground miniapp is drawing on the glasses, and the ring's
+ * battery. They change on their own clocks; the runtime pushes them like
+ * stored keys.
  */
-export const DERIVED_SETTINGS_KEYS = [
-  "phone_active",
-  "foreground_app_on_screen",
-  "ring_battery",
-  "active_dashboard",
-] as const
+export const DERIVED_SETTINGS_KEYS = ["phone_active", "foreground_app_on_screen", "ring_battery"] as const
 export type DerivedSettingsKey = (typeof DERIVED_SETTINGS_KEYS)[number]
 
 export function isDerivedSettingsKey(key: string): key is DerivedSettingsKey {
   return (DERIVED_SETTINGS_KEYS as readonly string[]).includes(key)
 }
 
-/** What a permitted app may do with `key`, or null when the bridge does not serve it. */
+/** What a system app may do with `key`, or null when the bridge does not serve it. */
 export function settingsBridgeAccess(key: string): SettingsBridgeAccess | null {
   if (isDerivedSettingsKey(key)) return "read"
   return SETTINGS_BRIDGE_KEYS[key] ?? null

package/src/stores/appVisibility.ts

@@ -1,7 +1,3 @@
-/** Host built-in phone pages and dashboard-type miniapps: never launched from a glasses menu. */
-export const isSystemMiniapp = (app: {offline: boolean; type: string}): boolean =>
-  app.offline || app.type === "dashboard"
-
 /** Combine registry-enforced visibility with the user's home-screen choice. */
 export const resolveHiddenStatus = (registryHidden: boolean, userHidden: boolean): boolean =>
   registryHidden || userHidden

package/src/stores/apps.ts

@@ -25,9 +25,9 @@ import {islandNotifications} from "../services/NotificationsEmitter"
 import sttModelManager from "../services/STTModelManager"
 import {miniappLauncher} from "../services/MiniappLauncher"
 import {miniappRunningRegistry} from "../services/MiniappRunningRegistry"
-import {activeDashboardAmong, resolveActiveDashboard} from "../services/pages/activeDashboard"
 import {defaultHiddenStatus, isGatedByDevTools, isGatedUntilPaired, resolveHiddenStatus} from "./appVisibility"
 import {SETTINGS, useSettingsStore} from "./settings"
+import {PermissionFeatures, permissions} from "../facades/permissions"
 import BluetoothSdk from "@glassly/bluetooth-sdk"
 import type {MiniappLaunchSource} from "@glassly/miniapp"
 
@@ -102,7 +102,6 @@ interface AppStatusState {
    * off leaves it running. Persists the wearer's choice beside the hidden flag.
    */
   setAlwaysOn: (packageName: string, status: boolean) => Promise<void>
-  setActiveDashboard: (packageName: string) => Promise<void>
   /** Replace the whole apps array. Hosts use this when their extra source changes. */
   setApps: (apps: ClientApp[]) => void
 }
@@ -379,6 +378,11 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
       return true
     }
 
+    // The phone mic is asked for here, at first use, not during pairing: the
+    // OS prompt lands over the app that needs it. The facade returns at once
+    // when the answer is already known, so this only ever prompts once.
+    if (declaresMicrophone(app)) await permissions.request(PermissionFeatures.MICROPHONE)
+
     // Foreground-only-one rule: stop other running standard apps.
     if (app.type === "standard") {
       const runningForeground = state.apps.filter(
@@ -508,17 +512,9 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
 
   uninstall: (packageName, version) => {
     return Res.try_async(async () => {
-      const wasActiveDashboard = activeDashboardAmong(get().apps) === packageName
       const res = await appRegistry.uninstall(packageName, version)
       if (res.is_error()) throw res.error
       set((s) => ({apps: s.apps.filter((a) => a.packageName !== packageName)}))
-      // The dashboard role fell back to another dashboard, which was stopped
-      // when it lost the role: start it, as launch would have.
-      if (wasActiveDashboard) {
-        const apps = get().apps
-        const heir = apps.find((a) => a.packageName === activeDashboardAmong(apps))
-        if (heir?.alwaysOn && !heir.running) await get().start(heir, {skipNavigation: true})
-      }
     })
   },
 
@@ -563,18 +559,6 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
     if (status && !app.running) await get().start(app, {skipNavigation: true})
   },
 
-  // The dashboard role (ADR-0009) moves to `packageName`: the previous holder
-  // stops and the new one starts in the background.
-  setActiveDashboard: async (packageName: string) => {
-    const apps = get().apps
-    const next = apps.find((a) => a.packageName === packageName && a.type === "dashboard")
-    if (!next) return
-    const previous = apps.find((a) => a.packageName === activeDashboardAmong(apps))
-    await useSettingsStore.getState().setSetting(SETTINGS.active_dashboard.key, packageName)
-    if (previous?.running && previous.packageName !== packageName) await get().stop(previous.packageName)
-    if (!next.running) await get().start(next, {skipNavigation: true})
-  },
-
   setApps: (apps) => set({apps}),
 }))
 
@@ -651,6 +635,10 @@ useSettingsStore.subscribe(
   },
 )
 
+/** Declares the microphone (or everything) in its manifest. */
+const declaresMicrophone = (app: ClientApp): boolean =>
+  app.permissions.some((p) => p.type === "MICROPHONE" || p.type === "ALL")
+
 // ---------------------------------------------------------------------------
 // Public hooks
 // ---------------------------------------------------------------------------
@@ -677,28 +665,8 @@ export const useRunningAlwaysOnApps = () => {
   return useMemo(() => apps.filter((app) => app.alwaysOn && app.running), [apps])
 }
 
-/** Installed miniapps that can hold the dashboard role: manifest type "dashboard". */
-export const useDashboards = () => {
-  const apps = useApps()
-  return useMemo(() => apps.filter((app) => app.type === "dashboard"), [apps])
-}
-
-/** The miniapp that holds the dashboard role (ADR-0009), or null when none is installed. */
-export const useActiveDashboard = (): ClientApp | null => {
-  const dashboards = useDashboards()
-  const chosen = useSettingsStore((s) => s.getSetting(SETTINGS.active_dashboard.key))
-  return useMemo(() => {
-    const packageName = resolveActiveDashboard(
-      dashboards.map((app) => app.packageName),
-      chosen,
-      SETTINGS.active_dashboard.defaultValue(),
-    )
-    return dashboards.find((app) => app.packageName === packageName) ?? null
-  }, [dashboards, chosen])
-}
-
-/** Apps that run without a foreground surface: background ones and dashboards. */
-const isBackgroundApp = (app: ClientApp): boolean => app.type === "background" || app.type === "dashboard"
+/** Apps that run without a foreground surface: background ones and the system dashboard. */
+const isBackgroundApp = (app: ClientApp): boolean => app.type === "background" || app.type === "system_dashboard"
 
 export const useActiveBackgroundApps = () => {
   const apps = useApps()

package/src/stores/settings.ts

@@ -730,18 +730,6 @@ export const SETTINGS: Record<string, Setting> = {
     saveOnServer: false,
     persist: true,
   },
-  // Debug: the G2's G2PERF display performance lines (a sample per busy
-  // second, plus stalls) in the console and the log buffer bug reports carry.
-  // OFF by default: they crowd out everything else in the ten-minute buffer.
-  // Synced to the Bluetooth SDK, which keeps counting either way and only
-  // logs while this is on. Device-local debug knob, so not saved on the server.
-  g2_perf_logs: {
-    key: "g2_perf_logs",
-    defaultValue: () => false,
-    writable: true,
-    saveOnServer: false,
-    persist: true,
-  },
   // Maximum rate at which display updates leave the phone for the glasses.
   // The Bluetooth SDK paces every scene frame and legacy layout to this,
   // coalescing faster updates last-wins; clears bypass it. No effect on G2
@@ -806,12 +794,51 @@ export const SETTINGS: Record<string, Setting> = {
     saveOnServer: false,
     persist: true,
   },
-  // The wearer's choice of dashboard miniapp (ADR-0009). Installs are
-  // per-phone, so the choice is device-local. The default is the bundled
-  // dashboard, which the role falls back to when the choice is not installed.
-  active_dashboard: {
-    key: "active_dashboard",
-    defaultValue: () => "com.glassly.dashboard",
+  // Device-local preferences for the Scene API dashboard available on G2
+  // custom firmware. Eligibility is firmware-reported at runtime, so there is
+  // deliberately no enable toggle: eligible devices replace the native
+  // dashboard automatically while stock firmware keeps its native dashboard.
+  custom_dashboard_clock_style: {
+    key: "custom_dashboard_clock_style",
+    defaultValue: () => "compact",
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
+  custom_dashboard_clock_show_date: {
+    key: "custom_dashboard_clock_show_date",
+    defaultValue: () => true,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
+  // "solid" | "two_tone": the battery widgets' G and R.
+  custom_dashboard_battery_style: {
+    key: "custom_dashboard_battery_style",
+    defaultValue: () => "solid",
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
+  // {preset, slots: {slotId: widgetId}, scratchpad: [widgetId]} — the
+  // dashboard miniapp owns the shape and its default; null draws its default layout.
+  custom_dashboard_layout: {
+    key: "custom_dashboard_layout",
+    defaultValue: () => null,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
+  custom_dashboard_calendar_event_count: {
+    key: "custom_dashboard_calendar_event_count",
+    defaultValue: () => 3,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
+  custom_dashboard_calendar_days_ahead: {
+    key: "custom_dashboard_calendar_days_ahead",
+    defaultValue: () => 5,
     writable: true,
     saveOnServer: false,
     persist: true,
@@ -1103,7 +1130,6 @@ export const BLUETOOTH_SETTING_KEYS: string[] = [
   SETTINGS.calendar_events.key,
   SETTINGS.cfw_scene_renderer.key,
   SETTINGS.cfw_fast_ble.key,
-  SETTINGS.g2_perf_logs.key,
   SETTINGS.display_max_fps.key,
   SETTINGS.twelve_hour_time.key,
   SETTINGS.metric_system.key,

package/src/types/applet.ts

@@ -10,7 +10,7 @@ import type {CompatibilityResult} from "../utils/hardware/hardware"
 /**
  * App execution model types
  */
-export type AppletType = "standard" | "background" | "dashboard"
+export type AppletType = "standard" | "background" | "system_dashboard"
 
 /**
  * Permission types that apps can request
@@ -29,8 +29,6 @@ export type AppPermissionType =
   | "MEMORY"
   | "AI"
   | "SPEAKERS"
-  | "MANAGE_MINIAPPS"
-  | "PLATFORM_SETTINGS"
 
 /**
  * Permission object with type and description

package/src/utils/display/scene/anchor.ts

@@ -2,7 +2,8 @@
  * Anchor resolution — turn corner-anchored boxes into plain top-left boxes
  * against the device's real canvas. Runs in emitScene BEFORE the canPosition
  * branch so both processScene (clamping) and degradeScene (reading order)
- * only ever see concrete coordinates.
+ * only ever see concrete coordinates. Spec:
+ * notes/superpowers/specs/2026-08-10-anchored-render-boxes.md
  */
 
 import type {SceneBox, SceneBoxInput, SceneElementInput} from "./types"

package/build/services/miniappPermissions.d.ts

@@ -1,16 +0,0 @@
-/**
- * Whether a miniapp may use an API gated on a manifest permission
- * (miniapp.json -> permissions): `session.miniapps` needs MANAGE_MINIAPPS,
- * `session.settings` PLATFORM_SETTINGS, the notification app list
- * READ_NOTIFICATIONS. System apps pass without declaring it. Pure, so the
- * runtime only does the reply.
- */
-export interface PermissionCaller {
-    system: boolean;
-    permissions?: ReadonlyArray<{
-        type?: string;
-    }>;
-}
-export declare function declaresPermission(permissions: PermissionCaller["permissions"], permission: string): boolean;
-export declare function mayUsePermission(caller: PermissionCaller, permission: string): boolean;
-//# sourceMappingURL=miniappPermissions.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"miniappPermissions.d.ts","sourceRoot":"","sources":["../../src/services/miniappPermissions.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,OAAO,CAAA;IACf,WAAW,CAAC,EAAE,aAAa,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC,CAAA;CAC7C;AAED,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,gBAAgB,CAAC,aAAa,CAAC,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAE5G;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAEtF"}

package/build/services/miniappPermissions.js

@@ -1,7 +0,0 @@
-export function declaresPermission(permissions, permission) {
-    return (permissions ?? []).some((declared) => declared.type?.toUpperCase() === permission);
-}
-export function mayUsePermission(caller, permission) {
-    return caller.system || declaresPermission(caller.permissions, permission);
-}
-//# sourceMappingURL=miniappPermissions.js.map

package/build/services/miniappPermissions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"miniappPermissions.js","sourceRoot":"","sources":["../../src/services/miniappPermissions.ts"],"names":[],"mappings":"AAYA,MAAM,UAAU,kBAAkB,CAAC,WAA4C,EAAE,UAAkB;IACjG,OAAO,CAAC,WAAW,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,UAAU,CAAC,CAAA;AAC5F,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,MAAwB,EAAE,UAAkB;IAC3E,OAAO,MAAM,CAAC,MAAM,IAAI,kBAAkB,CAAC,MAAM,CAAC,WAAW,EAAE,UAAU,CAAC,CAAA;AAC5E,CAAC","sourcesContent":["/**\n * Whether a miniapp may use an API gated on a manifest permission\n * (miniapp.json -> permissions): `session.miniapps` needs MANAGE_MINIAPPS,\n * `session.settings` PLATFORM_SETTINGS, the notification app list\n * READ_NOTIFICATIONS. System apps pass without declaring it. Pure, so the\n * runtime only does the reply.\n */\nexport interface PermissionCaller {\n  system: boolean\n  permissions?: ReadonlyArray<{type?: string}>\n}\n\nexport function declaresPermission(permissions: PermissionCaller[\"permissions\"], permission: string): boolean {\n  return (permissions ?? []).some((declared) => declared.type?.toUpperCase() === permission)\n}\n\nexport function mayUsePermission(caller: PermissionCaller, permission: string): boolean {\n  return caller.system || declaresPermission(caller.permissions, permission)\n}\n"]}

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

@@ -1,7 +0,0 @@
-export declare function resolveActiveDashboard(installed: readonly string[], chosen: unknown, fallback: string): string | null;
-/** The active dashboard among `apps`; only miniapps whose manifest type is "dashboard" can hold the role. */
-export declare function activeDashboardAmong(apps: ReadonlyArray<{
-    packageName: string;
-    type?: string;
-}>): string | null;
-//# sourceMappingURL=activeDashboard.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"activeDashboard.d.ts","sourceRoot":"","sources":["../../../src/services/pages/activeDashboard.ts"],"names":[],"mappings":"AASA,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAIrH;AAED,6GAA6G;AAC7G,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,aAAa,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAC,CAAC,GAAG,MAAM,GAAG,IAAI,CAO7G"}

package/build/services/pages/activeDashboard.js

@@ -1,21 +0,0 @@
-/**
- * Who holds the dashboard role (ADR-0009): the wearer's choice when that
- * miniapp is installed, else the default (the bundled dashboard), else the
- * first installed dashboard by package name, else nobody. Read at decision
- * time, never cached, so an uninstall hands the role back without anyone
- * rewriting the setting.
- */
-import { SETTINGS, useSettingsStore } from "../../stores/settings";
-export function resolveActiveDashboard(installed, chosen, fallback) {
-    if (typeof chosen === "string" && installed.includes(chosen))
-        return chosen;
-    if (installed.includes(fallback))
-        return fallback;
-    return [...installed].sort()[0] ?? null;
-}
-/** The active dashboard among `apps`; only miniapps whose manifest type is "dashboard" can hold the role. */
-export function activeDashboardAmong(apps) {
-    const installed = apps.filter((app) => app.type === "dashboard").map((app) => app.packageName);
-    return resolveActiveDashboard(installed, useSettingsStore.getState().getSetting(SETTINGS.active_dashboard.key), SETTINGS.active_dashboard.defaultValue());
-}
-//# sourceMappingURL=activeDashboard.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"activeDashboard.js","sourceRoot":"","sources":["../../../src/services/pages/activeDashboard.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAC,QAAQ,EAAE,gBAAgB,EAAC,MAAM,uBAAuB,CAAA;AAEhE,MAAM,UAAU,sBAAsB,CAAC,SAA4B,EAAE,MAAe,EAAE,QAAgB;IACpG,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC;QAAE,OAAO,MAAM,CAAA;IAC3E,IAAI,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAAE,OAAO,QAAQ,CAAA;IACjD,OAAO,CAAC,GAAG,SAAS,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAA;AACzC,CAAC;AAED,6GAA6G;AAC7G,MAAM,UAAU,oBAAoB,CAAC,IAAyD;IAC5F,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,WAAW,CAAC,CAAA;IAC9F,OAAO,sBAAsB,CAC3B,SAAS,EACT,gBAAgB,CAAC,QAAQ,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,gBAAgB,CAAC,GAAG,CAAC,EACrE,QAAQ,CAAC,gBAAgB,CAAC,YAAY,EAAE,CACzC,CAAA;AACH,CAAC","sourcesContent":["/**\n * Who holds the dashboard role (ADR-0009): the wearer's choice when that\n * miniapp is installed, else the default (the bundled dashboard), else the\n * first installed dashboard by package name, else nobody. Read at decision\n * time, never cached, so an uninstall hands the role back without anyone\n * rewriting the setting.\n */\nimport {SETTINGS, useSettingsStore} from \"../../stores/settings\"\n\nexport function resolveActiveDashboard(installed: readonly string[], chosen: unknown, fallback: string): string | null {\n  if (typeof chosen === \"string\" && installed.includes(chosen)) return chosen\n  if (installed.includes(fallback)) return fallback\n  return [...installed].sort()[0] ?? null\n}\n\n/** The active dashboard among `apps`; only miniapps whose manifest type is \"dashboard\" can hold the role. */\nexport function activeDashboardAmong(apps: ReadonlyArray<{packageName: string; type?: string}>): string | null {\n  const installed = apps.filter((app) => app.type === \"dashboard\").map((app) => app.packageName)\n  return resolveActiveDashboard(\n    installed,\n    useSettingsStore.getState().getSetting(SETTINGS.active_dashboard.key),\n    SETTINGS.active_dashboard.defaultValue(),\n  )\n}\n"]}

package/src/services/miniappPermissions.ts

@@ -1,19 +0,0 @@
-/**
- * Whether a miniapp may use an API gated on a manifest permission
- * (miniapp.json -> permissions): `session.miniapps` needs MANAGE_MINIAPPS,
- * `session.settings` PLATFORM_SETTINGS, the notification app list
- * READ_NOTIFICATIONS. System apps pass without declaring it. Pure, so the
- * runtime only does the reply.
- */
-export interface PermissionCaller {
-  system: boolean
-  permissions?: ReadonlyArray<{type?: string}>
-}
-
-export function declaresPermission(permissions: PermissionCaller["permissions"], permission: string): boolean {
-  return (permissions ?? []).some((declared) => declared.type?.toUpperCase() === permission)
-}
-
-export function mayUsePermission(caller: PermissionCaller, permission: string): boolean {
-  return caller.system || declaresPermission(caller.permissions, permission)
-}

package/src/services/pages/activeDashboard.ts

@@ -1,24 +0,0 @@
-/**
- * Who holds the dashboard role (ADR-0009): the wearer's choice when that
- * miniapp is installed, else the default (the bundled dashboard), else the
- * first installed dashboard by package name, else nobody. Read at decision
- * time, never cached, so an uninstall hands the role back without anyone
- * rewriting the setting.
- */
-import {SETTINGS, useSettingsStore} from "../../stores/settings"
-
-export function resolveActiveDashboard(installed: readonly string[], chosen: unknown, fallback: string): string | null {
-  if (typeof chosen === "string" && installed.includes(chosen)) return chosen
-  if (installed.includes(fallback)) return fallback
-  return [...installed].sort()[0] ?? null
-}
-
-/** The active dashboard among `apps`; only miniapps whose manifest type is "dashboard" can hold the role. */
-export function activeDashboardAmong(apps: ReadonlyArray<{packageName: string; type?: string}>): string | null {
-  const installed = apps.filter((app) => app.type === "dashboard").map((app) => app.packageName)
-  return resolveActiveDashboard(
-    installed,
-    useSettingsStore.getState().getSetting(SETTINGS.active_dashboard.key),
-    SETTINGS.active_dashboard.defaultValue(),
-  )
-}