@glassly/engine 0.3.7-dev.964 → 0.3.7-dev.969

package/src/services/JSRouter.ts

@@ -146,6 +146,9 @@ export class JSRouter {
    */
   uiRouter: UIRouter | null = null
 
+  /** Teardowns in progress, so a stop and a racing start or stop see the same one. */
+  private readonly unregistering = new Map<string, Promise<void>>()
+
   constructor(
     private readonly runtime: LocalMiniappRuntime,
     private readonly crust: JSCrustBinding,
@@ -351,12 +354,26 @@ export class JSRouter {
   }
 
   /**
-   * Tear down a JSContext and unregister from the runtime. Synchronous
-   * teardown — the spec drops the 50ms WILL_DISCONNECT grace window
-   * because there's no transport handshake to flush in the JSC world.
+   * Tear down a JSContext and unregister from the runtime. The session's
+   * `onBeforeDisconnect` handlers get a short grace window first, so a
+   * miniapp can clear what it drew and end its own work while its messages
+   * still reach the host. Concurrent calls share one teardown.
    */
-  async unregister(packageName: string): Promise<void> {
-    if (!this.registered.has(packageName)) return
+  unregister(packageName: string): Promise<void> {
+    if (!this.registered.has(packageName)) return Promise.resolve()
+    const inFlight = this.unregistering.get(packageName)
+    if (inFlight) return inFlight
+    const teardown = this.teardown(packageName).finally(() => this.unregistering.delete(packageName))
+    this.unregistering.set(packageName, teardown)
+    return teardown
+  }
+
+  /** Resolves once an in-flight {@link unregister} of this package has finished. */
+  async whenUnregistered(packageName: string): Promise<void> {
+    await this.unregistering.get(packageName)
+  }
+
+  private async teardown(packageName: string): Promise<void> {
     // Cancel any pending crash-respawn before tearing down — we don't
     // want a stale timer to re-spawn a miniapp the user just disabled.
     const pending = this.respawnTimers.get(packageName)
@@ -364,6 +381,7 @@ export class JSRouter {
       BgTimer.clearTimeout(pending)
       this.respawnTimers.delete(packageName)
     }
+    await this.runtime.notifyWillDisconnect(packageName, "stopped")
     this.spawnCache.delete(packageName)
     this.crashController?.onKill(packageName)
     // User-initiated close/disable: end any active nav trip so the glasses

package/src/services/LocalMiniappRuntime.ts

@@ -340,6 +340,8 @@ const SYSTEM_MINIAPP_PACKAGES = new Set([
   "com.glassly.miniappdev",
 ])
 const PING_INTERVAL_MS = 5_000
+/** How long a stopping miniapp's `beforeDisconnect` handlers get before teardown. */
+const WILL_DISCONNECT_GRACE_MS = 100
 // Min gap between "transcription limit reached" notices on the glasses. A
 // debounce, not a cooldown: the cloud re-announces the block per refused
 // subscribe, and miniapps retry in bursts — this only coalesces those bursts
@@ -1249,21 +1251,26 @@ class LocalMiniappRuntime {
    * undeliverable anyway.
    */
   public async gracefullyUnregisterApp(packageName: string, reason = "unregistering"): Promise<void> {
-    const app = this.connectedApps.get(packageName)
-    if (!app) return
-
-    console.log(`${LOG_TAG}: gracefullyUnregisterApp(${packageName}) — sending WILL_DISCONNECT`)
-    this.sendToMiniapp(packageName, {
-      type: MiniappResponseType.WILL_DISCONNECT,
-      reason,
-    })
-    // 50 ms: imperceptible to the user, plenty of time for the SDK's
-    // synchronous `beforeDisconnect` handlers to flush a final
-    // sendOneShot through the still-open transport.
-    await new Promise<void>((resolve) => BgTimer.setTimeout(resolve, 50))
+    if (!this.connectedApps.has(packageName)) return
+    await this.notifyWillDisconnect(packageName, reason)
     this.unregisterApp(packageName)
   }
 
+  /**
+   * Send `WILL_DISCONNECT` and wait out the grace window, so the session's
+   * `beforeDisconnect` handlers run (Navigation clears its HUD and ends its
+   * trip) and their last messages land before teardown. No-op unless the
+   * app finished its handshake.
+   */
+  public async notifyWillDisconnect(packageName: string, reason: string): Promise<void> {
+    if (!this.connectedApps.has(packageName) || !this.handshookApps.has(packageName)) return
+    console.log(`${LOG_TAG}: ${packageName} — sending WILL_DISCONNECT (${reason})`)
+    this.sendToMiniapp(packageName, {type: MiniappResponseType.WILL_DISCONNECT, reason})
+    // The message and the replies it triggers each cross a JSContext hop;
+    // short enough not to slow an app switch noticeably.
+    await new Promise<void>((resolve) => BgTimer.setTimeout(resolve, WILL_DISCONNECT_GRACE_MS))
+  }
+
   public unregisterApp(packageName: string, opts?: {endNavigation?: boolean}): void {
     console.log(`${LOG_TAG}: unregisterApp(${packageName})`)
     const releasedMicGateOverride = micStateCoordinator.clearMiniappGateOverrides(packageName)
@@ -6087,14 +6094,14 @@ class LocalMiniappRuntime {
     if (!app) return false
     // session.miniapps.start comes from the glasses (the dashboard's Apps menu,
     // an Assist voice command), unlike a headless action wake, which carries no source.
+    // The full start, as a phone open runs it: the standard peer stops so this
+    // app owns the display, and an app already running hears the new launch.
     const launchSource = "glasses" as const
-    // Running only for its widget: start() promotes it to a normal run, as opening it on the phone does.
-    if (app.widgetOnly) return useAppStatusStore.getState().start(app, {skipNavigation: true, launchSource})
-    if (app.local) {
-      await miniappLauncher.ensureConnected(packageName, undefined, {launchSource})
-      return true
-    }
-    return useAppStatusStore.getState().start(app, {skipNavigation: true, launchSource})
+    const started = await useAppStatusStore.getState().start(app, {skipNavigation: true, launchSource})
+    if (!started) return false
+    // The caller may message the app next; start() resolves at spawn.
+    if (app.local) await miniappLauncher.ensureConnected(packageName, undefined, {launchSource})
+    return true
   }
 
   private stopInteropApp(packageName: string): Promise<void> {

package/src/services/MiniappLauncher.ts

@@ -233,6 +233,8 @@ class MiniappLauncher {
    */
   async ensureRunning(packageName: string, hints?: LaunchHints): Promise<LaunchResult> {
     const router = this.requireRouter()
+    // A context still tearing down from a stop is not one to reuse.
+    await router.whenUnregistered(packageName)
 
     // Already spawned: best-effort resolve for the UI entry, never throw —
     // a headless caller that doesn't need UI gets {null, null} fast even if

package/src/services/pages/pageEligibility.ts

@@ -29,7 +29,7 @@ export function isCustomDashboardEligible(info: {model?: string | null; firmware
   if (info.model === DeviceTypes.MEMOMIND_ONE) {
     const match = /^GLASSLYCFW\/([0-9]+)$/.exec(info.firmwareVersion ?? "")
     const revision = match ? Number(match[1]) : 0
-    return Number.isSafeInteger(revision) && revision >= 5
+    return Number.isSafeInteger(revision) && revision >= 7
   }
   return (
     getModelCapabilities(info.model as DeviceTypes).hasCustomFirmware === true &&

package/src/services/settingsBridge.ts

@@ -38,6 +38,7 @@ export const SETTINGS_BRIDGE_KEYS: Readonly<Record<string, SettingsBridgeAccess>
   notifications_enabled: "write",
   notifications_popups: "write",
   notifications_popup_seconds: "write",
+  notifications_batch_seconds: "write",
   notifications_hold_during_apps: "write",
   notifications_ignore_while_active: "write",
   notifications_blocklist: "write",

package/src/stores/settings.ts

@@ -1147,6 +1147,13 @@ export const SETTINGS: Record<string, Setting> = {
     saveOnServer: true,
     persist: true,
   },
+  notifications_batch_seconds: {
+    key: "notifications_batch_seconds",
+    defaultValue: () => 0,
+    writable: true,
+    saveOnServer: true,
+    persist: true,
+  },
   // Hold popups while another glasses feature (navigation, a miniapp) is on screen.
   notifications_hold_during_apps: {
     key: "notifications_hold_during_apps",