@glassly/engine 0.1.0-dev.99 → 0.2.9-beta.448

package/src/services/PhoneNotificationsSync.ts

@@ -1,39 +1,49 @@
 /**
- * Phone-notifications sync — engine-owned. Started by `engine.start()`.
+ * Phone-notifications sync — engine-owned, started by `engine.start()`. Keeps
+ * three things in step with settings and the connected glasses, for any host:
  *
- * Android: pushes the notification-forwarding operational kill switch + config
- * (`android_notification_listener_enabled` and `notifications_blocklist`) to
- * the native NotificationListener via `CrustModule.setNotificationConfig`, so
- * the blocklist reaches the listener for ANY host — not just the Glassly App,
- * where this used to live in MantleManager. The Android service is desired by
- * default now that its cold start is isolated from React Native. Native code
- * keeps the component discoverable in Android's notification-access Settings,
- * but only binds the service after access is granted. The debug setting remains
- * a hidden emergency kill switch; Notify's running state gates presentation,
- * not capture.
+ *  - Android: the notification listener's kill switch + per-app blocklist
+ *    (`CrustModule.setNotificationConfig`). The listener runs in its own
+ *    guarded process and is desired by default; the debug setting stays a
+ *    hidden emergency switch. Notify's running state gates presentation, not
+ *    capture.
+ *  - Glasses whose firmware presents notifications (`hasNativeNotifications`):
+ *    one `GlassesNotificationConfig` pushed through the Bluetooth SDK whenever
+ *    a setting, the phone's activity, the seen-apps list or the connected
+ *    glasses change. Drivers re-apply their last config on reconnect; the push
+ *    repeats on connection so a fresh driver gets it too.
+ *  - The seen-apps list (`notification_seen_apps`) from `notification_app_seen`:
+ *    glasses that read the phone's stream report each source app, which is
+ *    the only app enumeration iOS offers.
  *
- * iOS: the G2 consumes notifications on-firmware via ANCS, so the phone's job
- * is config, not capture. This sync (a) records the apps the glasses report
- * posting notifications (`notification_app_seen` → `ios_notification_seen_apps`)
- * and (b) maps the shared `notifications_blocklist` + the G2 display settings
- * onto the native `notification_filter` / `notification_ctrl` DeviceStore keys,
- * which the bluetooth-sdk pushes to the glasses (and replays on reconnect).
- * The firmware filter is allow-based and fail-open: an empty blocklist disables
- * whitelisting entirely; any block enables it with allowlist = (catalog ∪ seen)
- * minus blocked.
+ * Presentation is one question with one answer (`presentationOwner`); hosts
+ * ask it per event instead of reasoning about models or platforms.
  */
 import {Platform} from "react-native"
 import {shallow} from "zustand/shallow"
 import CrustModule from "@glassly/crust"
+import type {PhoneNotificationEvent} from "@glassly/crust"
+import type {GlassesNotificationConfig} from "@glassly/bluetooth-sdk"
 import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
-import type {
-  G2NotificationCtrlSetting,
-  G2NotificationFilterSetting,
-  NotificationAppSeenEvent,
-} from "@glassly/bluetooth-sdk/internal"
+import type {NotificationAppSeenEvent} from "@glassly/bluetooth-sdk/internal"
 
+import {useGlassesStore} from "../stores/glasses"
 import {useSettingsStore, SETTINGS} from "../stores/settings"
-import {IOS_NOTIFICATION_APP_CATALOG} from "./iosNotificationAppCatalog"
+import {DeviceTypes} from "../types/enums"
+import {getModelCapabilities} from "../types/hardware"
+import {isGlassesConnected} from "./GlassesReadiness"
+import {notificationAppCatalog} from "./notificationAppCatalog"
+import {
+  glassesNotificationConfig,
+  presentationOwner,
+  type NotificationApp,
+  type PresentationOwner,
+} from "./notifications/notificationPolicy"
+import {overlayViewerRunning} from "./pages/overlayApps"
+import {pagesEligible} from "./pages/pageEligibility"
+import {isPhoneActive, onPhoneActivityChange} from "./PhoneActivity"
+
+export type {PresentationOwner}
 
 export interface SeenNotificationApp {
   appId: string
@@ -41,29 +51,17 @@ export interface SeenNotificationApp {
   lastSeen: number
 }
 
-let unsubscribe: (() => void) | null = null
-let seenAppsSubscription: {remove(): void} | null = null
-
-function pushAndroidConfig(): void {
-  const s = useSettingsStore.getState()
-  const listenerEnabled = Boolean(s.getSetting(SETTINGS.android_notification_listener_enabled.key))
-  const blocklist = s.getSetting(SETTINGS.notifications_blocklist.key)
-  CrustModule.setNotificationConfig(listenerEnabled, Array.isArray(blocklist) ? blocklist : []).catch((err: unknown) =>
-    console.warn(`PhoneNotificationsSync: setNotificationConfig failed: ${(err as Error)?.message ?? err}`),
-  )
-}
+let unsubscribers: Array<() => void> = []
 
 export function getSeenNotificationApps(): SeenNotificationApp[] {
-  const seen = useSettingsStore.getState().getSetting(SETTINGS.ios_notification_seen_apps.key)
+  const seen = useSettingsStore.getState().getSetting(SETTINGS.notification_seen_apps.key)
   return Array.isArray(seen) ? (seen as SeenNotificationApp[]) : []
 }
 
 /** Catalog ∪ seen apps, seen display names winning. Sorted by name. */
-export function getKnownNotificationApps(): Array<{appId: string; displayName: string}> {
+export function getKnownNotificationApps(): NotificationApp[] {
   const merged = new Map<string, string>()
-  for (const app of IOS_NOTIFICATION_APP_CATALOG) {
-    merged.set(app.appId, app.displayName)
-  }
+  for (const app of notificationAppCatalog()) merged.set(app.appId, app.displayName)
   for (const app of getSeenNotificationApps()) {
     if (app.appId) merged.set(app.appId, app.displayName || app.appId)
   }
@@ -72,41 +70,127 @@ export function getKnownNotificationApps(): Array<{appId: string; displayName: s
     .sort((a, b) => a.displayName.localeCompare(b.displayName))
 }
 
-export function computeG2NotificationFilter(): G2NotificationFilterSetting {
-  const blocklistValue = useSettingsStore.getState().getSetting(SETTINGS.notifications_blocklist.key)
-  const blocklist = Array.isArray(blocklistValue) ? (blocklistValue as string[]) : []
-  const blocked = new Set(blocklist)
-  // The list is included even while filtering is off, so the on-glass file
-  // already holds the user's current list when a first block enables it.
-  const apps = getKnownNotificationApps()
-    .filter((app) => !blocked.has(app.appId))
-    .map((app) => ({id: app.appId, name: app.displayName}))
-  return {enabled: blocked.size > 0, apps}
+/**
+ * Apps to show in a notification filter UI (package/bundle id, name, icon).
+ * Android: installed apps. iOS: seeded catalog ∪ glasses-reported apps
+ * (icons unavailable — iOS offers no cross-app icon lookup).
+ */
+export function installedNotificationApps(): Promise<
+  Array<{packageName: string; appName: string; icon: string | null}>
+> {
+  if (Platform.OS === "android") return CrustModule.getInstalledApps()
+  if (Platform.OS !== "ios") return Promise.resolve([])
+  return Promise.resolve(
+    getKnownNotificationApps().map((app) => ({packageName: app.appId, appName: app.displayName, icon: null})),
+  )
 }
 
-function computeG2NotificationCtrl(): G2NotificationCtrlSetting {
+/** The connected (or remembered) model presents notifications in firmware. */
+export function nativeNotificationsSupported(): boolean {
+  const model = useGlassesStore.getState().deviceModel as DeviceTypes
+  return getModelCapabilities(model).hasNativeNotifications === true
+}
+
+/** Popup durations the firmware accepts, or an empty list when it takes any. */
+export function nativeNotificationPopupSeconds(): number[] {
+  const model = useGlassesStore.getState().deviceModel as DeviceTypes
+  return getModelCapabilities(model).nativeNotificationPopupSeconds ?? []
+}
+
+export function notificationsEnabled(): boolean {
+  return useSettingsStore.getState().getSetting(SETTINGS.notifications_enabled.key) !== false
+}
+
+export function desiredGlassesNotificationConfig(): GlassesNotificationConfig {
   const s = useSettingsStore.getState()
-  return {
-    enabled: Boolean(s.getSetting(SETTINGS.g2_notifications_enabled.key)),
-    auto_display: Boolean(s.getSetting(SETTINGS.g2_notification_auto_display.key)),
-    disp_time: Number(s.getSetting(SETTINGS.g2_notification_disp_time.key)) || 0,
-    avoid_disturb: Boolean(s.getSetting(SETTINGS.g2_notification_avoid_disturb.key)),
-  }
+  const blocklist = s.getSetting(SETTINGS.notifications_blocklist.key)
+  return glassesNotificationConfig({
+    enabled: notificationsEnabled(),
+    popups: s.getSetting(SETTINGS.notifications_popups.key) !== false,
+    popupSeconds: Number(s.getSetting(SETTINGS.notifications_popup_seconds.key)),
+    holdDuringApps: s.getSetting(SETTINGS.notifications_hold_during_apps.key) !== false,
+    ignoreWhileActive: s.getSetting(SETTINGS.notifications_ignore_while_active.key) === true,
+    phoneActive: isPhoneActive(),
+    blockedApps: Array.isArray(blocklist) ? (blocklist as string[]) : [],
+    knownApps: getKnownNotificationApps(),
+  })
+}
+
+/**
+ * Who presents the next phone notification. `hostActive` is the host's own
+ * presentation surface (Notify in the Glassly App); the engine has no view of
+ * it.
+ */
+export function currentPresentationOwner(hostActive: boolean): PresentationOwner {
+  return presentationOwner({
+    enabled: notificationsEnabled(),
+    pagesEligible: pagesEligible(),
+    // The viewer is an overlay miniapp listening to phone notifications
+    // (ADR-0006): with none running, nothing draws one on eligible glasses.
+    viewerRunning: overlayViewerRunning(),
+    nativeNotifications: nativeNotificationsSupported() && isGlassesConnected(useGlassesStore.getState().connection),
+    hostActive,
+  })
 }
 
-function pushIosConfig(): void {
-  // The native DeviceStore dedupes unchanged values and replays these to the
-  // glasses on every reconnect, so pushing eagerly is cheap.
-  void Promise.resolve(
-    BluetoothSdk.updateBluetoothSettings({
-      notification_ctrl: computeG2NotificationCtrl(),
-      notification_filter: computeG2NotificationFilter(),
+/**
+ * Whether the glasses may read the phone's notifications. iOS glasses read
+ * the stream themselves under the Bluetooth notification-sharing consent the
+ * driver reports as `ancsAuthorized`; Android glasses get content from the
+ * phone's listener, whose grant the permission flow owns.
+ */
+export function captureAuthorization(): "granted" | "denied" | "unknown" | "not_needed" {
+  if (Platform.OS !== "ios") return "not_needed"
+  if (!nativeNotificationsSupported()) return "not_needed"
+  const glasses = useGlassesStore.getState()
+  if (!isGlassesConnected(glasses.connection)) return "unknown"
+  return glasses.ancsAuthorized ? "granted" : "denied"
+}
+
+/**
+ * Hand one captured notification to glasses whose firmware presents it from
+ * uploaded content (Android). Glasses that read the phone's stream reject it;
+ * callers only reach here when the owner is `firmware`.
+ */
+export function uploadPhoneNotification(event: PhoneNotificationEvent): Promise<void> {
+  if (Platform.OS !== "android") return Promise.resolve()
+  return Promise.resolve(
+    BluetoothSdk.uploadPhoneNotification({
+      notificationId: String(event.notificationId ?? ""),
+      packageName: String(event.packageName ?? ""),
+      appName: String(event.app ?? ""),
+      title: String(event.title ?? ""),
+      subtitle: "",
+      body: String(event.content ?? ""),
+      timestampMs: Number(event.timestamp) || Date.now(),
     }),
-  ).catch((err: unknown) =>
-    console.warn(`PhoneNotificationsSync: notification config push failed: ${(err as Error)?.message ?? err}`),
   )
 }
 
+function pushListenerConfig(): void {
+  if (Platform.OS !== "android") return
+  const s = useSettingsStore.getState()
+  const listenerEnabled = Boolean(s.getSetting(SETTINGS.android_notification_listener_enabled.key))
+  const blocklist = s.getSetting(SETTINGS.notifications_blocklist.key)
+  CrustModule.setNotificationConfig(listenerEnabled, Array.isArray(blocklist) ? blocklist : []).catch((err: unknown) =>
+    console.warn(`PhoneNotificationsSync: setNotificationConfig failed: ${(err as Error)?.message ?? err}`),
+  )
+}
+
+function pushGlassesConfig(): void {
+  if (!nativeNotificationsSupported()) return
+  if (!isGlassesConnected(useGlassesStore.getState().connection)) return
+  void Promise.resolve(BluetoothSdk.setGlassesNotificationConfig(desiredGlassesNotificationConfig())).catch(
+    (err: unknown) =>
+      console.warn(`PhoneNotificationsSync: glasses notification config failed: ${(err as Error)?.message ?? err}`),
+  )
+}
+
+function pushAll(): void {
+  pushListenerConfig()
+  pushGlassesConfig()
+}
+
 /** Record a glasses-reported source app. Writes only on new app / renamed app. */
 function recordSeenApp(event: NotificationAppSeenEvent): void {
   if (!event.appId) return
@@ -117,46 +201,44 @@ function recordSeenApp(event: NotificationAppSeenEvent): void {
   const next = seen
     .filter((app) => app.appId !== event.appId)
     .concat([{appId: event.appId, displayName, lastSeen: event.timestamp || Date.now()}])
-  useSettingsStore.getState().setSetting(SETTINGS.ios_notification_seen_apps.key, next)
+  useSettingsStore.getState().setSetting(SETTINGS.notification_seen_apps.key, next)
 }
 
 export function startPhoneNotificationsSync(): void {
-  if (unsubscribe) return
-
-  if (Platform.OS === "android") {
-    pushAndroidConfig() // initial sync so the listener has the current config
-    unsubscribe = useSettingsStore.subscribe(
-      (state) => ({
-        listenerEnabled: state.getSetting(SETTINGS.android_notification_listener_enabled.key),
-        blocklist: state.getSetting(SETTINGS.notifications_blocklist.key),
-      }),
-      () => pushAndroidConfig(),
+  if (unsubscribers.length) return
+  pushAll()
+  const seenApps = BluetoothSdk.addListener("notification_app_seen", recordSeenApp)
+  unsubscribers = [
+    useSettingsStore.subscribe(
+      (state) =>
+        [
+          SETTINGS.android_notification_listener_enabled,
+          SETTINGS.notifications_blocklist,
+          SETTINGS.notification_seen_apps,
+          SETTINGS.notifications_enabled,
+          SETTINGS.notifications_popups,
+          SETTINGS.notifications_popup_seconds,
+          SETTINGS.notifications_hold_during_apps,
+          SETTINGS.notifications_ignore_while_active,
+        ].map((setting) => state.getSetting(setting.key)),
+      pushAll,
       {equalityFn: shallow},
-    )
-    return
-  }
-
-  if (Platform.OS !== "ios") return
-
-  pushIosConfig()
-  unsubscribe = useSettingsStore.subscribe(
-    (state) => ({
-      blocklist: state.getSetting(SETTINGS.notifications_blocklist.key),
-      seenApps: state.getSetting(SETTINGS.ios_notification_seen_apps.key),
-      enabled: state.getSetting(SETTINGS.g2_notifications_enabled.key),
-      autoDisplay: state.getSetting(SETTINGS.g2_notification_auto_display.key),
-      dispTime: state.getSetting(SETTINGS.g2_notification_disp_time.key),
-      avoidDisturb: state.getSetting(SETTINGS.g2_notification_avoid_disturb.key),
-    }),
-    () => pushIosConfig(),
-    {equalityFn: shallow},
-  )
-  seenAppsSubscription = BluetoothSdk.addListener("notification_app_seen", recordSeenApp)
+    ),
+    // A (re)connected driver gets the current config; the SDK dedupes nothing
+    // here, so only connection state and model are watched, not every field.
+    useGlassesStore.subscribe(
+      (state) => ({model: state.deviceModel, connected: isGlassesConnected(state.connection)}),
+      pushGlassesConfig,
+      {equalityFn: shallow},
+    ),
+    // Lock / foreground changes flip the effective popups flag for firmware
+    // that pops notifications up by itself.
+    onPhoneActivityChange(pushGlassesConfig),
+    () => seenApps.remove(),
+  ]
 }
 
 export function stopPhoneNotificationsSync(): void {
-  unsubscribe?.()
-  unsubscribe = null
-  seenAppsSubscription?.remove()
-  seenAppsSubscription = null
+  for (const unsubscribe of unsubscribers) unsubscribe()
+  unsubscribers = []
 }

package/src/services/PhonePhotoCoordinator.ts

@@ -24,6 +24,8 @@ import {cloudClientService} from "./CloudClientService"
 import {isGlassesConnected} from "./GlassesReadiness"
 import {useGlassesStore} from "../stores/glasses"
 
+import {BgTimer} from "../utils/timers"
+
 interface PhotoResult {
   photoUrl: string
   mimeType: string
@@ -144,10 +146,7 @@ export class PhonePhotoCoordinator {
   private readonly activeRequests = new Map<string, ActiveRequest>()
   /** Short BLE correlation id (4-char hex) → full cloud requestId. */
   private readonly bleIdToCloud = new Map<string, string>()
-  private readonly activeWarmUps = new Map<
-    string,
-    {requestId: string; durationMs: number; expiryTimer?: ReturnType<typeof setTimeout>}
-  >()
+  private readonly activeWarmUps = new Map<string, {requestId: string; durationMs: number; expiryTimer?: number}>()
 
   /** Report-safe camera ownership snapshot for incident diagnostics. */
   getDiagnosticSnapshot(): Record<string, unknown> {
@@ -232,7 +231,7 @@ export class PhonePhotoCoordinator {
     // Last-resort watchdog for a wedged pipeline. The managed-photo ready push
     // normally resolves or rejects first; this only prevents an indefinite hang
     // if both the native terminal response and cloud push disappear.
-    const captureWatchdog = setTimeout(() => {
+    const captureWatchdog = BgTimer.setTimeout(() => {
       const e = this.activeRequests.get(requestId)
       if (!e) return
       e.abort.abort()
@@ -248,7 +247,7 @@ export class PhonePhotoCoordinator {
     // Clear the watchdog on BOTH arms. Not `.finally()`: that would mint a new
     // promise that re-rejects unobserved whenever the photo fails (the caller
     // only awaits `outcome` itself), i.e. an unhandled rejection per failure.
-    const clearWatchdog = () => clearTimeout(captureWatchdog)
+    const clearWatchdog = () => BgTimer.clearTimeout(captureWatchdog)
     void outcome.then(clearWatchdog, clearWatchdog)
 
     // 3) Drive glasses over BLE. requestPhoto now resolves at terminal
@@ -354,7 +353,7 @@ export class PhonePhotoCoordinator {
       throw new PhotoError("GLASSES_NOT_CONNECTED", "Glasses are not connected", "command", "ble")
     }
 
-    let lease: {requestId: string; durationMs: number; expiryTimer?: ReturnType<typeof setTimeout>} | undefined
+    let lease: {requestId: string; durationMs: number; expiryTimer?: number} | undefined
     try {
       await this.stopWarmUpForApp(packageName)
       const requestId = mintBleRequestId()
@@ -375,7 +374,7 @@ export class PhonePhotoCoordinator {
         ...(opts.mfnr != null ? {mfnr: opts.mfnr} : {}),
       })
       if (this.activeWarmUps.get(packageName) === lease) {
-        lease.expiryTimer = setTimeout(() => {
+        lease.expiryTimer = BgTimer.setTimeout(() => {
           if (this.activeWarmUps.get(packageName) === lease) {
             this.activeWarmUps.delete(packageName)
           }
@@ -383,7 +382,7 @@ export class PhonePhotoCoordinator {
       }
     } catch (err) {
       if (lease && this.activeWarmUps.get(packageName) === lease) {
-        if (lease.expiryTimer) clearTimeout(lease.expiryTimer)
+        if (lease.expiryTimer) BgTimer.clearTimeout(lease.expiryTimer)
         this.activeWarmUps.delete(packageName)
       }
       throw this.toPhotoError(err, "WARM_UP_FAILED", "command", "ble")
@@ -397,7 +396,7 @@ export class PhonePhotoCoordinator {
     await BluetoothSdk.stopCameraWarmUp(active.requestId)
     if (this.activeWarmUps.get(packageName) === active) {
       this.activeWarmUps.delete(packageName)
-      if (active.expiryTimer) clearTimeout(active.expiryTimer)
+      if (active.expiryTimer) BgTimer.clearTimeout(active.expiryTimer)
     }
   }
 

package/src/services/PhoneStreamCoordinator.ts

@@ -49,6 +49,8 @@ import {
   type RestreamDestinationInput,
 } from "./cloudStreamApi"
 
+import {BgTimer} from "../utils/timers"
+
 /**
  * Default cadence + thresholds. Exposed via {@link CoordinatorTimings} so tests
  * can shorten them; production code should never override these.
@@ -159,8 +161,8 @@ interface ManagedEntry {
   hlsReady: boolean
   hlsReadyResolvers: Array<(result: ManagedStartResult) => void>
   hlsReadyRejecters: Array<(err: Error) => void>
-  cloudflareTimer?: ReturnType<typeof setTimeout>
-  hlsTimer?: ReturnType<typeof setInterval>
+  cloudflareTimer?: number
+  hlsTimer?: number
   hlsAttempts: number
   /** Cloudflare status probes made during this stream session. */
   cloudflareAttempts: number
@@ -593,7 +595,7 @@ export class PhoneStreamCoordinator {
         this.timings.cloudflareStartupPollInitialMs * 2 ** Math.min(Math.max(0, entry.cloudflareAttempts - 1), 10),
       )
       const delayMs = waitingForWebRtc ? Math.min(startupDelayMs, remainingMs) : this.timings.cloudflareStatusPollMs
-      entry.cloudflareTimer = setTimeout(() => void poll(), delayMs)
+      entry.cloudflareTimer = BgTimer.setTimeout(() => void poll(), delayMs)
     }
 
     const poll = async () => {
@@ -706,7 +708,7 @@ export class PhoneStreamCoordinator {
             elapsedMs: Date.now() - entry.startupStartedAtMs,
           })
           if (entry.hlsTimer) {
-            clearInterval(entry.hlsTimer)
+            BgTimer.clearInterval(entry.hlsTimer)
             entry.hlsTimer = undefined
           }
           const result = managedStartResult(entry)
@@ -726,7 +728,7 @@ export class PhoneStreamCoordinator {
       }
       if (entry.hlsAttempts >= this.timings.hlsReadinessMaxAttempts) {
         if (entry.hlsTimer) {
-          clearInterval(entry.hlsTimer)
+          BgTimer.clearInterval(entry.hlsTimer)
           entry.hlsTimer = undefined
         }
         const err = new Error(
@@ -748,10 +750,10 @@ export class PhoneStreamCoordinator {
         })
       }
     }
-    setTimeout(() => {
+    BgTimer.setTimeout(() => {
       // Guard: stream may have been torn down during the initial delay.
       if (this.current !== entry) return
-      entry.hlsTimer = setInterval(tick, this.timings.hlsReadinessPollMs)
+      entry.hlsTimer = BgTimer.setInterval(tick, this.timings.hlsReadinessPollMs)
     }, this.timings.hlsReadinessInitialDelayMs)
   }
 
@@ -789,8 +791,8 @@ export class PhoneStreamCoordinator {
     this.lifecycle = null
 
     if (entry.kind === "managed") {
-      if (entry.cloudflareTimer) clearTimeout(entry.cloudflareTimer)
-      if (entry.hlsTimer) clearInterval(entry.hlsTimer)
+      if (entry.cloudflareTimer) BgTimer.clearTimeout(entry.cloudflareTimer)
+      if (entry.hlsTimer) BgTimer.clearInterval(entry.hlsTimer)
       // Reject any still-pending HLS readiness waiters.
       const pendingErr = new Error(`Stream torn down: ${reason}`)
       for (const reject of entry.hlsReadyRejecters) reject(pendingErr)
@@ -845,8 +847,8 @@ function pickIngestUrl(p: ProvisionResult, preference?: "srt" | "whip" | "rtmp")
     preference === "whip"
       ? p.webrtcPublishUrl || p.srtUrl || p.rtmpUrl
       : preference === "rtmp"
-      ? p.rtmpUrl || p.srtUrl || p.webrtcPublishUrl
-      : p.srtUrl || p.rtmpUrl || p.webrtcPublishUrl
+        ? p.rtmpUrl || p.srtUrl || p.webrtcPublishUrl
+        : p.srtUrl || p.rtmpUrl || p.webrtcPublishUrl
   if (!url) {
     throw new Error("Cloudflare provision returned no usable ingest URL")
   }

package/src/services/STTModelManager.ts

@@ -41,6 +41,7 @@ class STTModelManager {
   private static instance: STTModelManager
   private downloadJobId?: number
   private currentLanguage = DEFAULT_LANGUAGE
+  private modelReadyListeners = new Set<() => void>()
   private modelBaseUrl = "https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/"
 
   private languages: Record<string, LanguageConfig> = {
@@ -405,7 +406,20 @@ class STTModelManager {
   }
 
   private async setNativeModelPath(path: string, languageCode: string): Promise<void> {
-    BluetoothSdk.setSttModelDetails(path, languageCode)
+    await BluetoothSdk.setSttModelDetails(path, languageCode)
+    for (const listener of this.modelReadyListeners) {
+      try {
+        listener()
+      } catch (error) {
+        console.warn("STTModelManager: model-ready listener failed:", error)
+      }
+    }
+  }
+
+  /** Fired after a downloaded/selected model's path has reached native. */
+  onModelReady(listener: () => void): () => void {
+    this.modelReadyListeners.add(listener)
+    return () => this.modelReadyListeners.delete(listener)
   }
 
   async getStorageInfo(): Promise<{free: number; total: number}> {