@glassly/engine 0.3.4-dev.704 → 0.3.5-dev.705

package/src/stores/apps.ts

@@ -26,6 +26,7 @@ import sttModelManager from "../services/STTModelManager"
 import {miniappLauncher} from "../services/MiniappLauncher"
 import {isMiniappsPaused, onMiniappsPauseChange} from "../services/MiniappPauseCoordinator"
 import {miniappRunningRegistry} from "../services/MiniappRunningRegistry"
+import {miniappWidgetMode} from "../services/MiniappWidgetMode"
 import {defaultHiddenStatus, isGatedByDevTools, isGatedUntilPaired, resolveHiddenStatus} from "./appVisibility"
 import {SETTINGS, useSettingsStore} from "./settings"
 import BluetoothSdk from "@glassly/bluetooth-sdk"
@@ -373,16 +374,21 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
 
     // If the tapped app is already running, this is a re-open: the nav/foreground
     // above already drove the animation, and there's nothing to spawn. Short-
-    // circuit before the spawn pipeline.
-    if (app.running) {
+    // circuit before the spawn pipeline. An app running only for its widget
+    // is promoted instead: it keeps its context and takes the foreground.
+    if (app.running && !app.widgetOnly) {
       saveLastOpenTime(packageName)
       return true
     }
+    if (app.widgetOnly) miniappWidgetMode.setWidgetOnly(packageName, false)
 
     // Only-one rules: one standard app in the foreground, one dashboard
-    // drawing the overlay. Starting another stops the one running.
+    // drawing the overlay. Starting another stops the one running. Widget-only
+    // peers hold no foreground, so they stay.
     if (app.type === "standard" || app.type === "dashboard") {
-      const runningPeers = state.apps.filter((a) => a.running && a.type === app.type && a.packageName !== packageName)
+      const runningPeers = state.apps.filter(
+        (a) => a.running && !a.widgetOnly && a.type === app.type && a.packageName !== packageName,
+      )
       for (const r of runningPeers) {
         await get().stop(r.packageName)
       }
@@ -429,6 +435,22 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
       return
     }
 
+    // A placed widget provider is the dashboard's to keep: closing it from
+    // the tray takes its card and its frame, and it runs on in widget mode.
+    if (app.local && app.running && miniappWidgetMode.isPlaced(packageName)) {
+      if (!app.widgetOnly) {
+        miniappWidgetMode.setWidgetOnly(packageName, true)
+        localDisplayManager.onUnmount(packageName)
+        set((s) => ({
+          foregroundedPackage: s.foregroundedPackage === packageName ? null : s.foregroundedPackage,
+          apps: s.apps.map((a) =>
+            a.packageName === packageName ? {...a, screenshot: undefined, foregrounded: false, loading: false} : a,
+          ),
+        }))
+      }
+      return
+    }
+
     set((s) => ({
       apps: s.apps.map((a) =>
         a.packageName === packageName ? {...a, running: false, screenshot: undefined, loading: false} : a,
@@ -494,7 +516,8 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
   stopAll: () => {
     return Res.try_async(async () => {
       // Always On apps stay up; they stop one at a time from the switcher.
-      const running = get().apps.filter((a) => a.running && !a.alwaysOn)
+      // Widget-only apps have no card to close; they are the dashboard's.
+      const running = get().apps.filter((a) => a.running && !a.alwaysOn && !a.widgetOnly)
       for (const a of running) {
         await get().stop(a.packageName)
       }
@@ -578,15 +601,17 @@ function projectLocalRunningState(): void {
     if (!app.local) return app
     const next = running.has(app.packageName)
     const paused = next && pausedNow
-    if (app.running === next && (app.paused ?? false) === paused) return app
+    const widgetOnly = next && miniappWidgetMode.isWidgetOnly(app.packageName)
+    if (app.running === next && (app.paused ?? false) === paused && (app.widgetOnly ?? false) === widgetOnly) return app
     changed = true
-    return {...app, running: next, paused}
+    return {...app, running: next, paused, widgetOnly}
   })
   if (changed) {
     useAppStatusStore.setState({apps: updated})
   }
 }
 miniappRunningRegistry.subscribe(projectLocalRunningState)
+miniappWidgetMode.subscribe(projectLocalRunningState)
 onMiniappsPauseChange(projectLocalRunningState)
 
 // The display-manager's core (foreground) slot is DERIVED state: always the
@@ -596,7 +621,7 @@ onMiniappsPauseChange(projectLocalRunningState)
 // sites, so no launch/stop path can forget to claim or release the slot.
 // onCoreAppChange is idempotent, so firing on every store write is free.
 useAppStatusStore.subscribe((state) => {
-  const core = state.apps.find((a) => a.running && (a.type === "standard" || !a.type))
+  const core = state.apps.find((a) => a.running && !a.widgetOnly && (a.type === "standard" || !a.type))
   localDisplayManager.onCoreAppChange(core?.packageName ?? null)
 })
 
@@ -657,10 +682,16 @@ export const useStopAll = () => useAppStatusStore((state) => state.stopAll)
 export const useInstall = () => useAppStatusStore((state) => state.install)
 export const useUninstall = () => useAppStatusStore((state) => state.uninstall)
 
-/** Every running app; each one has a card in the app switcher tray. */
+/** Every running app with a card in the app switcher tray: widget-only apps have none. */
 export const useActiveApps = () => {
   const apps = useApps()
-  return useMemo(() => apps.filter((app) => app.running), [apps])
+  return useMemo(() => apps.filter((app) => app.running && !app.widgetOnly), [apps])
+}
+
+/** Apps running only for a widget the dashboard placed; the switcher's Widgets pill lists them. */
+export const useWidgetApps = () => {
+  const apps = useApps()
+  return useMemo(() => apps.filter((app) => app.running && app.widgetOnly), [apps])
 }
 
 /** Always On apps whose background task is running, card or no card. */
@@ -690,7 +721,10 @@ export const useBackgroundApps = () => {
 
 export const useActiveForegroundApp = () => {
   const apps = useApps()
-  return useMemo(() => apps.find((app) => (app.type === "standard" || !app.type) && app.running) ?? null, [apps])
+  return useMemo(
+    () => apps.find((app) => (app.type === "standard" || !app.type) && app.running && !app.widgetOnly) ?? null,
+    [apps],
+  )
 }
 
 /**

package/src/types/applet.ts

@@ -89,6 +89,16 @@ export interface DeclaredAction {
   visibility?: "public" | "system"
 }
 
+export type DeclaredWidgetSize = "XS" | "SM" | "MD" | "LG"
+
+/** A dashboard widget a miniapp declares in `miniapp.json` and serves through `session.widgets`. */
+export interface DeclaredWidget {
+  id: string
+  name: string
+  sizes: DeclaredWidgetSize[]
+  defaultSize: DeclaredWidgetSize
+}
+
 export interface ClientApp extends AppletInterface {
   offline: boolean
   offlineRoute: string
@@ -124,4 +134,12 @@ export interface ClientApp extends AppletInterface {
   isMiniappDev?: boolean
   /** Manifest-declared actions (for session.miniapps.list + invoke gating). */
   actions?: DeclaredAction[]
+  /** Manifest-declared dashboard widgets. */
+  widgets?: DeclaredWidget[]
+  /**
+   * Running only because a host placed one of its widgets: no card in the
+   * app switcher, no frame of its own on the glasses. Opening the app from
+   * the home screen promotes it to a normal run.
+   */
+  widgetOnly?: boolean
 }