@mentra/engine 0.1.0-beta.0 → 0.1.0-dev.1

package/src/services/LocalMiniappRuntime.ts

@@ -9,7 +9,7 @@
  * management (connect/disconnect/ping).
  */
 
-import {Linking} from "react-native"
+import {AppState, Linking} from "react-native"
 import Share from "react-native-share"
 import * as Battery from "expo-battery"
 import * as Clipboard from "expo-clipboard"
@@ -51,6 +51,8 @@ import {phoneStreamCoordinator} from "./PhoneStreamCoordinator"
 import {phoneVideoCoordinator} from "./PhoneVideoCoordinator"
 import {runSentenceTtsPipeline} from "./SentenceTtsPipeline"
 import {summarizeTranscriptionRoutes, transcriptionDeliveryRoute} from "./TranscriptionRouting"
+import {prepareTtsSentences} from "./TtsTextSanitizer"
+import {handleWifiAdbRequest} from "./WifiAdbRequest"
 import {cloudClientService} from "./CloudClientService"
 import {miniappLauncher} from "./MiniappLauncher"
 import {
@@ -64,25 +66,38 @@ import {
   type TtsSynthesisResult,
 } from "../runtime/config"
 import {getAnalytics, getUiSeams} from "../runtime/bootstrap"
+import {invokeScanQrSeam} from "../runtime/scanQrSeam"
 import {normalizeStreamAudioConfig, normalizeStreamVideoConfig} from "../runtime/streamConfig"
+import {toLanguageHint} from "@mentra/cloud-protocol/languages"
 import type {AudioSubscription, LanguageSource, TranscriptionData, TranslationData} from "@mentra/cloud-protocol"
+import {buildMiniappManifestSnapshot, type MiniappRuntimeDiagnosticSnapshot} from "../utils/miniappDiagnostics"
 import ttsModelManager from "./TTSModelManager"
 import {NavigationHandlers} from "./NavigationHandlers"
 import type {ClientApp} from "../types/applet"
 import {useAppStatusStore} from "../stores/apps"
 import {getDevAppAttestation, getDevAppSourcePackage} from "./AppRegistry"
+import {resolveForegroundLocationPermission} from "./ForegroundLocationPermission"
+import {advanceMiniappPingLiveness} from "./MiniappLiveness"
 import {listPhoneCalendarEvents, PhoneCalendarError} from "./PhoneCalendarService"
+import {LocalMiniappStorage} from "./LocalMiniappStorage"
 
 // =============================================================================
 // Types
 // =============================================================================
 
 export interface InstalledMiniappManifest {
+  packageName?: string
   /** Human-facing app name (from miniapp.json `name`). Shown in the "Starting
    * <name>…" boot message; falls back to the package name when absent. */
   name?: string
+  version?: string
+  sdkVersion?: string
+  minHostVersion?: string
+  type?: string
+  entry?: {background?: string; ui?: string}
   permissions?: Array<{type: string; required?: boolean; description?: string}>
   hardwareRequirements?: Array<{type: string; level: string; description?: string}>
+  actions?: Array<{id?: unknown; description?: unknown; parameters?: unknown; outputSchema?: unknown}>
 }
 
 type SpeakerStateValue = "idle" | "loading" | "playing" | "stopped" | "error"
@@ -95,6 +110,7 @@ interface ConnectedMiniapp {
   cloudTranscriptionStreams: Set<string>
   sendMessage: (raw: string) => void
   lastPongAt: number
+  unansweredPingRounds: number
   installedManifest?: InstalledMiniappManifest
   authRefreshTimerId: number | null
   /**
@@ -168,6 +184,16 @@ function withTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T | nul
 }
 
 const LOG_TAG = "LOCAL_MINIAPP"
+const DIAGNOSTIC_MAX_LIST_ITEMS = 100
+const DIAGNOSTIC_MAX_STRING_LENGTH = 512
+
+function diagnosticStringList(values: Iterable<string>): string[] {
+  return [...values]
+    .map((value) => value.slice(0, DIAGNOSTIC_MAX_STRING_LENGTH))
+    .sort()
+    .slice(0, DIAGNOSTIC_MAX_LIST_ITEMS)
+}
+
 const SYSTEM_MINIAPP_PACKAGES = new Set([
   "com.mentra.camera",
   "com.mentra.gallery",
@@ -205,10 +231,29 @@ const RGB_LED_ACTIONS = new Set<RgbLedAction>(["on", "off"])
 const RGB_LED_COLORS = new Set<RgbLedColor>(["red", "green", "blue", "orange", "white"])
 const CAMERA_FOV_MIN = 62
 const CAMERA_FOV_MAX = 118
-const CAMERA_FOV_DEFAULT = 102
-const CAMERA_FOV_PRESETS: Record<CameraFovPreset, number> = {narrow: 82, standard: CAMERA_FOV_DEFAULT, wide: 118}
+const CAMERA_FOV_DEFAULT = 118
+const CAMERA_FOV_PRESETS: Record<CameraFovPreset, number> = {narrow: 82, standard: 102, wide: 118}
 const CAMERA_ROI_POSITION_BY_NAME: Record<string, CameraRoiPosition> = {center: "center", bottom: "bottom", top: "top"}
 
+const localMiniappStorageBackend = {
+  get(key: string): unknown | null {
+    const result = mmkvStorage.load<unknown>(key)
+    return result.is_ok() ? result.value : null
+  },
+  has(key: string): boolean {
+    return mmkvStorage.load<unknown>(key).is_ok()
+  },
+  set(key: string, value: unknown): void {
+    mmkvStorage.save(key, value)
+  },
+  remove(key: string): void {
+    mmkvStorage.remove(key)
+  },
+  keys(): string[] {
+    return mmkvStorage.getAllKeys()
+  },
+}
+
 // =============================================================================
 // Declared-permission record helper (for CONNECT_ACK / PERMISSIONS_UPDATE)
 // =============================================================================
@@ -350,11 +395,22 @@ class LocalMiniappRuntime {
   /** Ref-counted stream subscriptions: stream → set of packageNames. */
   private streamSubscribers: Map<string, Set<string>> = new Map()
 
+  /** Host observers for the Mentra Live button-capture policy. */
+  private buttonPressSubscriberListeners = new Set<(packageNames: string[]) => void>()
+
   /** Guards one-time wiring of the cloud transcript/translation fan-out. */
   private cloudResultsWired = false
   private cloudStatusWired = false
   private cloudAudioSubscriptionSync = new CloudAudioSubscriptionSync()
 
+  /**
+   * Per-miniapp language hints from TRANSCRIPTION_CONFIG (issue 021 WP3).
+   * Bare ISO 639-1 codes, already registry-validated by the SDK and
+   * re-normalized here (defense in depth). Merged (union) into the auto-mode
+   * cloud transcription subscription in buildCloudAudioSubscriptions.
+   */
+  private transcriptionHintsByApp = new Map<string, string[]>()
+
   /** Ping interval handle. */
   private pingIntervalId: number | null = null
   private foregroundProbeTimers: Map<string, number> = new Map()
@@ -381,6 +437,99 @@ class LocalMiniappRuntime {
 
   private constructor() {}
 
+  /** Snapshot of miniapps actively subscribed to hardware button events. */
+  public getButtonPressSubscribers(): string[] {
+    return [...(this.streamSubscribers.get(MiniappStreamType.BUTTON_PRESS) ?? [])].sort()
+  }
+
+  /** Observe active hardware-button subscriptions. */
+  public onButtonPressSubscribersChanged(listener: (packageNames: string[]) => void): () => void {
+    this.buttonPressSubscriberListeners.add(listener)
+    return () => this.buttonPressSubscriberListeners.delete(listener)
+  }
+
+  /** Report-safe live miniapp/subscription/resource snapshot. */
+  public getDiagnosticSnapshot(nowMs = Date.now()): MiniappRuntimeDiagnosticSnapshot {
+    const connectedApps = [...this.connectedApps.entries()]
+      .sort(([a], [b]) => a.localeCompare(b))
+      .slice(0, DIAGNOSTIC_MAX_LIST_ITEMS)
+      .map(([packageName, app]) => ({
+        packageName: packageName.slice(0, DIAGNOSTIC_MAX_STRING_LENGTH),
+        handshakeComplete: this.handshookApps.has(packageName),
+        subscriptions: diagnosticStringList(app.subscriptions),
+        lastMessageAgeMs: Math.max(0, nowMs - app.lastPongAt),
+        requestedLocationRate: app.requestedLocationRate,
+        hasActiveSpeakerStream: app.activeSpeakerStreamId !== undefined,
+        ...(app.installedManifest
+          ? {
+              manifest: buildMiniappManifestSnapshot(app.installedManifest, {
+                packageName,
+                name: app.installedManifest.name,
+                version: app.installedManifest.version,
+                type: app.installedManifest.type,
+              }),
+            }
+          : {}),
+      }))
+    const subscriptionsByStream = Object.fromEntries(
+      [...this.streamSubscribers.entries()]
+        .filter(([, packageNames]) => packageNames.size > 0)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .slice(0, DIAGNOSTIC_MAX_LIST_ITEMS)
+        .map(([stream, packageNames]) => [
+          stream.slice(0, DIAGNOSTIC_MAX_STRING_LENGTH),
+          diagnosticStringList(packageNames),
+        ]),
+    )
+
+    return {
+      connectedApps,
+      subscriptionsByStream,
+      resources: {
+        display: localDisplayManager.getDiagnosticSnapshot(),
+        camera: phonePhotoCoordinator.getDiagnosticSnapshot(),
+        video: phoneVideoCoordinator.getDiagnosticSnapshot(),
+        stream: phoneStreamCoordinator.getDiagnosticSnapshot(),
+        cameraFov: phoneCameraFovCoordinator.getDiagnosticSnapshot(),
+      },
+    }
+  }
+
+  private replaceStreamSubscribers(
+    packageName: string,
+    previousStreams: Iterable<string>,
+    nextStreams: Iterable<string>,
+  ) {
+    const previousButtonSubscribers = this.getButtonPressSubscribers().join("\u0000")
+
+    for (const stream of previousStreams) {
+      const subscribers = this.streamSubscribers.get(stream)
+      if (!subscribers) continue
+      subscribers.delete(packageName)
+      if (subscribers.size === 0) this.streamSubscribers.delete(stream)
+    }
+
+    for (const stream of nextStreams) {
+      let subscribers = this.streamSubscribers.get(stream)
+      if (!subscribers) {
+        subscribers = new Set()
+        this.streamSubscribers.set(stream, subscribers)
+      }
+      subscribers.add(packageName)
+    }
+
+    const nextButtonSubscribers = this.getButtonPressSubscribers()
+    if (previousButtonSubscribers !== nextButtonSubscribers.join("\u0000")) {
+      for (const listener of this.buttonPressSubscriberListeners) {
+        try {
+          listener(nextButtonSubscribers)
+        } catch (error) {
+          console.warn(`${LOG_TAG}: button press subscriber listener threw:`, error)
+        }
+      }
+    }
+  }
+
   /**
    * Generate an HMAC-signed local session token for browser fallback auth.
    * Token format: base64(JSON({userId, packageName, exp})).base64(HMAC-SHA256(payload, secret))
@@ -606,13 +755,7 @@ class LocalMiniappRuntime {
         BgTimer.clearTimeout(existing.authRetryTimerId)
         existing.authRetryTimerId = null
       }
-      for (const stream of existing.subscriptions) {
-        const subs = this.streamSubscribers.get(stream)
-        if (subs) {
-          subs.delete(packageName)
-          if (subs.size === 0) this.streamSubscribers.delete(stream)
-        }
-      }
+      this.replaceStreamSubscribers(packageName, existing.subscriptions, [])
       this.recomputeMicRequirements()
       this.updateCloudSubscriptions()
     }
@@ -622,6 +765,7 @@ class LocalMiniappRuntime {
       cloudTranscriptionStreams: new Set(),
       sendMessage: sendFn,
       lastPongAt: Date.now(),
+      unansweredPingRounds: 0,
       installedManifest,
       authRefreshTimerId: null,
       authRetryTimerId: null,
@@ -742,6 +886,7 @@ class LocalMiniappRuntime {
 
   public unregisterApp(packageName: string): void {
     console.log(`${LOG_TAG}: unregisterApp(${packageName})`)
+    const releasedMicGateOverride = micStateCoordinator.clearMiniappGateOverrides(packageName)
     this.clearForegroundProbe(packageName)
     this.clearMiniappAuthRefresh(packageName)
     this.clearMiniappAuthDeliveryRetry(packageName)
@@ -750,6 +895,9 @@ class LocalMiniappRuntime {
     // the early-return so it runs even if the connectedApps entry is already gone.
     this.handshookApps.delete(packageName)
     this.flushConnectWaiters(packageName, new Error(`${packageName} unregistered before connect`))
+    // Drop this app's transcription hints; the cloud subscription rebuild
+    // below (via replaceStreamSubscribers) re-derives the hint union without it.
+    this.transcriptionHintsByApp.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.
@@ -766,19 +914,18 @@ class LocalMiniappRuntime {
         console.warn(`${LOG_TAG}: failed to release camera FOV override for ${packageName} on unregister`, error)
       })
     const app = this.connectedApps.get(packageName)
-    if (!app) return
-
-    // Remove from all stream subscriber sets
-    for (const stream of app.subscriptions) {
-      const subs = this.streamSubscribers.get(stream)
-      if (subs) {
-        subs.delete(packageName)
-        if (subs.size === 0) {
-          this.streamSubscribers.delete(stream)
-        }
+    if (!app) {
+      if (releasedMicGateOverride) {
+        void micStateCoordinator.syncEffectiveGatePolicy(this.getConfiguredMicGates()).catch((error) => {
+          console.warn(`${LOG_TAG}: failed to restore mic gate policy for ${packageName}`, error)
+        })
       }
+      return
     }
 
+    // Remove from all stream subscriber sets
+    this.replaceStreamSubscribers(packageName, app.subscriptions, [])
+
     // Reset per-session warning dedup so a relaunch surfaces issues again.
     resetPermissionWarnings(packageName)
 
@@ -844,6 +991,11 @@ class LocalMiniappRuntime {
 
     this.connectedApps.delete(packageName)
     this.recomputeMicRequirements()
+    if (releasedMicGateOverride) {
+      void micStateCoordinator.syncEffectiveGatePolicy(this.getConfiguredMicGates()).catch((error) => {
+        console.warn(`${LOG_TAG}: failed to restore mic gate policy for ${packageName}`, error)
+      })
+    }
     this.updateCloudSubscriptions()
 
     if (this.connectedApps.size === 0) {
@@ -1017,9 +1169,18 @@ class LocalMiniappRuntime {
       case MiniappRequestType.CAMERA_FOV:
         void this.handleCameraFov(packageName, payload, requestId)
         break
+      case MiniappRequestType.SET_WIFI_ADB_STATE:
+        void this.handleSetWifiAdbState(packageName, payload, requestId)
+        break
       case MiniappRequestType.IMU_SET_ENABLED:
         this.handleImuSetEnabled(packageName, payload, requestId)
         break
+      case MiniappRequestType.MIC_SET_VAD_ENABLED:
+        void this.handleMicSetVadEnabled(packageName, payload, requestId)
+        break
+      case MiniappRequestType.MIC_SET_LOUDNESS_GATE_ENABLED:
+        void this.handleMicSetLoudnessGateEnabled(packageName, payload, requestId)
+        break
       case MiniappRequestType.PING:
         // SDK should handle this itself; reply PONG just in case
         this.sendToMiniapp(packageName, {type: MiniappResponseType.PONG}, requestId)
@@ -1042,52 +1203,83 @@ class LocalMiniappRuntime {
       case MiniappRequestType.DOWNLOAD:
         this.handleDownload(packageName, payload, requestId)
         break
+      case MiniappRequestType.SCAN_QR:
+        void this.handleScanQr(packageName, payload, requestId)
+        break
 
       // Persistent binary blob storage (session.blob)
       case MiniappRequestType.BLOB_CREATE:
-        this.blobStore.handleCreate(packageName, payload, requestId)
+        this.enqueueBlobRequest(packageName, requestId, () =>
+          this.blobStore.handleCreate(packageName, payload, requestId),
+        )
         break
       case MiniappRequestType.BLOB_WRITE:
-        this.blobStore.handleWrite(packageName, payload, requestId)
+        this.enqueueBlobRequest(packageName, requestId, () =>
+          this.blobStore.handleWrite(packageName, payload, requestId),
+        )
         break
       case MiniappRequestType.BLOB_COMMIT:
-        this.blobStore.handleCommit(packageName, payload, requestId)
+        this.enqueueBlobRequest(packageName, requestId, () =>
+          this.blobStore.handleCommit(packageName, payload, requestId),
+        )
         break
       case MiniappRequestType.BLOB_ABORT:
-        this.blobStore.handleAbort(packageName, payload, requestId)
+        this.enqueueBlobRequest(packageName, requestId, () =>
+          this.blobStore.handleAbort(packageName, payload, requestId),
+        )
         break
       case MiniappRequestType.BLOB_SET_FROM_URL:
-        void this.blobStore.handleSetFromUrl(packageName, payload, requestId)
+        this.enqueueBlobRequest(packageName, requestId, () =>
+          this.blobStore.handleSetFromUrl(packageName, payload, requestId),
+        )
         break
       case MiniappRequestType.BLOB_IMPORT:
-        void this.blobStore.handleImport(packageName, payload, requestId)
+        this.enqueueBlobRequest(packageName, requestId, () =>
+          this.blobStore.handleImport(packageName, payload, requestId),
+        )
         break
       case MiniappRequestType.BLOB_GET:
-        this.blobStore.handleGet(packageName, payload, requestId)
+        this.enqueueBlobRequest(packageName, requestId, () => this.blobStore.handleGet(packageName, payload, requestId))
         break
       case MiniappRequestType.BLOB_LIST:
-        this.blobStore.handleList(packageName, payload, requestId)
+        this.enqueueBlobRequest(packageName, requestId, () =>
+          this.blobStore.handleList(packageName, payload, requestId),
+        )
         break
       case MiniappRequestType.BLOB_USAGE:
-        this.blobStore.handleUsage(packageName, payload, requestId)
+        this.enqueueBlobRequest(packageName, requestId, () =>
+          this.blobStore.handleUsage(packageName, payload, requestId),
+        )
         break
       case MiniappRequestType.BLOB_DELETE:
-        this.blobStore.handleDelete(packageName, payload, requestId)
+        this.enqueueBlobRequest(packageName, requestId, () =>
+          this.blobStore.handleDelete(packageName, payload, requestId),
+        )
         break
       case MiniappRequestType.BLOB_CLEAR:
-        this.blobStore.handleClear(packageName, payload, requestId)
+        this.enqueueBlobRequest(packageName, requestId, () =>
+          this.blobStore.handleClear(packageName, payload, requestId),
+        )
         break
       case MiniappRequestType.BLOB_OPEN_READ:
-        this.blobStore.handleOpenRead(packageName, payload, requestId)
+        this.enqueueBlobRequest(packageName, requestId, () =>
+          this.blobStore.handleOpenRead(packageName, payload, requestId),
+        )
         break
       case MiniappRequestType.BLOB_READ:
-        this.blobStore.handleRead(packageName, payload, requestId)
+        this.enqueueBlobRequest(packageName, requestId, () =>
+          this.blobStore.handleRead(packageName, payload, requestId),
+        )
         break
       case MiniappRequestType.BLOB_CLOSE_READ:
-        this.blobStore.handleCloseRead(packageName, payload, requestId)
+        this.enqueueBlobRequest(packageName, requestId, () =>
+          this.blobStore.handleCloseRead(packageName, payload, requestId),
+        )
         break
       case MiniappRequestType.BLOB_SHARE:
-        void this.blobStore.handleShare(packageName, payload, requestId)
+        this.enqueueBlobRequest(packageName, requestId, () =>
+          this.blobStore.handleShare(packageName, payload, requestId),
+        )
         break
 
       // Cloud-coordinated features
@@ -1144,8 +1336,20 @@ class LocalMiniappRuntime {
         })
         break
 
+      case MiniappRequestType.TRANSCRIPTION_CONFIG:
+        this.handleTranscriptionConfig(packageName, payload, requestId)
+        break
+
       default:
+        // NACK instead of silent drop (issue 021 S3): an SDK that sends a
+        // request this runtime doesn't implement must get a rejected promise,
+        // not a permanently-pending silent gap. One-shots (no requestId) can
+        // only be logged.
         console.warn(`${LOG_TAG}: Unknown request type from ${packageName}: ${requestType}`)
+        this.sendResult(packageName, requestId, false, undefined, {
+          code: MiniappErrorCode.NOT_IMPLEMENTED,
+          message: `Unknown or unimplemented request type: ${requestType}`,
+        })
         break
     }
   }
@@ -1170,6 +1374,7 @@ class LocalMiniappRuntime {
 
     // Update lastPongAt so it doesn't time out right away
     existing.lastPongAt = Date.now()
+    existing.unansweredPingRounds = 0
 
     // Read current glasses capabilities from the settings store
     const defaultWearable = useSettingsStore.getState().getSetting(ISLAND_SETTINGS_KEYS.defaultWearable) as
@@ -1377,6 +1582,51 @@ class LocalMiniappRuntime {
     }
   }
 
+  /**
+   * TRANSCRIPTION_CONFIG (issue 021 WP3): store the miniapp's language hints
+   * and rebuild the cloud subscription set so the auto-mode subscription
+   * carries them. Replies with a REQUEST_RESULT so the SDK's configure()
+   * promise settles: unknown hint values are an error, not a silent drop.
+   */
+  private handleTranscriptionConfig(packageName: string, payload: Record<string, unknown>, requestId?: string): void {
+    const app = this.connectedApps.get(packageName)
+    if (!app) return
+
+    const config = (payload.config ?? {}) as Record<string, unknown>
+    const rawHints = config.languageHints
+    if (rawHints !== undefined && !Array.isArray(rawHints)) {
+      this.sendResult(packageName, requestId, false, undefined, {
+        code: MiniappErrorCode.INTERNAL,
+        message: "languageHints must be an array of language codes",
+      })
+      return
+    }
+
+    if (rawHints === undefined || rawHints.length === 0) {
+      this.transcriptionHintsByApp.delete(packageName)
+    } else {
+      // Defense in depth: the SDK already validated, but the wire is untyped.
+      const hints: string[] = []
+      const invalid: string[] = []
+      for (const raw of rawHints as unknown[]) {
+        const hint = typeof raw === "string" ? toLanguageHint(raw) : null
+        if (hint) hints.push(hint)
+        else invalid.push(String(raw))
+      }
+      if (invalid.length > 0) {
+        this.sendResult(packageName, requestId, false, undefined, {
+          code: MiniappErrorCode.INTERNAL,
+          message: `Unknown language hint(s): ${invalid.join(", ")}`,
+        })
+        return
+      }
+      this.transcriptionHintsByApp.set(packageName, [...new Set(hints)].sort())
+    }
+
+    this.updateCloudSubscriptions()
+    this.sendResult(packageName, requestId, true, {applied: true})
+  }
+
   private handleSubscribe(packageName: string, payload: Record<string, unknown>, requestId?: string): void {
     const app = this.connectedApps.get(packageName)
     if (!app) return
@@ -1450,18 +1700,8 @@ class LocalMiniappRuntime {
       }
     }
 
-    // Remove old subscriptions for this app
-    for (const oldStream of app.subscriptions) {
-      const subs = this.streamSubscribers.get(oldStream)
-      if (subs) {
-        subs.delete(packageName)
-        if (subs.size === 0) {
-          this.streamSubscribers.delete(oldStream)
-        }
-      }
-    }
-
     // Add new subscriptions
+    const previousSubscriptions = app.subscriptions
     app.subscriptions = new Set(streams)
     app.forceLocalTranscriptionStreams = new Set(
       [...forceLocalTranscriptionStreams].filter((stream) => app.subscriptions.has(stream)),
@@ -1469,14 +1709,7 @@ class LocalMiniappRuntime {
     app.cloudTranscriptionStreams = new Set(
       [...cloudTranscriptionStreams].filter((stream) => app.subscriptions.has(stream)),
     )
-    for (const stream of streams) {
-      let subs = this.streamSubscribers.get(stream)
-      if (!subs) {
-        subs = new Set()
-        this.streamSubscribers.set(stream, subs)
-      }
-      subs.add(packageName)
-    }
+    this.replaceStreamSubscribers(packageName, previousSubscriptions, app.subscriptions)
 
     this.recomputeMicRequirements()
     this.updateCloudSubscriptions()
@@ -1966,16 +2199,21 @@ class LocalMiniappRuntime {
 
   private async handleSpeak(packageName: string, payload: Record<string, unknown>, requestId?: string): Promise<void> {
     const rawText = payload.text
-    const sentences =
+    const rawSentences =
       typeof rawText === "string"
         ? [rawText.trim()].filter(Boolean)
         : Array.isArray(rawText)
-          ? rawText.filter((sentence): sentence is string => typeof sentence === "string").map((sentence) => sentence.trim()).filter(Boolean)
+          ? rawText
+              .filter((sentence): sentence is string => typeof sentence === "string")
+              .map((sentence) => sentence.trim())
+              .filter(Boolean)
           : []
+    const enableSanitization = payload.enableSanitization !== false
+    const sentences = prepareTtsSentences(rawSentences, enableSanitization)
     if (sentences.length === 0) {
       this.sendResult(packageName, requestId, false, undefined, {
         code: MiniappErrorCode.INTERNAL,
-        message: "speak requires text or a non-empty sentence list",
+        message: "speak requires text or a non-empty sentence list with speakable content",
       })
       return
     }
@@ -2095,7 +2333,6 @@ class LocalMiniappRuntime {
                     appId: packageName,
                     volume,
                     stopOtherAudio,
-                    suppressCloudUplink: true,
                   },
                   (_responseId, success, error, duration, completionReason) => {
                     if (run.playbackRequestId === sentenceRequestId) run.playbackRequestId = undefined
@@ -2144,7 +2381,6 @@ class LocalMiniappRuntime {
             appId: packageName,
             volume,
             stopOtherAudio,
-            suppressCloudUplink: true,
           },
           (_respId, success, error, duration, completionReason) => {
             if (run.playbackRequestId === audioRequestId) run.playbackRequestId = undefined
@@ -2197,7 +2433,6 @@ class LocalMiniappRuntime {
               appId: packageName,
               volume,
               stopOtherAudio,
-              suppressCloudUplink: true,
             },
             (_respId, success, error, duration, completionReason) => {
               if (run.playbackRequestId === audioRequestId) run.playbackRequestId = undefined
@@ -2292,7 +2527,17 @@ class LocalMiniappRuntime {
 
   private async handleLocationPoll(packageName: string, requestId?: string): Promise<void> {
     try {
-      const {status} = await Location.requestForegroundPermissionsAsync()
+      // Expo's Android requestForegroundPermissionsAsync always delegates to
+      // Activity.requestPermissions(), even when permission is already granted.
+      // Calling it after the user presses Home therefore waits until the Activity
+      // resumes. Read the current grant first, and only enter the prompt flow
+      // while the Activity is actually foregrounded.
+      const permissionStartedAt = Date.now()
+      const permission = await resolveForegroundLocationPermission(Location, () => AppState.currentState)
+      const {status} = permission
+      console.log(
+        `${LOG_TAG}: location poll permission status=${status} appState=${AppState.currentState} elapsed=${Date.now() - permissionStartedAt}ms`,
+      )
       if (status !== "granted") {
         this.sendResult(packageName, requestId, false, undefined, {
           code: MiniappErrorCode.PERMISSION_NOT_DECLARED,
@@ -2305,8 +2550,11 @@ class LocalMiniappRuntime {
       // a fresh fix if the cache is empty. Use Low accuracy on the fresh
       // path so we get a cell/wifi-tower fix in ~1s instead of waiting
       // for full GPS warm-up.
+      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}))
+      console.log(`${LOG_TAG}: location poll resolved elapsed=${Date.now() - locationStartedAt}ms`)
 
       this.sendResult(packageName, requestId, true, {
         lat: location.coords.latitude,
@@ -2348,9 +2596,69 @@ class LocalMiniappRuntime {
   private readonly blobStore = new BlobStore({
     sendResult: (packageName, requestId, ok, result, error) =>
       this.sendResult(packageName, requestId, ok, result, error),
-    getUserId: () =>
-      (useSettingsStore.getState().getSetting(ISLAND_SETTINGS_KEYS.coreToken) as string | undefined) || "anonymous",
+    getUserId: () => cloudClientService.getMentraUserId(),
   })
+  private readonly blobRequestQueues = new Map<string, Promise<void>>()
+
+  private readonly simpleStorage = new LocalMiniappStorage({
+    backend: localMiniappStorageBackend,
+    getUserId: () => cloudClientService.resolveMentraUserId(),
+  })
+
+  /**
+   * BlobStore's file helpers are synchronous once a user namespace is selected,
+   * but first-boot Core auth is not. Queue requests per app behind stable
+   * identity resolution so CREATE/WRITE/COMMIT ordering survives that wait.
+   */
+  private enqueueBlobRequest(
+    packageName: string,
+    requestId: string | undefined,
+    operation: () => Promise<void> | void,
+  ): void {
+    const app = this.connectedApps.get(packageName)
+    const previous = this.blobRequestQueues.get(packageName) ?? Promise.resolve()
+    const queued = previous.then(async () => {
+      try {
+        await cloudClientService.resolveMentraUserId()
+      } catch (err) {
+        console.error(`${LOG_TAG}: blob identity error:`, err)
+        this.sendResult(packageName, requestId, false, undefined, {
+          code: MiniappErrorCode.NOT_CONNECTED,
+          message: "Blob storage is unavailable before sign-in completes",
+        })
+        return
+      }
+
+      // unregisterApp() or a crash-respawn may have replaced this app while
+      // identity resolution was pending. Never replay an old context's request
+      // against its replacement.
+      if (!app || this.connectedApps.get(packageName) !== app) return
+
+      // Invoke in request order, but do not keep the queue occupied for the
+      // lifetime of an async picker, download, or share sheet. CREATE/WRITE/
+      // COMMIT are synchronous and therefore still dispatch strictly in order.
+      try {
+        const pending = operation()
+        if (pending) {
+          void pending.catch((err) => this.handleBlobRequestError(packageName, requestId, err))
+        }
+      } catch (err) {
+        this.handleBlobRequestError(packageName, requestId, err)
+      }
+    })
+    this.blobRequestQueues.set(packageName, queued)
+    void queued.finally(() => {
+      if (this.blobRequestQueues.get(packageName) === queued) this.blobRequestQueues.delete(packageName)
+    })
+  }
+
+  private handleBlobRequestError(packageName: string, requestId: string | undefined, err: unknown): void {
+    console.error(`${LOG_TAG}: blob request error:`, err)
+    this.sendResult(packageName, requestId, false, undefined, {
+      code: MiniappErrorCode.INTERNAL,
+      message: err instanceof Error ? err.message : "Blob storage error",
+    })
+  }
 
   /**
    * Heading is a sensor stream — start the native compass when any mini
@@ -2427,12 +2735,6 @@ class LocalMiniappRuntime {
   // Storage helpers
   // ---------------------------------------------------------------------------
 
-  private getStorageKeyPrefix(packageName: string): string {
-    const userId =
-      (useSettingsStore.getState().getSetting(ISLAND_SETTINGS_KEYS.coreToken) as string | undefined) || "anonymous"
-    return `mentraos_localstorage_${userId}_${packageName}_`
-  }
-
   private async handleStorageGet(
     packageName: string,
     payload: Record<string, unknown>,
@@ -2447,9 +2749,8 @@ class LocalMiniappRuntime {
         })
         return
       }
-      const fullKey = this.getStorageKeyPrefix(packageName) + key
-      const result = mmkvStorage.load<unknown>(fullKey)
-      this.sendResult(packageName, requestId, true, {key, value: result.is_ok() ? result.value : null})
+      const value = await this.simpleStorage.get(packageName, key)
+      this.sendResult(packageName, requestId, true, {key, value})
     } catch (err) {
       console.error(`${LOG_TAG}: storage_get error:`, err)
       this.sendResult(packageName, requestId, false, undefined, {
@@ -2473,8 +2774,7 @@ class LocalMiniappRuntime {
         })
         return
       }
-      const fullKey = this.getStorageKeyPrefix(packageName) + key
-      mmkvStorage.save(fullKey, payload.value ?? null)
+      await this.simpleStorage.set(packageName, key, payload.value ?? null)
       this.sendResult(packageName, requestId, true)
     } catch (err) {
       console.error(`${LOG_TAG}: storage_set error:`, err)
@@ -2499,8 +2799,7 @@ class LocalMiniappRuntime {
         })
         return
       }
-      const fullKey = this.getStorageKeyPrefix(packageName) + key
-      mmkvStorage.remove(fullKey)
+      await this.simpleStorage.delete(packageName, key)
       this.sendResult(packageName, requestId, true)
     } catch (err) {
       console.error(`${LOG_TAG}: storage_delete error:`, err)
@@ -2517,9 +2816,7 @@ class LocalMiniappRuntime {
     requestId?: string,
   ): Promise<void> {
     try {
-      const prefix = this.getStorageKeyPrefix(packageName)
-      const allKeys = mmkvStorage.getAllKeys()
-      const keys = allKeys.filter((k) => k.startsWith(prefix)).map((k) => k.slice(prefix.length))
+      const keys = await this.simpleStorage.keys(packageName)
       this.sendResult(packageName, requestId, true, {keys})
     } catch (err) {
       console.error(`${LOG_TAG}: storage_list error:`, err)
@@ -2532,11 +2829,7 @@ class LocalMiniappRuntime {
 
   private async handleStorageClear(packageName: string, requestId?: string): Promise<void> {
     try {
-      const prefix = this.getStorageKeyPrefix(packageName)
-      const allKeys = mmkvStorage.getAllKeys()
-      for (const k of allKeys) {
-        if (k.startsWith(prefix)) mmkvStorage.remove(k)
-      }
+      await this.simpleStorage.clear(packageName)
       this.sendResult(packageName, requestId, true)
     } catch (err) {
       console.error(`${LOG_TAG}: storage_clear error:`, err)
@@ -2561,9 +2854,8 @@ class LocalMiniappRuntime {
         })
         return
       }
-      const fullKey = this.getStorageKeyPrefix(packageName) + key
-      const result = mmkvStorage.load<unknown>(fullKey)
-      this.sendResult(packageName, requestId, true, {has: result.is_ok()})
+      const has = await this.simpleStorage.has(packageName, key)
+      this.sendResult(packageName, requestId, true, {has})
     } catch (err) {
       console.error(`${LOG_TAG}: storage_has error:`, err)
       this.sendResult(packageName, requestId, false, undefined, {
@@ -2575,17 +2867,7 @@ class LocalMiniappRuntime {
 
   private async handleStorageGetAll(packageName: string, requestId?: string): Promise<void> {
     try {
-      const prefix = this.getStorageKeyPrefix(packageName)
-      const allKeys = mmkvStorage.getAllKeys()
-      const values: Record<string, string> = {}
-      for (const k of allKeys) {
-        if (!k.startsWith(prefix)) continue
-        const r = mmkvStorage.load<unknown>(k)
-        if (r.is_ok()) {
-          const v = r.value
-          values[k.slice(prefix.length)] = typeof v === "string" ? v : String(v ?? "")
-        }
-      }
+      const values = await this.simpleStorage.getAll(packageName)
       this.sendResult(packageName, requestId, true, {values})
     } catch (err) {
       console.error(`${LOG_TAG}: storage_get_all error:`, err)
@@ -2610,10 +2892,7 @@ class LocalMiniappRuntime {
         })
         return
       }
-      const prefix = this.getStorageKeyPrefix(packageName)
-      for (const [key, value] of Object.entries(values)) {
-        mmkvStorage.save(prefix + key, value ?? null)
-      }
+      await this.simpleStorage.setMultiple(packageName, values)
       this.sendResult(packageName, requestId, true)
     } catch (err) {
       console.error(`${LOG_TAG}: storage_set_multiple error:`, err)
@@ -2624,6 +2903,36 @@ class LocalMiniappRuntime {
     }
   }
 
+  // ---------------------------------------------------------------------------
+  // Wi-Fi ADB
+  // ---------------------------------------------------------------------------
+
+  private async handleSetWifiAdbState(
+    packageName: string,
+    payload: Record<string, unknown>,
+    requestId?: string,
+  ): Promise<void> {
+    const result = await handleWifiAdbRequest(packageName, payload, {
+      isSystemPackage: (candidate) => this.isSystemPackage(candidate),
+      setWifiAdbState: async (enabled) => {
+        console.log(`${LOG_TAG}: set_wifi_adb_state enabled=${enabled} from ${packageName}`)
+        try {
+          await BluetoothSdk.setWifiAdbState(enabled)
+        } catch (error) {
+          console.error(`${LOG_TAG}: set_wifi_adb_state error:`, error)
+          throw error
+        }
+      },
+    })
+
+    if (result.ok) {
+      this.sendResult(packageName, requestId, true)
+      return
+    }
+
+    this.sendResult(packageName, requestId, false, undefined, result.error)
+  }
+
   // ---------------------------------------------------------------------------
   // Camera FOV
   // ---------------------------------------------------------------------------
@@ -2689,6 +2998,124 @@ class LocalMiniappRuntime {
     }
   }
 
+  /**
+   * Lifecycle-scoped glasses-side VAD override from a miniapp
+   * (session.mic.setVoiceActivityDetectionEnabled). Requires MICROPHONE in the
+   * miniapp manifest. Mentra Live only today — other models no-op via DeviceStore.
+   */
+  private async handleMicSetVadEnabled(
+    packageName: string,
+    payload: Record<string, unknown>,
+    requestId?: string,
+  ): Promise<void> {
+    const app = this.connectedApps.get(packageName)
+    const hasMicPermission = app?.installedManifest?.permissions?.some((p) => p.type === "MICROPHONE")
+    if (!hasMicPermission) {
+      logPermissionNotDeclared(packageName, "MICROPHONE", "to set VAD enabled", `{"type": "MICROPHONE"}`)
+      this.sendResult(packageName, requestId, false, undefined, {
+        code: MiniappErrorCode.PERMISSION_NOT_DECLARED,
+        message: `MICROPHONE permission not declared in miniapp.json. Add {"type": "MICROPHONE"} to the "permissions" array.`,
+        permission: "MICROPHONE",
+        operation: MiniappRequestType.MIC_SET_VAD_ENABLED,
+      })
+      return
+    }
+
+    if (typeof payload.enabled !== "boolean") {
+      this.sendResult(packageName, requestId, false, undefined, {
+        code: MiniappErrorCode.INVALID_ARGUMENT,
+        message: "enabled must be a boolean",
+      })
+      return
+    }
+
+    try {
+      const enabled = payload.enabled
+      console.log(`${LOG_TAG}: mic_set_vad_enabled ${enabled} (by ${packageName})`)
+      await micStateCoordinator.setMiniappGateOverride(packageName, "vad", enabled, this.getConfiguredMicGates())
+      this.sendResult(packageName, requestId, true)
+    } catch (err) {
+      console.error(`${LOG_TAG}: mic_set_vad_enabled error:`, err)
+      this.sendResult(packageName, requestId, false, undefined, {
+        code: MiniappErrorCode.INTERNAL,
+        message: err instanceof Error ? err.message : "VAD set-enabled error",
+      })
+    }
+  }
+
+  /**
+   * Lifecycle-scoped center-mic loudness gate ("Barrier") override from a miniapp
+   * (session.mic.setLoudnessGateEnabled). Requires MICROPHONE in the miniapp
+   * manifest. Mentra Live only today — other models no-op via DeviceStore.
+   */
+  private async handleMicSetLoudnessGateEnabled(
+    packageName: string,
+    payload: Record<string, unknown>,
+    requestId?: string,
+  ): Promise<void> {
+    const app = this.connectedApps.get(packageName)
+    const hasMicPermission = app?.installedManifest?.permissions?.some((p) => p.type === "MICROPHONE")
+    if (!hasMicPermission) {
+      logPermissionNotDeclared(packageName, "MICROPHONE", "to set loudness gate enabled", `{"type": "MICROPHONE"}`)
+      this.sendResult(packageName, requestId, false, undefined, {
+        code: MiniappErrorCode.PERMISSION_NOT_DECLARED,
+        message: `MICROPHONE permission not declared in miniapp.json. Add {"type": "MICROPHONE"} to the "permissions" array.`,
+        permission: "MICROPHONE",
+        operation: MiniappRequestType.MIC_SET_LOUDNESS_GATE_ENABLED,
+      })
+      return
+    }
+
+    if (typeof payload.enabled !== "boolean") {
+      this.sendResult(packageName, requestId, false, undefined, {
+        code: MiniappErrorCode.INVALID_ARGUMENT,
+        message: "enabled must be a boolean",
+      })
+      return
+    }
+
+    try {
+      const enabled = payload.enabled
+      console.log(`${LOG_TAG}: mic_set_loudness_gate_enabled ${enabled} (by ${packageName})`)
+      await micStateCoordinator.setMiniappGateOverride(
+        packageName,
+        "loudnessGate",
+        enabled,
+        this.getConfiguredMicGates(),
+      )
+      this.sendResult(packageName, requestId, true)
+    } catch (err) {
+      console.error(`${LOG_TAG}: mic_set_loudness_gate_enabled error:`, err)
+      this.sendResult(packageName, requestId, false, undefined, {
+        code: MiniappErrorCode.INTERNAL,
+        message: err instanceof Error ? err.message : "Loudness gate set-enabled error",
+      })
+    }
+  }
+
+  /**
+   * session.system.scanQr — host camera overlay. Must not clear miniapp
+   * foreground; the host seam is responsible for presenting a Modal on top.
+   */
+  private async handleScanQr(
+    packageName: string,
+    payload: Record<string, unknown>,
+    requestId?: string,
+  ): Promise<void> {
+    try {
+      const result = await invokeScanQrSeam(getUiSeams().scanQr, payload)
+      this.sendResult(packageName, requestId, true, result)
+    } catch (err) {
+      if (!getUiSeams().scanQr) {
+        console.warn(`${LOG_TAG}: scanQr seam missing — QR overlay is not registered`)
+      }
+      this.sendResult(packageName, requestId, false, undefined, {
+        code: (err as {code?: string} | null | undefined)?.code || MiniappErrorCode.INTERNAL,
+        message: err instanceof Error ? err.message : "QR scan failed",
+      })
+    }
+  }
+
   // ---------------------------------------------------------------------------
   // System utilities (share, open URL, clipboard, download)
   // ---------------------------------------------------------------------------
@@ -2833,7 +3260,7 @@ class LocalMiniappRuntime {
       const result = await phonePhotoCoordinator.takePhoto(packageName, {
         size: payload.size as "low" | "medium" | "high" | "max" | "small" | "large" | "full" | undefined,
         mode: payload.mode as "photo" | "text" | undefined,
-        transferMethod: payload.transferMethod as "auto" | "ble" | undefined,
+        transferMethod: payload.transferMethod as "auto" | "direct" | "ble" | undefined,
         compress: payload.compress as "none" | "low" | "medium" | "high" | undefined,
         sound: payload.sound as boolean | undefined,
         saveToGallery: payload.saveToGallery as boolean | undefined,
@@ -2843,8 +3270,8 @@ class LocalMiniappRuntime {
         isoCap: payload.isoCap as number | undefined,
         noiseReduction: payload.noiseReduction as boolean | undefined,
         edgeEnhancement: payload.edgeEnhancement as boolean | undefined,
-        mfnr: payload.mfnr as boolean | undefined,
         zsl: payload.zsl as boolean | undefined,
+        mfnr: payload.mfnr as boolean | undefined,
         ispDigitalGain: payload.ispDigitalGain as number | undefined,
         ispAnalogGain: payload.ispAnalogGain as string | undefined,
       })
@@ -2884,6 +3311,8 @@ class LocalMiniappRuntime {
         mode: payload.mode as "photo" | "text" | undefined,
         exposureTimeNs: payload.exposureTimeNs as number | undefined,
         durationMs: payload.durationMs as number | undefined,
+        zsl: payload.zsl as boolean | undefined,
+        mfnr: payload.mfnr as boolean | undefined,
       })
       this.sendResult(packageName, requestId, true)
     } catch (err) {
@@ -2976,6 +3405,7 @@ class LocalMiniappRuntime {
         video: normalizeStreamVideoConfig(payload.video),
         audio: normalizeStreamAudioConfig(payload.audio),
         sound: payload.sound as boolean | undefined,
+        authToken: typeof payload.authToken === "string" ? payload.authToken : undefined,
       })
       this.sendResult(packageName, requestId, true, result)
     } catch (err) {
@@ -3071,7 +3501,7 @@ class LocalMiniappRuntime {
       return
     }
     try {
-      await requestWifiSetup(payload.reason as string | undefined)
+      await requestWifiSetup(payload.reason as string | undefined, packageName)
       this.sendResult(packageName, requestId, true)
     } catch (err) {
       this.sendResult(packageName, requestId, false, undefined, {
@@ -3135,29 +3565,12 @@ class LocalMiniappRuntime {
       }
     }
 
-    // Remove old subscriptions for this app
-    for (const oldStream of app.subscriptions) {
-      const subs = this.streamSubscribers.get(oldStream)
-      if (subs) {
-        subs.delete(packageName)
-        if (subs.size === 0) {
-          this.streamSubscribers.delete(oldStream)
-        }
-      }
-    }
-
     // Add new subscriptions
+    const previousSubscriptions = app.subscriptions
     app.subscriptions = new Set(streams)
     app.forceLocalTranscriptionStreams.clear()
     app.cloudTranscriptionStreams = new Set(streams.filter((stream) => stream.startsWith("transcription:")))
-    for (const stream of streams) {
-      let subs = this.streamSubscribers.get(stream)
-      if (!subs) {
-        subs = new Set()
-        this.streamSubscribers.set(stream, subs)
-      }
-      subs.add(packageName)
-    }
+    this.replaceStreamSubscribers(packageName, previousSubscriptions, app.subscriptions)
 
     this.recomputeMicRequirements()
     this.updateCloudSubscriptions()
@@ -3168,6 +3581,16 @@ class LocalMiniappRuntime {
   // Mic requirements
   // ===========================================================================
 
+  private getConfiguredMicGates(): {vadEnabled: boolean | null; loudnessGateEnabled: boolean | null} {
+    const bluetoothSettings = useSettingsStore.getState().getBluetoothSettings()
+    const configuredVad = bluetoothSettings.voice_activity_detection_enabled
+    const configuredLoudnessGate = bluetoothSettings.loudness_gate_enabled
+    return {
+      vadEnabled: typeof configuredVad === "boolean" ? configuredVad : null,
+      loudnessGateEnabled: typeof configuredLoudnessGate === "boolean" ? configuredLoudnessGate : null,
+    }
+  }
+
   private recomputeMicRequirements(): void {
     let anyPcm = false
     let anyLc3 = false
@@ -3176,7 +3599,11 @@ class LocalMiniappRuntime {
       if (stream === "audio_chunk") anyPcm = true
       if (stream.startsWith("transcription:") || stream.startsWith("translation:") || stream === "vad") anyLc3 = true
     }
-    micStateCoordinator.setLocalRequirements({pcm: anyPcm, lc3: anyLc3})
+    micStateCoordinator.setLocalRequirements({
+      pcm: anyPcm,
+      lc3: anyLc3,
+      ...this.getConfiguredMicGates(),
+    })
   }
 
   /**
@@ -3254,12 +3681,21 @@ class LocalMiniappRuntime {
    */
   private buildCloudAudioSubscriptions(cloudStreams: Set<string>): AudioSubscription[] {
     const subs: AudioSubscription[] = []
+    // Union of every connected app's TRANSCRIPTION_CONFIG hints. Hints only
+    // apply to the auto-mode TRANSCRIPTION subscription (the wire schema has
+    // no hints field on specific-language sources — the language IS the hint
+    // there), and are deliberately NOT attached to translation sources.
+    const hintUnion = [...new Set([...this.transcriptionHintsByApp.values()].flat())].sort()
     const langSource = (code: string): LanguageSource =>
       code === "auto" || code === "*" ? {mode: "auto"} : {mode: "specific", code}
     for (const stream of cloudStreams) {
       if (stream.startsWith("transcription:")) {
         const lang = stream.substring("transcription:".length)
-        subs.push({kind: "transcription", language: langSource(lang)})
+        const source = langSource(lang)
+        subs.push({
+          kind: "transcription",
+          language: source.mode === "auto" && hintUnion.length > 0 ? {mode: "auto", hints: hintUnion} : source,
+        })
       } else if (stream.startsWith("translation:")) {
         const parts = stream.split(":")
         // Only `translation:<source>:<target>` maps cleanly; a concrete target
@@ -4130,17 +4566,16 @@ class LocalMiniappRuntime {
   }
 
   private doPingRound(): void {
-    const now = Date.now()
-    const staleThreshold = PING_INTERVAL_MS * PING_TIMEOUT_THRESHOLD
-
     const toRemove: string[] = []
 
     for (const [packageName, app] of this.connectedApps) {
-      if (now - app.lastPongAt > staleThreshold) {
+      const liveness = advanceMiniappPingLiveness(app.unansweredPingRounds, PING_TIMEOUT_THRESHOLD)
+      if (liveness.shouldUnregister) {
         console.warn(`${LOG_TAG}: ${packageName} missed ${PING_TIMEOUT_THRESHOLD} pings, unregistering`)
         toRemove.push(packageName)
         continue
       }
+      app.unansweredPingRounds = liveness.unansweredPingRounds
 
       // Send PING — SDK auto-replies with PONG
       this.sendToMiniapp(packageName, {
@@ -4164,6 +4599,7 @@ class LocalMiniappRuntime {
     const app = this.connectedApps.get(packageName)
     if (app) {
       app.lastPongAt = Date.now()
+      app.unansweredPingRounds = 0
       this.clearForegroundProbe(packageName)
     }
   }
@@ -4191,7 +4627,17 @@ class LocalMiniappRuntime {
 
     // Belt-and-suspenders: clear any remaining state
     this.pendingCloudRequests.clear()
+    const hadButtonPressSubscribers = this.getButtonPressSubscribers().length > 0
     this.streamSubscribers.clear()
+    if (hadButtonPressSubscribers) {
+      for (const listener of this.buttonPressSubscriberListeners) {
+        try {
+          listener([])
+        } catch (error) {
+          console.warn(`${LOG_TAG}: button press subscriber listener threw during cleanup:`, error)
+        }
+      }
+    }
     this.connectedApps.clear()
     for (const timerId of this.foregroundProbeTimers.values()) {
       BgTimer.clearTimeout(timerId)