@glassly/engine 0.3.5-beta.710 → 0.3.5-beta.734

package/src/services/GlassesTouchInput.ts

@@ -17,7 +17,7 @@ import {pagesEligible} from "./pages/pageEligibility"
 
 const miniappExitGesture = new MiniappExitGesture({
   getState: () => useAppStatusStore.getState(),
-  getVisiblePackageName: () => localDisplayManager.getVisibleMiniappPackageName(),
+  getTargetPackageName: () => localDisplayManager.getMiniappToLeave(),
   beginExitNotice: (packageName, text) => localDisplayManager.beginMiniappExit(packageName, text),
   finishExitNotice: (packageName) => localDisplayManager.finishMiniappExit(packageName),
   cancelExitNotice: (packageName) => localDisplayManager.cancelMiniappExit(packageName),
@@ -47,9 +47,10 @@ function shouldForwardScroll(event: TouchEvent): boolean {
  * Route both real glasses input and phone mirror controls through the same
  * policy. A claimed gesture goes to the app holding the claim, alone; an
  * unclaimed one goes to every subscriber and then the engine's default. The
- * one rule ahead of the claims: an unclaimed double tap on a miniapp whose
- * frame is visibly on the glasses leaves that app, whoever else claimed the
- * gesture — the dashboard's claim is for the empty screen. Head position
+ * one rule ahead of the claims: an unclaimed double tap leaves the miniapp
+ * the wearer is in — the one visibly on the glasses, else the running
+ * standard app on an empty screen — whoever else claimed the gesture; the
+ * dashboard's claim is for the screen with no app in it. Head position
  * (head_up / head_down) is a gesture like any other: the dashboard claims it
  * while it runs, and an unclaimed head_up on glasses that defer the dashboard
  * to the phone opens the native one, as it would with no app at all.
@@ -63,16 +64,16 @@ export function dispatchTouchEvent(event: TouchEvent): void {
   const osHeadUp = gesture === "head_up"
 
   if (osDoubleTap) {
-    // A visible main miniapp opts out of OS exit by registering double tap (the
+    // The app being left opts out of OS exit by registering double tap (the
     // terminal's back-to-menu). The latest claimant still receives it. Otherwise
     // the tap means "leave the app". The controller shows the bounded OS
-    // notice first, then uses the normal
-    // store stop path (and closes its phone overlay).
-    const visible = localDisplayManager.getVisibleMiniappPackageName()
+    // notice first, then uses the normal store stop path (and closes its
+    // phone overlay).
+    const leaving = localDisplayManager.getMiniappToLeave()
     if (
-      visible !== null &&
-      !localMiniappRuntime.hasGestureClaim(visible, gesture) &&
-      miniappExitGesture.tryExitVisibleMiniapp()
+      leaving !== null &&
+      !localMiniappRuntime.hasGestureClaim(leaving, gesture) &&
+      miniappExitGesture.tryExitMiniapp()
     ) {
       gestureDotsService.noteGesture(gesture, true, event.index, event.controllerId)
       return

package/src/services/LocalDisplayManager.ts

@@ -165,7 +165,7 @@ class LocalDisplayManager {
   private overlayOwner: string | null = null
 
   /** Miniapp whose visible frame is temporarily covered by an OS exit notice. */
-  private exitingApp: {packageName: string; coveredDisplay: ActiveDisplay} | null = null
+  private exitingApp: {packageName: string; coveredDisplay: ActiveDisplay | null} | null = null
 
   private expiryTimerId: number | null = null
 
@@ -309,16 +309,30 @@ class LocalDisplayManager {
   }
 
   /**
-   * Cover the currently visible miniapp with a persistent system exit notice.
-   * While it is up, miniapp display traffic is held off so a streaming app
-   * cannot immediately overwrite the notice. The caller completes the normal
-   * stop flow and then calls finishMiniappExit(); onUnmount does the same as a
+   * The miniapp an unclaimed double tap leaves: the one visibly drawing on
+   * the main view, else the core (running standard) app on an empty or
+   * system-drawn screen — an app that has drawn nothing yet, or whose frame
+   * expired, is still the one the wearer is in. Nothing while a page covers
+   * the main view: the page's claims own the tap.
+   */
+  public getMiniappToLeave(): string | null {
+    if (this.overlayOwner !== null) return null
+    return this.getVisibleMiniappPackageName() ?? this.coreApp
+  }
+
+  /**
+   * Cover the leaving miniapp with a persistent system exit notice. While it
+   * is up, miniapp display traffic is held off so a streaming app cannot
+   * immediately overwrite the notice. The caller completes the normal stop
+   * flow and then calls finishMiniappExit(); onUnmount does the same as a
    * safety net.
    */
   public beginMiniappExit(packageName: string, text: string): boolean {
     if (this.exitingApp !== null) return this.exitingApp.packageName === packageName
-    const coveredDisplay = this.currentDisplay
-    if (!coveredDisplay || this.getVisibleMiniappPackageName() !== packageName) return false
+    if (this.getMiniappToLeave() !== packageName) return false
+    // Only the app's own visible frame comes back on cancel; a system frame
+    // or an empty screen does not.
+    const coveredDisplay = this.getVisibleMiniappPackageName() === packageName ? this.currentDisplay : null
 
     console.log(`${LOG_TAG}: beginMiniappExit(${packageName})`)
     this.exitingApp = {packageName, coveredDisplay}
@@ -349,7 +363,7 @@ class LocalDisplayManager {
     this.exitingApp = null
 
     if (this.currentDisplay?.packageName !== SYSTEM_NOTICE_PKG) return
-    if (covered.expiresAt === null || covered.expiresAt > this.now()) {
+    if (covered && (covered.expiresAt === null || covered.expiresAt > this.now())) {
       this.restoreDisplay(covered)
     } else {
       this.currentDisplay = null

package/src/services/LocalMiniappRuntime.ts

@@ -641,6 +641,10 @@ class LocalMiniappRuntime {
   private connectedApps: Map<string, ConnectedMiniapp> = new Map()
   /** Claimed gestures (CLAIM_GESTURES): a stack per gesture, the most recent claimer holding it. */
   private gestureClaims: GestureClaimState = emptyGestureClaims()
+  // The last main-view frame each app asked to render. Widget mode refuses
+  // frames and demotion clears them, and an app that has drawn once may not
+  // draw again on its own, so promotion replays this.
+  private retainedRenders = new Map<string, Record<string, unknown>>()
 
   /**
    * Packages that have completed their CONNECT handshake (sent
@@ -705,7 +709,13 @@ class LocalMiniappRuntime {
   private localSecret = `miniapp_${Date.now()}_${Math.random().toString(36).slice(2, 14)}`
   private usedTokens = new Set<string>()
 
-  private constructor() {}
+  private constructor() {
+    miniappWidgetMode.subscribe((packageName, widgetOnly) => {
+      // Promotion happens inside the apps store's start(); the core-app slot
+      // settles with that store write, so replay once it has.
+      if (!widgetOnly) queueMicrotask(() => this.replayRetainedRender(packageName))
+    })
+  }
 
   /** Snapshot of miniapps actively subscribed to hardware button events. */
   public getButtonPressSubscribers(): string[] {
@@ -1122,7 +1132,11 @@ class LocalMiniappRuntime {
     // window ends early once this app pushes its first display (see
     // LocalDisplayManager.request), or after ~1.5s. Fires once per spawn —
     // including a crash-respawn, since each spawn is a fresh "app is starting".
-    localDisplayManager.onMount(packageName, installedManifest?.name ?? packageName)
+    // A spawn for a dashboard widget is not the wearer starting the app: it draws
+    // nothing of its own, so it shows no boot text either.
+    if (!miniappWidgetMode.isWidgetOnly(packageName)) {
+      localDisplayManager.onMount(packageName, installedManifest?.name ?? packageName)
+    }
   }
 
   /**
@@ -1244,6 +1258,7 @@ class LocalMiniappRuntime {
     }
     // Its gesture claims go back to whoever claimed them before.
     this.applyGestureClaimChanges(dropGestureClaims(this.gestureClaims, packageName))
+    this.retainedRenders.delete(packageName)
 
     // Warm-up is a request-owned camera lease. Cancel it even if the app record was already
     // removed so a close racing the camera-open promise cannot leave the sensor running.
@@ -2489,11 +2504,6 @@ class LocalMiniappRuntime {
         this.sendResult(packageName, requestId, true, {status: "blocked", reason: "app stopped"})
         return
       }
-      // A widget-only app draws through its widget alone.
-      if (miniappWidgetMode.isWidgetOnly(packageName)) {
-        this.sendResult(packageName, requestId, true, {status: "blocked", reason: "widget mode"})
-        return
-      }
       if (!Array.isArray(payload.elements)) {
         this.sendResult(packageName, requestId, false, undefined, {
           code: MiniappErrorCode.INTERNAL,
@@ -2501,6 +2511,15 @@ class LocalMiniappRuntime {
         })
         return
       }
+      if (payload.view !== "dashboard") {
+        if (payload.elements.length === 0) this.retainedRenders.delete(packageName)
+        else this.retainedRenders.set(packageName, payload)
+      }
+      // A widget-only app draws through its widget alone; the frame waits for promotion.
+      if (miniappWidgetMode.isWidgetOnly(packageName)) {
+        this.sendResult(packageName, requestId, true, {status: "blocked", reason: "widget mode"})
+        return
+      }
       // The dashboard view is the overlay app's alone; anyone else's frame
       // is dropped, reported rather than silently lost.
       if (payload.view === "dashboard" && !isOverlayApp(packageName)) {
@@ -2530,6 +2549,13 @@ class LocalMiniappRuntime {
     }
   }
 
+  /** Put a promoted app's last main-view frame on the glasses; widget mode had refused it. */
+  private replayRetainedRender(packageName: string): void {
+    const payload = this.retainedRenders.get(packageName)
+    if (!payload || !this.connectedApps.has(packageName) || miniappWidgetMode.isWidgetOnly(packageName)) return
+    this.handleRender(packageName, payload)
+  }
+
   /**
    * display.showView: the active dashboard takes or releases the overlay
    * slot. Refused (NOT_PERMITTED) for an app that is not a dashboard;
@@ -6381,10 +6407,12 @@ class LocalMiniappRuntime {
     }
     const provider = app.packageName
     // Record the placement before the wake so the spawn lands in widget mode
-    // and an unplace racing it cannot stop the provider early.
+    // and an unplace racing it cannot stop the provider early. A provider the
+    // store already runs (a wearer's launch still spawning, say) stays a
+    // normal run; the registry alone lags that launch.
     this.widgetPlacements = placeWidget(this.widgetPlacements, {hostPackageName, providerPackageName: provider, widgetId, box})
     miniappWidgetMode.setPlaced(provider, true)
-    if (!miniappRunningRegistry.has(provider)) miniappWidgetMode.setWidgetOnly(provider, true)
+    if (!app.running && !miniappRunningRegistry.has(provider)) miniappWidgetMode.setWidgetOnly(provider, true)
     try {
       await this.wakeInteropApp(provider)
     } catch (e) {

package/src/services/MiniappExitGesture.ts

@@ -4,6 +4,8 @@ interface ExitGestureApp {
   packageName: string
   name: string
   running: boolean
+  /** Running only for a placed widget: the wearer is not in it, so there is nothing to leave. */
+  widgetOnly?: boolean
 }
 
 interface ExitGestureState {
@@ -15,7 +17,8 @@ interface ExitGestureState {
 
 export interface ExitGestureDependencies {
   getState: () => ExitGestureState
-  getVisiblePackageName: () => string | null
+  /** The miniapp a double tap leaves right now, or null when the tap is the system's. */
+  getTargetPackageName: () => string | null
   beginExitNotice: (packageName: string, text: string) => boolean
   finishExitNotice: (packageName: string) => void
   cancelExitNotice: (packageName: string) => void
@@ -29,16 +32,16 @@ export class MiniappExitGesture {
 
   public constructor(private readonly deps: ExitGestureDependencies) {}
 
-  /** Returns true when the system gesture was consumed by a visible miniapp exit. */
-  public tryExitVisibleMiniapp(): boolean {
+  /** Returns true when the system gesture was consumed by a miniapp exit. */
+  public tryExitMiniapp(): boolean {
     // Swallow repeat taps while the notice is already counting down.
     if (this.pending) return true
 
-    const packageName = this.deps.getVisiblePackageName()
+    const packageName = this.deps.getTargetPackageName()
     if (!packageName) return false
 
     const app = this.deps.getState().apps.find((candidate) => candidate.packageName === packageName)
-    if (!app?.running) return false
+    if (!app?.running || app.widgetOnly) return false
 
     const name = app.name.trim() || packageName
     if (!this.deps.beginExitNotice(packageName, `Exiting ${name}…`)) return false

package/src/services/MiniappWidgetMode.ts

@@ -2,25 +2,27 @@
  * Widget mode: a miniapp whose background context runs only because a host
  * (the dashboard) placed one of its widgets. It is running, but it has no
  * card in the app switcher, draws nothing of its own on the glasses and
- * hears no touch input; the Widgets pill lists it. Opening the app from the
- * home screen promotes it to a normal run; closing a placed app from the
- * tray demotes it back here instead of stopping it.
+ * hears no touch input; the Widgets pill lists it. Foregrounding the app on
+ * the phone promotes it to a normal run (the store's start/setForeground);
+ * closing a placed app from the tray demotes it back here instead of
+ * stopping it.
  *
  * The runtime is the writer (placements come and go through it); the apps
  * store projects `widgetOnly` from here beside `running`.
  */
 
-type Listener = () => void
+/** Called with the app whose mode changed and whether it is now widget-only. */
+type Listener = (packageName: string, widgetOnly: boolean) => void
 
 const widgetOnly = new Set<string>()
 /** Providers with at least one widget placed by some host. */
 const placed = new Set<string>()
 const listeners = new Set<Listener>()
 
-function notify(): void {
+function notify(packageName: string, on: boolean): void {
   for (const fn of listeners) {
     try {
-      fn()
+      fn(packageName, on)
     } catch (e) {
       console.warn("MiniappWidgetMode: listener threw", e)
     }
@@ -32,7 +34,7 @@ export const miniappWidgetMode = {
   setWidgetOnly(packageName: string, on: boolean): void {
     const changed = on ? !widgetOnly.has(packageName) : widgetOnly.delete(packageName)
     if (on) widgetOnly.add(packageName)
-    if (changed) notify()
+    if (changed) notify(packageName, on)
   },
 
   isWidgetOnly(packageName: string): boolean {

package/src/stores/apps.ts

@@ -256,6 +256,7 @@ function projectApps(previousState: AppStatusState, localApps: ClientApp[]): Cli
         // across both passes.
         foregrounded: app.packageName === previousState.foregroundedPackage,
         paused: app.local && app.running && isMiniappsPaused(),
+        widgetOnly: !!app.local && app.running && miniappWidgetMode.isWidgetOnly(app.packageName),
       }
       const prev = previousByPackage.get(app.packageName)
       return prev && shallowEqualApp(prev, next) ? prev : next
@@ -362,6 +363,11 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
       return false
     }
 
+    // An app running only for its widget is promoted before the host hook:
+    // the hook may foreground it, and setForeground sends a widget-only app
+    // back here.
+    if (app.widgetOnly) miniappWidgetMode.setWidgetOnly(packageName, false)
+
     // Host navigation / open-animation seam. Runs on EVERY accepted open —
     // including re-opening an already-running app — so the animation always
     // plays (BuiltInMiniappCatalog.navigateForApp: overlay apps setForeground
@@ -374,13 +380,12 @@ 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. An app running only for its widget
-    // is promoted instead: it keeps its context and takes the foreground.
+    // circuit before the spawn pipeline. A promoted app keeps its context but
+    // still takes the foreground below.
     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. Widget-only
@@ -495,13 +500,10 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
       apps: s.apps.map((a) => ({...a, foregrounded: a.packageName === packageName})),
     }))
 
-    // Ensure the JSContext exists. start() is idempotent for an
-    // already-running app and enforces the foreground-only-one rule for
-    // standard apps. Fire-and-forget after the flag flip so it doesn't block
-    // paint.
-    // if (!app.running) {
-    //   get().start(app)
-    // }
+    // The wearer is in this app now: one running only for its widget becomes
+    // a normal run. start() promotes it, stops the standard peer and keeps the
+    // context. Fire-and-forget after the flag flip so it doesn't block paint.
+    if (app.running && app.widgetOnly) void get().start(app, {skipNavigation: true})
   },
 
   clearForeground: () => {