@glassly/engine 0.3.7 → 0.3.8-dev.1000

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
@@ -382,6 +400,14 @@ export class JSRouter {
   }
 
   /** List packages the router has registered. */
+  /** The user opened a running miniapp again; the source rides the next respawn too. */
+  notifyLaunch(packageName: string, launchSource: MiniappLaunchSource): void {
+    if (!this.registered.has(packageName)) return
+    const cached = this.spawnCache.get(packageName)
+    if (cached) cached.launchSource = launchSource
+    this.runtime.sendLaunchChange(packageName, launchSource)
+  }
+
   registeredPackages(): string[] {
     return Array.from(this.registered)
   }
@@ -483,13 +509,18 @@ export class JSRouter {
     if (iface === "__error") {
       const payload = this.tryParseArgs(msg.argsJson)
       this.logger.error(`[${packageName}] ${method}`, payload)
+      // Crashes reach the `glassly dev` terminal too, not only console calls.
+      const summary = this.summarizeReason(payload, method)
+      const stack = (payload as {stack?: unknown} | null)?.stack
+      const errorArgs = typeof stack === "string" && stack ? [summary, stack] : [summary]
+      devServerBridge.forwardLog(packageName, "error", errorArgs, Date.now(), "background")
       if (this.crashController) {
         // Only treat "exception" + "unhandledRejection" + "uncaught" as
         // crash signals. `console.error` calls also flow through the
         // log path — those don't end the JSContext.
         const isCrash = method === "exception" || method === "unhandledRejection" || method === "uncaught"
         if (isCrash) {
-          this.handleCrash(packageName, this.summarizeReason(payload, method))
+          this.handleCrash(packageName, summary)
         }
       }
       return

package/src/services/LocalDisplayManager.ts

@@ -627,6 +627,9 @@ class LocalDisplayManager {
         this.currentDisplay &&
         this.currentDisplay.packageName === this.backgroundLock.packageName
       if (bgHoldsAndDisplays) {
+        // The retained scene is now older than the saved frame; forget it so
+        // the restore paints this frame rather than replaying the stale one.
+        sceneRenderer.clearApp(packageName)
         resolve?.({status: "blocked", reason: "a background app holds the display"})
         return
       }
@@ -974,8 +977,8 @@ class LocalDisplayManager {
           }, delay)
         }
       } else {
-        // Retained state gone (app stopped since) — re-render the saved
-        // elements as a fresh scene instead.
+        // Retained state gone (app stopped, or its newer frame was blocked) —
+        // re-render the saved elements as a fresh scene instead.
         this.sendNow(saved.packageName, {view: "main", scene: saved.scene, durationMs: remaining})
       }
       return

package/src/services/LocalMiniappRuntime.ts

@@ -57,6 +57,7 @@ import type {AiTier, AiTierProvider, SavedLlmKeys} from "./AiTierResolution"
 import {decideLlmRoute, localLlmReason, type LocalLlmReason} from "./LlmRouting"
 import localLlmModelManager from "./LocalLlmModelManager"
 import localLlmProvider from "./LocalLlmProvider"
+import offlineActivity from "./OfflineActivity"
 import {HttpError} from "@glassly/cloud-client"
 import type {
   QuotaStatusPayload,
@@ -304,6 +305,20 @@ function withTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T | nul
   })
 }
 
+/** Bounds the cold-GPS wait for a one-shot poll; on a stall, any older fix beats an error. */
+const FRESH_LOCATION_TIMEOUT_MS = 8_000
+
+async function freshLocationOrStale(): Promise<Location.LocationObject> {
+  const fresh = await withTimeout(
+    Location.getCurrentPositionAsync({accuracy: Location.Accuracy.Low}),
+    FRESH_LOCATION_TIMEOUT_MS,
+  )
+  if (fresh) return fresh
+  const stale = await Location.getLastKnownPositionAsync()
+  if (stale) return stale
+  throw new Error("No location fix available")
+}
+
 const LOG_TAG = "LOCAL_MINIAPP"
 const DIAGNOSTIC_MAX_LIST_ITEMS = 100
 const DIAGNOSTIC_MAX_STRING_LENGTH = 512
@@ -326,6 +341,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
@@ -1235,21 +1252,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)
@@ -1659,11 +1681,11 @@ class LocalMiniappRuntime {
         this.handleOpenUrl(packageName, payload)
         break
       case MiniappRequestType.DISPLAY_DIAGNOSTICS: {
-        // The records are parsed out of the G2PERF lines, which the SDK only logs while g2_perf_logs is on.
+        // The records are parsed out of the G2PERF lines, which the SDK only logs while perf_logs is on.
         const settings = useSettingsStore.getState()
         const enabled =
           settings.getSetting(SETTINGS.debug_console.key) === true &&
-          settings.getSetting(SETTINGS.g2_perf_logs.key) === true
+          settings.getSetting(SETTINGS.perf_logs.key) === true
         this.sendResult(packageName, requestId, true, {
           enabled,
           generatedAt: Date.now(),
@@ -3450,7 +3472,7 @@ class LocalMiniappRuntime {
       const locationStartedAt = Date.now()
       const cached = await Location.getLastKnownPositionAsync({maxAge: 60_000})
       console.log(`${LOG_TAG}: location poll cache hit=${cached !== null} elapsed=${Date.now() - locationStartedAt}ms`)
-      const location = cached ?? (await Location.getCurrentPositionAsync({accuracy: Location.Accuracy.Low}))
+      const location = cached ?? (await freshLocationOrStale())
       console.log(`${LOG_TAG}: location poll resolved elapsed=${Date.now() - locationStartedAt}ms`)
 
       this.sendResult(packageName, requestId, true, {
@@ -4322,6 +4344,7 @@ class LocalMiniappRuntime {
       return
     }
 
+    const endActivity = offlineActivity.beginLlm(reason, localLlmModelManager.model(modelId).label)
     try {
       // webSearch is a vendor server-side grant; the phone has none.
       const {webSearch: _webSearch, ...localRequest} = request
@@ -4346,6 +4369,8 @@ class LocalMiniappRuntime {
         undefined,
         primaryError ?? {code: MiniappErrorCode.AI_LOCAL_UNAVAILABLE, message},
       )
+    } finally {
+      endActivity()
     }
   }
 
@@ -6071,13 +6096,16 @@ class LocalMiniappRuntime {
   private async startInteropApp(packageName: string): Promise<boolean> {
     const app = this.interopApps().find((a) => a.packageName === packageName)
     if (!app) return false
-    // 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})
-    if (app.local) {
-      await miniappLauncher.ensureConnected(packageName)
-      return true
-    }
-    return useAppStatusStore.getState().start(app, {skipNavigation: true})
+    // 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
+    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> {
@@ -6851,6 +6879,17 @@ class LocalMiniappRuntime {
     this.sendToMiniapp(packageName, {type: MiniappResponseType.LINK, params})
   }
 
+  /**
+   * Tell a running miniapp the user opened it again and from where. The
+   * CONNECT_ACK only carries the source of the spawn, which is stale for a
+   * background app that keeps running between opens.
+   */
+  public sendLaunchChange(packageName: string, launchSource: MiniappLaunchSource): void {
+    const existing = this.connectedApps.get(packageName)
+    if (existing) existing.launchSource = launchSource
+    this.sendToMiniapp(packageName, {type: MiniappResponseType.LAUNCH_CHANGE, launchSource})
+  }
+
   /**
    * Send a VISIBILITY_CHANGE push to a miniapp.
    */

package/src/services/LocalSttFallbackCoordinator.ts

@@ -2,6 +2,7 @@ import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
 import {ISLAND_SETTINGS_KEYS} from "../runtime/config"
 import {useSettingsStore} from "../stores/settings"
 import {cloudClientService} from "./CloudClientService"
+import offlineActivity from "./OfflineActivity"
 import sttModelManager from "./STTModelManager"
 
 /**
@@ -223,6 +224,9 @@ class LocalSttFallbackCoordinator {
 
   private publishReason(): void {
     const reason = this.localActive ? this.currentReason() : ""
+    offlineActivity.setTranscription(
+      this.localActive ? {reason: this.currentReason(), model: sttModelManager.currentModelLabel()} : null,
+    )
     const store = useSettingsStore.getState()
     if (store.getSetting(ISLAND_SETTINGS_KEYS.localSttFallbackReason) !== reason) {
       store.setSetting(ISLAND_SETTINGS_KEYS.localSttFallbackReason, reason)

package/src/services/LocalTranslationService.ts

@@ -1,3 +1,4 @@
+import offlineActivity, {type ServedTranslationPair} from "./OfflineActivity"
 import {offlineTranslationManager} from "./OfflineTranslationManager"
 
 /** One concrete-target `translation:<source>:<target>` stream and who listens to it. */
@@ -67,6 +68,7 @@ export class LocalTranslationService {
 
   attach(host: Host): void {
     this.host = host
+    offlineActivity.setTranslationSource(() => this.servedPairs())
   }
 
   setSubscriptions(subscriptions: LocalTranslationSubscription[]): void {
@@ -75,6 +77,24 @@ export class LocalTranslationService {
     for (const key of this.lanes.keys()) {
       if (!live.has(key.substring(key.indexOf(">") + 1))) this.lanes.delete(key)
     }
+    offlineActivity.refresh()
+  }
+
+  servedPairs(): ServedTranslationPair[] {
+    if (!this.host || !offlineTranslationManager.isSupported()) return []
+    const pairs = new Map<string, ServedTranslationPair>()
+    let primaryUp: boolean | null = null
+    for (const sub of this.subscriptions) {
+      if (baseLanguage(sub.source) === baseLanguage(sub.target)) continue
+      if (!sub.forceLocal) {
+        primaryUp ??= this.host.primaryUp()
+        if (primaryUp || !sub.cloud) continue
+      }
+      const key = `${sub.source}>${sub.target}`
+      const existing = pairs.get(key)
+      pairs.set(key, {source: sub.source, target: sub.target, forceLocal: sub.forceLocal || !!existing?.forceLocal})
+    }
+    return [...pairs.values()]
   }
 
   onLocalTranscript(transcript: LocalTranscript, sourceLanguage: string): void {

package/src/services/MiniappEngine.ts

@@ -29,42 +29,77 @@ export interface MiniappEngine {
 
 let engine: MiniappEngine | null = null
 
+/**
+ * Kill and re-spawn a miniapp's background JSContext from its installed bundle
+ * (dev: the dev server's fresh build). Resolves false when it isn't installed
+ * or the spawn failed.
+ */
+async function respawnBackground(router: JSRouter, uiRouter: UIRouter, packageName: string): Promise<boolean> {
+  // Re-resolve the freshly built bundle (dev: HTTP off the dev server;
+  // released: file:// snapshot) via the launcher's shared recipe. Carries
+  // the declared permissions + manifest across the respawn — omitting them
+  // would respawn the JSContext with no permissions, so SUBSCRIBE gates and
+  // per-call dispatch checks would start rejecting after a background
+  // hot-reload.
+  const resolved = await miniappLauncher.resolveBundle(packageName)
+  if (!resolved) {
+    console.warn(`JSRuntime: respawn-bg could not resolve bundle for ${packageName}`)
+    return false
+  }
+  // Force a respawn (kill + spawn) rather than launcher.ensureRunning,
+  // which is idempotent and would no-op an already-registered context.
+  await router.unregister(packageName)
+  const ok = await router.spawnAndRegister(packageName, resolved.bgSource, {
+    permissions: resolved.declaredPermissions,
+    installedManifest: resolved.installedManifest,
+  })
+  if (!ok) {
+    console.warn(`JSRuntime: respawn-bg failed for ${packageName}`)
+    return false
+  }
+  // The respawned JSContext is a fresh MiniappSession with ui.bound false.
+  // The mounted WebView won't re-fire glassly.ready() (it's latched), so
+  // re-announce it so RPC replies (glassly.request) reach the UI again
+  // instead of being dropped while unbound.
+  uiRouter.notifyReopen(packageName)
+  return true
+}
+
 function wireDevServerRespawnBackground(router: JSRouter, uiRouter: UIRouter): void {
   devServerBridge.onRespawnBackground(async (packageName) => {
     try {
-      // Re-resolve the freshly built bundle (dev: HTTP off the dev server;
-      // released: file:// snapshot) via the launcher's shared recipe. Carries
-      // the declared permissions + manifest across the respawn — omitting them
-      // would respawn the JSContext with no permissions, so SUBSCRIBE gates and
-      // per-call dispatch checks would start rejecting after a background
-      // hot-reload.
-      const resolved = await miniappLauncher.resolveBundle(packageName)
-      if (!resolved) {
-        console.warn(`JSRuntime: respawn-bg could not resolve bundle for ${packageName}`)
-        return
-      }
-      // Force a respawn (kill + spawn) rather than launcher.ensureRunning,
-      // which is idempotent and would no-op an already-registered context.
-      await router.unregister(packageName)
-      const ok = await router.spawnAndRegister(packageName, resolved.bgSource, {
-        permissions: resolved.declaredPermissions,
-        installedManifest: resolved.installedManifest,
-      })
-      if (!ok) {
-        console.warn(`JSRuntime: respawn-bg failed for ${packageName}`)
-        return
-      }
-      // The respawned JSContext is a fresh MiniappSession with ui.bound false.
-      // The mounted WebView won't re-fire glassly.ready() (it's latched), so
-      // re-announce it so RPC replies (glassly.request) reach the UI again
-      // instead of being dropped while unbound.
-      uiRouter.notifyReopen(packageName)
+      await respawnBackground(router, uiRouter, packageName)
     } catch (e) {
       console.warn(`JSRuntime: respawn-bg threw for ${packageName}:`, e)
     }
   })
 }
 
+/** Packages with a live background JSContext. */
+export function runningMiniappPackages(): string[] {
+  return engine?.router.registeredPackages() ?? []
+}
+
+/** Tear down a miniapp's background JSContext; a no-op when it isn't running. */
+export async function stopMiniapp(packageName: string): Promise<void> {
+  await engine?.router.unregister(packageName)
+}
+
+/**
+ * Start (or restart) a miniapp's background so it reads its storage afresh (an
+ * app state restore). Resolves false when the engine isn't up or the spawn failed.
+ */
+export async function respawnMiniapp(packageName: string): Promise<boolean> {
+  const current = engine
+  if (!current) return false
+  try {
+    return await respawnBackground(current.router, current.uiRouter, packageName)
+  } catch (e) {
+    console.warn(`JSRuntime: respawn threw for ${packageName}:`, e)
+    return false
+  }
+}
+
 /**
  * Construct (once) and return the JSRuntime engine singletons. Starts the router's
  * message pump on first call. Subsequent calls return the same instances.

package/src/services/MiniappLauncher.ts

@@ -91,6 +91,11 @@ class MiniappLauncher {
   }
 
   /** True iff the package's background JS context is currently spawned. */
+  /** Tell an already-running miniapp the user opened it again and from where. */
+  notifyLaunch(packageName: string, launchSource: MiniappLaunchSource): void {
+    this.deps?.router.notifyLaunch(packageName, launchSource)
+  }
+
   isRunning(packageName: string): boolean {
     return this.deps?.router.registeredPackages().includes(packageName) ?? false
   }
@@ -228,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/NavigationService.ts

@@ -16,6 +16,7 @@ import CrustModule from "@glassly/crust"
 import {resolveMapboxAccessToken, resolveMapboxRenderToken, userMapboxApiKey} from "./MapboxTokenService"
 import {decodePolyline, parseDurationSeconds} from "./navigation/routesApiCodec"
 import {resolveStepRoads} from "./navigation/roadNameResolver"
+import {BgTimer} from "../utils/timers"
 
 const LOG_TAG = "NAV_SERVICE"
 
@@ -394,7 +395,7 @@ class NavigationService {
     sessionToken: string,
   ): Promise<{
     ok: boolean
-    suggestions?: Array<{placeId: string; mainText: string; secondaryText: string}>
+    suggestions?: Array<{placeId: string; mainText: string; secondaryText: string; distanceMeters?: number}>
     error?: string
   }> {
     return placeAutocompleteViaSearchBox(query, near, sessionToken)
@@ -506,6 +507,19 @@ export default navigationService
 const MAPBOX_DIRECTIONS_BASE = "https://api.mapbox.com/directions/v5/mapbox"
 const MAPBOX_GEOCODE_REVERSE = "https://api.mapbox.com/search/geocode/v6/reverse"
 const MAPBOX_SEARCHBOX_SUGGEST = "https://api.mapbox.com/search/searchbox/v1/suggest"
+
+/** Place search sits in front of a voice command; a stalled call must fail over, not hang. */
+const PLACE_SEARCH_TIMEOUT_MS = 6_000
+
+async function fetchWithTimeout(url: string, timeoutMs: number): Promise<Response> {
+  const controller = new AbortController()
+  const timer = BgTimer.setTimeout(() => controller.abort(), timeoutMs)
+  try {
+    return await fetch(url, {method: "GET", signal: controller.signal})
+  } finally {
+    BgTimer.clearTimeout(timer)
+  }
+}
 const MAPBOX_SEARCHBOX_RETRIEVE = "https://api.mapbox.com/search/searchbox/v1/retrieve"
 
 /**
@@ -818,7 +832,7 @@ async function placeAutocompleteViaSearchBox(
   sessionToken: string,
 ): Promise<{
   ok: boolean
-  suggestions?: Array<{placeId: string; mainText: string; secondaryText: string}>
+  suggestions?: Array<{placeId: string; mainText: string; secondaryText: string; distanceMeters?: number}>
   error?: string
 }> {
   if (!query.trim()) return {ok: true, suggestions: []}
@@ -837,11 +851,14 @@ async function placeAutocompleteViaSearchBox(
     types: "poi,address,place,street",
     limit: "10",
   })
-  // Mapbox wants lng,lat for proximity bias.
-  if (near) params.set("proximity", `${near.lng},${near.lat}`)
+  // Mapbox wants lng,lat for proximity bias; `origin` adds per-suggestion distance.
+  if (near) {
+    params.set("proximity", `${near.lng},${near.lat}`)
+    params.set("origin", `${near.lng},${near.lat}`)
+  }
 
   try {
-    const res = await fetch(`${MAPBOX_SEARCHBOX_SUGGEST}?${params.toString()}`, {method: "GET"})
+    const res = await fetchWithTimeout(`${MAPBOX_SEARCHBOX_SUGGEST}?${params.toString()}`, PLACE_SEARCH_TIMEOUT_MS)
     if (!res.ok) return {ok: false, error: `Search Box suggest ${res.status}`}
     const json = (await res.json()) as {
       suggestions?: Array<{
@@ -849,6 +866,7 @@ async function placeAutocompleteViaSearchBox(
         name?: string
         place_formatted?: string
         full_address?: string
+        distance?: number
       }>
     }
     const suggestions = (json.suggestions ?? [])
@@ -857,6 +875,7 @@ async function placeAutocompleteViaSearchBox(
         placeId: s.mapbox_id,
         mainText: s.name ?? "",
         secondaryText: s.place_formatted ?? s.full_address ?? "",
+        ...(typeof s.distance === "number" ? {distanceMeters: s.distance} : {}),
       }))
     return {ok: true, suggestions}
   } catch (err) {
@@ -890,9 +909,10 @@ async function placeDetailsViaSearchBox(
   }
   const params = new URLSearchParams({access_token: token, session_token: sessionToken})
   try {
-    const res = await fetch(`${MAPBOX_SEARCHBOX_RETRIEVE}/${encodeURIComponent(placeId)}?${params.toString()}`, {
-      method: "GET",
-    })
+    const res = await fetchWithTimeout(
+      `${MAPBOX_SEARCHBOX_RETRIEVE}/${encodeURIComponent(placeId)}?${params.toString()}`,
+      PLACE_SEARCH_TIMEOUT_MS,
+    )
     if (!res.ok) return {ok: false, error: `Search Box retrieve ${res.status}`}
     const json = (await res.json()) as {
       features?: Array<{

package/src/services/OfflineActivity.ts

@@ -0,0 +1,131 @@
+/**
+ * What the phone is running on-device right now (transcription, translation,
+ * LLM) and why, for the home offline card. Producers push in; it imports
+ * nothing at runtime so their test stubs stay unaffected.
+ */
+import type {LocalLlmReason} from "./LlmRouting"
+import type {LocalSttFallbackReason} from "./LocalSttFallbackCoordinator"
+
+export type OfflineActivityReason = LocalSttFallbackReason | LocalLlmReason
+
+export interface OfflineTranscriptionActivity {
+  reason: LocalSttFallbackReason
+  model: string
+}
+
+export interface OfflineTranslationPair {
+  source: string
+  target: string
+}
+
+export interface OfflineTranslationActivity {
+  reason: OfflineActivityReason
+  pairs: OfflineTranslationPair[]
+}
+
+export interface OfflineLlmActivity {
+  reason: LocalLlmReason
+  model: string
+  requests: number
+}
+
+export interface OfflineActivity {
+  transcription: OfflineTranscriptionActivity | null
+  translation: OfflineTranslationActivity | null
+  llm: OfflineLlmActivity | null
+}
+
+export interface ServedTranslationPair extends OfflineTranslationPair {
+  forceLocal: boolean
+}
+
+const EMPTY: OfflineActivity = {transcription: null, translation: null, llm: null}
+
+class OfflineActivityTracker {
+  private transcription: OfflineTranscriptionActivity | null = null
+  private llmRuns: Array<{reason: LocalLlmReason; model: string}> = []
+  private translationSource: (() => ServedTranslationPair[]) | null = null
+  private snapshot: OfflineActivity = EMPTY
+  private snapshotKey = JSON.stringify(EMPTY)
+  private listeners = new Set<(activity: OfflineActivity) => void>()
+
+  current(): OfflineActivity {
+    return this.snapshot
+  }
+
+  subscribe(listener: (activity: OfflineActivity) => void): () => void {
+    this.listeners.add(listener)
+    return () => {
+      this.listeners.delete(listener)
+    }
+  }
+
+  setTranscription(transcription: OfflineTranscriptionActivity | null): void {
+    this.transcription = transcription
+    this.refresh()
+  }
+
+  beginLlm(reason: LocalLlmReason, model: string): () => void {
+    const run = {reason, model}
+    this.llmRuns.push(run)
+    this.refresh()
+    let ended = false
+    return () => {
+      if (ended) return
+      ended = true
+      this.llmRuns = this.llmRuns.filter((r) => r !== run)
+      this.refresh()
+    }
+  }
+
+  setTranslationSource(source: (() => ServedTranslationPair[]) | null): void {
+    this.translationSource = source
+    this.refresh()
+  }
+
+  refresh(): void {
+    const next: OfflineActivity = {
+      transcription: this.transcription,
+      translation: this.translation(),
+      llm: this.llm(),
+    }
+    const key = JSON.stringify(next)
+    if (key === this.snapshotKey) return
+    this.snapshotKey = key
+    this.snapshot = next
+    for (const listener of this.listeners) {
+      try {
+        listener(next)
+      } catch (error) {
+        console.warn("OfflineActivity: listener failed:", error)
+      }
+    }
+  }
+
+  reset(): void {
+    this.transcription = null
+    this.llmRuns = []
+    this.translationSource = null
+    this.refresh()
+  }
+
+  private translation(): OfflineTranslationActivity | null {
+    if (!this.transcription || !this.translationSource) return null
+    const pairs = this.translationSource()
+    if (pairs.length === 0) return null
+    return {
+      reason: pairs.some((p) => p.forceLocal) ? "force_local" : this.transcription.reason,
+      pairs: pairs.map(({source, target}) => ({source, target})),
+    }
+  }
+
+  private llm(): OfflineLlmActivity | null {
+    const latest = this.llmRuns[this.llmRuns.length - 1]
+    if (!latest) return null
+    return {reason: latest.reason, model: latest.model, requests: this.llmRuns.length}
+  }
+}
+
+export {OfflineActivityTracker}
+const offlineActivity = new OfflineActivityTracker()
+export default offlineActivity