@glassly/engine 0.1.0-dev.1 → 0.1.0-dev.101

package/src/services/OtaInstallCoordinator.ts

@@ -17,8 +17,7 @@
  * state written mid-pass queues a follow-up pass — the same way a setState
  * during React effects scheduled a re-render after the current effect batch.
  */
-import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
-import type {OtaProgress, OtaStatus} from "@glassly/bluetooth-sdk/internal"
+import BluetoothSdk, {type OtaProgress, type OtaStatus} from "@glassly/bluetooth-sdk"
 import GlobalEventEmitter from "../utils/GlobalEventEmitter"
 import {isGlassesConnected, useGlassesStore} from "../stores/glasses"
 import {resolveOtaManifestUrl} from "./otaManifestUrl"
@@ -27,10 +26,12 @@ import type {OtaCheckCurrentGlassesResult} from "./OtaUpdateCheckService"
 import {deriveDisplayState, type DisplayState} from "./otaDisplayState"
 import {
   BES_CONTINUE_LOCKOUT_MS,
+  BES_RESTART_TIMEOUT_MS,
   DOWNLOAD_STUCK_TIMEOUT_MS,
   GLOBAL_OTA_TIMEOUT_MS,
   LEGACY_APK_COMPLETION_SETTLE_MS,
   LEGACY_BES_CONTINUE_LOCKOUT_MS,
+  LEGACY_BES_RESTART_TIMEOUT_MS,
   LEGACY_DOWNLOAD_STUCK_TIMEOUT_MS,
   LEGACY_GLOBAL_OTA_TIMEOUT_MS,
   LEGACY_MTK_INSTALL_TIMEOUT_MS,
@@ -170,6 +171,8 @@ export interface OtaInstallSnapshot {
   /** Pre-ota_start phone staging/join state for a hotspot attempt. */
   hotspotPhase: HotspotOtaPhase
   hotspotArtifactPercent: number | null
+  /** Transport selected from the checked glasses capabilities and Wi-Fi state. */
+  transport: "wifi" | "hotspot"
 }
 
 type OtaStartOutcome = "pending" | "acknowledged" | "rejected"
@@ -244,6 +247,7 @@ class OtaInstallCoordinator {
   private pingInterval: ReturnType<typeof setInterval> | null = null
   private queryReplyTimeout: ReturnType<typeof setTimeout> | null = null
   private continueLockoutTimer: ReturnType<typeof setTimeout> | null = null
+  private restartRecoveryTimeout: ReturnType<typeof setTimeout> | null = null
   private legacyApkSettleTimer: ReturnType<typeof setTimeout> | null = null
   private mtkStallDetectTimer: ReturnType<typeof setTimeout> | null = null
   private mtkSimTickTimer: ReturnType<typeof setInterval> | null = null
@@ -407,7 +411,7 @@ class OtaInstallCoordinator {
         if (this.otaStartOwnership?.outcome === "pending") {
           void this.sendOtaStartWithWatchdogs()
         } else {
-          void BluetoothSdk.sendOtaQueryStatus().catch(() => {})
+          void BluetoothSdk.queryOtaStatus().catch(() => {})
           this.armQueryReplyFallback("retry")
         }
       }
@@ -449,16 +453,17 @@ class OtaInstallCoordinator {
    * stays in the screen): clear the selected update, and after an APK step
    * clear the stale build number so the next check re-reads version_info.
    */
-  finish(): void {
+  async finish(): Promise<void> {
     if (this.otaStartOwnership?.outcome !== "pending") {
       this.otaStartOwnership = null
     }
     useGlassesStore.getState().setOtaUpdateAvailable(null)
     if (this.apkStepSeen) {
-      BluetoothSdk.updateGlasses({buildNumber: ""})
       useGlassesStore.getState().setGlassesInfo({buildNumber: ""})
     }
-    void this.teardownHotspotTransport()
+    // The post-install check needs internet again. Do not let callers leave the
+    // terminal screen while Android still owns the no-internet hotspot route.
+    await this.teardownHotspotTransport()
   }
 
   /**
@@ -467,8 +472,8 @@ class OtaInstallCoordinator {
    * deriveDisplayState doesn't resurrect the stale install when the host
    * navigates away and back through /ota routes.
    */
-  discard(): void {
-    this.finish()
+  async discard(): Promise<void> {
+    await this.finish()
     const store = useGlassesStore.getState()
     store.setOtaStatus(null)
     store.setOtaProgress(null)
@@ -505,6 +510,7 @@ class OtaInstallCoordinator {
       versionChangePhase: this.deriveVersionChangePhase(connected),
       hotspotPhase: this.hotspotPhase,
       hotspotArtifactPercent: this.hotspotArtifactPercent,
+      transport: this.selectedTransport,
     }
   }
 
@@ -997,12 +1003,22 @@ class OtaInstallCoordinator {
     // (15s unified, 35s for legacy-shaped sessions — WP 8C-f).
     if (displayStateChanged && displayState === "restarting") {
       this.clearContinueLockoutTimer()
+      this.clearRestartRecoveryTimeout()
       const lockoutMs = legacySession ? LEGACY_BES_CONTINUE_LOCKOUT_MS : BES_CONTINUE_LOCKOUT_MS
+      const restartTimeoutMs = legacySession ? LEGACY_BES_RESTART_TIMEOUT_MS : BES_RESTART_TIMEOUT_MS
       this.setContinueButtonDisabled(true)
       this.continueLockoutTimer = setTimeout(() => {
         this.continueLockoutTimer = null
         this.setContinueButtonDisabled(false)
       }, lockoutMs)
+      this.restartRecoveryTimeout = setTimeout(() => {
+        this.restartRecoveryTimeout = null
+        if (this.computeDisplayStateNow() !== "restarting") return
+        console.log(`[OTA_PROGRESS] watchdog: glasses did not finish restarting in ${restartTimeoutMs}ms`)
+        this.setErrorMsg(OtaProgressMessages.restartTimeout)
+      }, restartTimeoutMs)
+    } else if (displayStateChanged) {
+      this.clearRestartRecoveryTimeout()
     }
 
     // Legacy MTK install stall simulation (WP 8C-e): display-only. The simulation
@@ -1065,7 +1081,7 @@ class OtaInstallCoordinator {
     if (this.otaStartOwnership?.outcome === "pending") {
       void this.sendOtaStartWithWatchdogs()
     }
-    void BluetoothSdk.sendOtaQueryStatus()
+    void BluetoothSdk.queryOtaStatus().catch(() => {})
     this.armQueryReplyFallback("reconnect")
     return true
   }
@@ -1109,7 +1125,7 @@ class OtaInstallCoordinator {
     if (noSessionYet) {
       if (!isIdleStatus && this.otaStartOwnership?.outcome === "acknowledged") {
         console.log("[OTA_PROGRESS] initial mount, acknowledged session has no cached status — reconciling")
-        void BluetoothSdk.sendOtaQueryStatus().catch(() => {})
+        void BluetoothSdk.queryOtaStatus().catch(() => {})
         this.armQueryReplyFallback("initial-mount")
         return
       }
@@ -1125,7 +1141,7 @@ class OtaInstallCoordinator {
       void this.sendOtaStartWithWatchdogs()
     } else {
       console.log("[OTA_PROGRESS] initial mount, session exists, sending ota_query_status")
-      void BluetoothSdk.sendOtaQueryStatus()
+      void BluetoothSdk.queryOtaStatus().catch(() => {})
       this.armQueryReplyFallback("initial-mount")
     }
   }
@@ -1154,7 +1170,7 @@ class OtaInstallCoordinator {
     this.clearProgressTimeout()
     this.onFirstActivity()
     this.onFirstNonZeroProgress()
-    void BluetoothSdk.sendOtaQueryStatus()
+    void BluetoothSdk.queryOtaStatus().catch(() => {})
     useGlassesStore.getState().setMtkUpdatedThisSession(true)
   }
 
@@ -1345,7 +1361,7 @@ class OtaInstallCoordinator {
     const s = useGlassesStore.getState().otaStatus
     if (s?.stepType === "apk" && s.phase === "install" && s.status === "in_progress") {
       this.apkInstallPollInFlight = true
-      void BluetoothSdk.sendOtaQueryStatus()
+      void BluetoothSdk.queryOtaStatus()
         .catch(() => {})
         .finally(() => {
           this.apkInstallPollInFlight = false
@@ -1492,6 +1508,9 @@ class OtaInstallCoordinator {
         otaVersionUrl = this.hotspotManifestUrl
         this.maybeArmStuckWatchdog()
       }
+      if (!otaVersionUrl) {
+        throw new Error("OTA is disabled because this build has no immutable manifest pin")
+      }
       console.log(`[OTA_PROGRESS] sending ota_start with ${this.selectedTransport} manifest URL: ${otaVersionUrl}`)
       nativeStartAttempted = true
       await BluetoothSdk.startOtaUpdate(otaVersionUrl)
@@ -1662,6 +1681,13 @@ class OtaInstallCoordinator {
     }
   }
 
+  private clearRestartRecoveryTimeout(): void {
+    if (this.restartRecoveryTimeout) {
+      clearTimeout(this.restartRecoveryTimeout)
+      this.restartRecoveryTimeout = null
+    }
+  }
+
   private clearLegacyApkSettleTimer(): void {
     if (this.legacyApkSettleTimer) {
       clearTimeout(this.legacyApkSettleTimer)
@@ -1700,6 +1726,7 @@ class OtaInstallCoordinator {
     this.clearPingInterval()
     this.clearLegacyApkSettleTimer()
     this.clearMtkSimulationTimers()
+    this.clearRestartRecoveryTimeout()
   }
 }
 

package/src/services/OtaService.ts

@@ -10,8 +10,7 @@
  *
  * Started by `engine.start()`. Idempotent.
  */
-import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
-import type {OtaStatus} from "@glassly/bluetooth-sdk/internal"
+import BluetoothSdk, {type OtaStatus} from "@glassly/bluetooth-sdk"
 import GlobalEventEmitter from "../utils/GlobalEventEmitter"
 import {useGlassesStore} from "../stores/glasses"
 import {handleOtaClockSkewFromGlasses} from "./glassesClockSync"

package/src/services/OtaUpdateCheckService.ts

@@ -1,9 +1,9 @@
-import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
-import type {OtaUpdateInfo} from "@glassly/bluetooth-sdk/internal"
+import BluetoothSdk, {type OtaUpdateInfo} from "@glassly/bluetooth-sdk"
+import {ENGINE_RELEASE_METADATA} from "../generated/releaseMetadata"
 import {getGlassesSystemTimeMs, isGlassesConnected, useGlassesStore, waitForGlassesState} from "../stores/glasses"
-import {SETTINGS, useSettingsStore} from "../stores/settings"
 import {maybeFixGlassesClockFromVersionInfo} from "./glassesClockSync"
-import {resolveOtaManifestUrl} from "./otaManifestUrl"
+import {hasConfiguredModernOtaManifestPin, resolveOtaManifestUrl} from "./otaManifestUrl"
+import {resolveOtaReleaseVersion} from "./otaReleaseVersion"
 
 /**
  * Phone-side mirror of ASG's `DOWNGRADE_FLOOR_VERSION_CODE`. Set to the versionCode of the first
@@ -39,6 +39,7 @@ export interface BesFirmware {
 }
 
 export interface VersionJson {
+  releaseVersion?: string
   apps?: {
     [packageName: string]: VersionInfo
   }
@@ -67,6 +68,8 @@ export interface OtaCheckResult {
    * instead of racing it with a second fetch of the same URL.
    */
   manifestBody: string | null
+  /** Coordinated release identity for the selected OTA pin. */
+  releaseVersion: string | null
   /**
    * Why the check failed, when it did. "network" is retryable (connection/server
    * trouble); "pin_unavailable" is permanent for this app build (manifest 404/gone,
@@ -107,6 +110,7 @@ function emptyCheckResult(skippedReason?: OtaCheckSkippedReason): OtaCheckCurren
     besVersion: null,
     isApkDowngrade: false,
     manifestBody: null,
+    releaseVersion: null,
     updateInfo: null,
     isRequired: true,
     skippedReason,
@@ -123,7 +127,7 @@ async function fetchVersionInfoDetailed(url: string): Promise<ManifestFetchResul
   try {
     const response = await fetch(url)
     if (!response.ok) {
-      console.error("Failed to fetch version info:", response.status)
+      console.warn("Failed to fetch version info:", response.status)
       // 4xx: the manifest does not exist (or is gone) — permanent for this app
       // build, retrying cannot help. Everything else is transient server/network
       // trouble and retryable.
@@ -135,11 +139,11 @@ async function fetchVersionInfoDetailed(url: string): Promise<ManifestFetchResul
     try {
       return {json: await response.json()}
     } catch (parseError) {
-      console.error("OTA: manifest is not valid JSON:", parseError)
+      console.warn("OTA: manifest is not valid JSON:", parseError)
       return {json: null, failureReason: "pin_unavailable"}
     }
   } catch (error) {
-    console.error("OTA: Error fetching version info:", error)
+    console.warn("OTA: Error fetching version info:", error)
     return {json: null, failureReason: "network"}
   }
 }
@@ -299,6 +303,7 @@ export async function checkForOtaUpdate(
         besVersion: null,
         isApkDowngrade: false,
         manifestBody: null,
+        releaseVersion: null,
         checkFailureReason: fetched.failureReason ?? "network",
       }
     }
@@ -330,6 +335,7 @@ export async function checkForOtaUpdate(
         besVersion: null,
         isApkDowngrade: false,
         manifestBody: null,
+        releaseVersion: null,
         checkFailureReason: "pin_unavailable",
       }
     }
@@ -368,6 +374,12 @@ export async function checkForOtaUpdate(
       besVersion: versionJson?.bes_firmware?.version || null,
       isApkDowngrade: apkDirection === "downgrade",
       manifestBody: versionJson ? JSON.stringify(versionJson) : null,
+      releaseVersion: resolveOtaReleaseVersion({
+        manifestReleaseVersion: versionJson.releaseVersion,
+        manifestUrl: otaVersionUrl,
+        packagedManifestUrl: ENGINE_RELEASE_METADATA.otaManifestUrl,
+        packagedReleaseIdentity: ENGINE_RELEASE_METADATA.releaseIdentity,
+      }),
     }
   } catch (error) {
     console.error("Error checking for OTA update:", error)
@@ -380,6 +392,7 @@ export async function checkForOtaUpdate(
       besVersion: null,
       isApkDowngrade: false,
       manifestBody: null,
+      releaseVersion: null,
       checkFailureReason: "network",
     }
   }
@@ -401,22 +414,19 @@ export async function checkCurrentGlassesForUpdate(
     return emptyCheckResult("disconnected")
   }
 
-  const embeddedManifestUrl = process.env.EXPO_PUBLIC_ASG_OTA_VERSION_URL?.trim()
-  const superMode = useSettingsStore.getState().getSetting(SETTINGS.super_mode.key)
-  const overrideUrl = useSettingsStore.getState().getSetting(SETTINGS.ota_version_url.key)
-  const overrideActive = superMode && typeof overrideUrl === "string" && overrideUrl.trim() !== ""
-  if (!embeddedManifestUrl && !overrideActive) {
-    console.log("OTA: check skipped - mobile app has no embedded OTA manifest pin")
+  if (!hasConfiguredModernOtaManifestPin()) {
+    console.log("OTA: check skipped - this app or Engine package has no embedded OTA manifest pin")
     return emptyCheckResult("dev_build")
   }
-  if (!embeddedManifestUrl) {
-    console.log("OTA: no embedded manifest pin, but super-mode manifest override is active - checking anyway")
-  }
 
   if (refreshVersionInfo) {
-    void BluetoothSdk.requestVersionInfo().catch((error) => {
-      console.warn("OTA: Failed to request version_info from glasses:", error)
-    })
+    void BluetoothSdk.requestVersionInfo()
+      .then((versionInfo) => {
+        useGlassesStore.getState().setGlassesInfo(versionInfo)
+      })
+      .catch((error) => {
+        console.warn("OTA: Failed to request version_info from glasses:", error)
+      })
   }
 
   let buildNumber = useGlassesStore.getState().buildNumber
@@ -470,6 +480,10 @@ export async function checkCurrentGlassesForUpdate(
   }
 
   const manifestUrl = resolveOtaManifestUrl(useGlassesStore.getState().otaVersionUrl, buildNumber)
+  if (!manifestUrl) {
+    console.log("OTA: check skipped - no OTA manifest pin resolved")
+    return emptyCheckResult("dev_build")
+  }
   const result = await checkForOtaUpdate(
     manifestUrl,
     buildNumber,

package/src/services/PhoneNotificationsSync.ts

@@ -1,24 +1,50 @@
 /**
- * Phone-notifications sync — engine-owned. Pushes the notification-forwarding
- * operational kill switch + config (`android_notification_listener_enabled`
- * and `notifications_blocklist`) to the native
- * NotificationListener via `CrustModule.setNotificationConfig`, so
+ * Phone-notifications sync — engine-owned. Started by `engine.start()`.
+ *
+ * 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-only; a no-op elsewhere. Started by `engine.start()`.
+ * not capture.
+ *
+ * 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.
  */
+import {Platform} from "react-native"
 import {shallow} from "zustand/shallow"
 import CrustModule from "@glassly/crust"
+import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
+import type {
+  G2NotificationCtrlSetting,
+  G2NotificationFilterSetting,
+  NotificationAppSeenEvent,
+} from "@glassly/bluetooth-sdk/internal"
 
 import {useSettingsStore, SETTINGS} from "../stores/settings"
+import {IOS_NOTIFICATION_APP_CATALOG} from "./iosNotificationAppCatalog"
+
+export interface SeenNotificationApp {
+  appId: string
+  displayName: string
+  lastSeen: number
+}
 
 let unsubscribe: (() => void) | null = null
+let seenAppsSubscription: {remove(): void} | null = null
 
-function pushConfig(): void {
+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)
@@ -27,20 +53,110 @@ function pushConfig(): void {
   )
 }
 
+export function getSeenNotificationApps(): SeenNotificationApp[] {
+  const seen = useSettingsStore.getState().getSetting(SETTINGS.ios_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}> {
+  const merged = new Map<string, string>()
+  for (const app of IOS_NOTIFICATION_APP_CATALOG) {
+    merged.set(app.appId, app.displayName)
+  }
+  for (const app of getSeenNotificationApps()) {
+    if (app.appId) merged.set(app.appId, app.displayName || app.appId)
+  }
+  return [...merged.entries()]
+    .map(([appId, displayName]) => ({appId, displayName}))
+    .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}
+}
+
+function computeG2NotificationCtrl(): G2NotificationCtrlSetting {
+  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)),
+  }
+}
+
+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(),
+    }),
+  ).catch((err: unknown) =>
+    console.warn(`PhoneNotificationsSync: notification config push failed: ${(err as Error)?.message ?? err}`),
+  )
+}
+
+/** Record a glasses-reported source app. Writes only on new app / renamed app. */
+function recordSeenApp(event: NotificationAppSeenEvent): void {
+  if (!event.appId) return
+  const seen = getSeenNotificationApps()
+  const existing = seen.find((app) => app.appId === event.appId)
+  const displayName = event.displayName || existing?.displayName || event.appId
+  if (existing && existing.displayName === displayName) return
+  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)
+}
+
 export function startPhoneNotificationsSync(): void {
   if (unsubscribe) return
-  pushConfig() // initial sync so the listener has the current config
+
+  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(),
+      {equalityFn: shallow},
+    )
+    return
+  }
+
+  if (Platform.OS !== "ios") return
+
+  pushIosConfig()
   unsubscribe = useSettingsStore.subscribe(
     (state) => ({
-      listenerEnabled: state.getSetting(SETTINGS.android_notification_listener_enabled.key),
       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),
     }),
-    () => pushConfig(),
+    () => pushIosConfig(),
     {equalityFn: shallow},
   )
+  seenAppsSubscription = BluetoothSdk.addListener("notification_app_seen", recordSeenApp)
 }
 
 export function stopPhoneNotificationsSync(): void {
   unsubscribe?.()
   unsubscribe = null
+  seenAppsSubscription?.remove()
+  seenAppsSubscription = null
 }

package/src/services/PhonePhotoCoordinator.ts

@@ -166,7 +166,7 @@ export class PhonePhotoCoordinator {
     // to time out. Fail fast with a typed error.
     //
     // We DON'T pre-check `hasCamera` here — the canonical capability data
-    // lives in `getModelCapabilities(deviceModel)` in the engine types and
+    // lives in `getModelCapabilities(deviceModel)` from @glassly/engine and
     // pulling that into this file would add a cross-package import. If a
     // cameraless device receives the BLE photo command, the glasses-side
     // handler will return a photo_response error within ~1s and the gated

package/src/services/PhoneStreamCoordinator.ts

@@ -796,12 +796,6 @@ export class PhoneStreamCoordinator {
       for (const reject of entry.hlsReadyRejecters) reject(pendingErr)
       entry.hlsReadyResolvers = []
       entry.hlsReadyRejecters = []
-      // Cloudflare DELETE is fire-and-forget — failing it doesn't undo the
-      // BLE stop we're about to do, and Cloudflare's idle-input scavenger
-      // will eventually clean up leaked inputs.
-      teardownManagedStream(entry.liveInputId).catch((err) => {
-        console.warn("[STREAM] teardownManagedStream failed:", err)
-      })
     }
 
     try {
@@ -816,6 +810,16 @@ export class PhoneStreamCoordinator {
       // Only clear if we're still the active entry (defensive — runExclusive
       // serializes us, so this should always be true).
       if (this.current === entry) this.current = null
+
+      if (entry.kind === "managed") {
+        // Start remote cleanup only after the publisher has stopped, but do not
+        // hold the local transition lock on an unbounded network request. The
+        // runtime's durable cleanup queue owns retries if this request fails or
+        // the app exits before Cloudflare finishes finalizing the recording.
+        void teardownManagedStream(entry.liveInputId).catch((err) => {
+          console.warn("[STREAM] teardownManagedStream failed:", err)
+        })
+      }
     }
   }
 }

package/src/services/SceneRenderer.ts

@@ -273,6 +273,10 @@ class SceneRenderer {
   }
 
   private sendFrame(frame: SceneFrame): void {
+    // Single native view: only the visible surface's frames go out. Suppressed
+    // main frames stay committed; setDashboardActive(false) replays them.
+    const dashboardActive = useDisplayStore.getState().dashboardActive
+    if (dashboardActive !== (frame.view === "dashboard")) return
     try {
       // Frames carry the canvas they were laid out against; only a frame from
       // a path that predates the tag falls back to the current capabilities.

package/src/services/StreamLifecycleController.ts

@@ -2,6 +2,10 @@
  * Drives RTMP stream liveliness checks via a keep-alive heartbeat:
  * `setActive(true)` starts the timer; each tick sends a keep-alive with a
  * fresh ackId; `maxMissedAcks` consecutive timeouts fire `onTimeout`.
+ *
+ * Phone-owned successor to the retired cloud stream lifecycle controller.
+ * It uses the local `LifecycleLogger` interface because pino is not a phone
+ * dependency.
  */
 
 export interface LifecycleLogger {

package/src/services/asg/localNetworkTransport.ts

@@ -1,5 +1,5 @@
 import * as RNFS from "@dr.pogodin/react-native-fs"
-import {LocalNetwork, type LocalNetworkDownloadProgress} from "@glassly/bluetooth-sdk/internal"
+import {otaLocalNetwork, type OtaLocalNetworkDownloadProgress} from "@glassly/bluetooth-sdk/ota-transport"
 import {Buffer} from "buffer"
 import {Platform} from "react-native"
 import WifiManager from "react-native-wifi-reborn"
@@ -17,7 +17,7 @@ export function shouldUseScopedLocalNetwork(os: string, moduleAvailable: boolean
 }
 
 function supportsScopedConnection(): boolean {
-  return shouldUseScopedLocalNetwork(Platform.OS, LocalNetwork != null)
+  return shouldUseScopedLocalNetwork(Platform.OS, otaLocalNetwork.isAvailable())
 }
 
 function normalizeHeaders(headers?: HeadersInit): Record<string, string> {
@@ -48,25 +48,25 @@ export const localNetworkTransport = {
       await WifiManager.connectToProtectedSSID(ssid, password, false, false)
       return undefined
     }
-    const result = await LocalNetwork!.connect(ssid, password)
+    const result = await otaLocalNetwork.connect(ssid, password)
     scopedConnectionActive = true
     return result.localAddress
   },
 
   async disconnect(): Promise<void> {
     if (supportsScopedConnection()) {
-      await LocalNetwork!.disconnect().catch(() => {})
+      await otaLocalNetwork.disconnect().catch(() => {})
     }
     scopedConnectionActive = false
     nativeJobs.clear()
   },
 
   async fetch(url: string | URL | Request, init?: RequestInit, timeoutMs = 30_000): Promise<Response> {
-    if (!scopedConnectionActive || !LocalNetwork || typeof url !== "string") {
+    if (!scopedConnectionActive || !otaLocalNetwork.isAvailable() || typeof url !== "string") {
       return globalThis.fetch(url, init)
     }
 
-    const nativeModule = LocalNetwork
+    const nativeModule = otaLocalNetwork
     const id = requestId("request")
     const signal = init?.signal
     const cancel = () => void nativeModule.cancel(id)
@@ -92,13 +92,13 @@ export const localNetworkTransport = {
   },
 
   downloadFile(options: DownloadOptions): DownloadHandle {
-    if (!scopedConnectionActive || !LocalNetwork) return RNFS.downloadFile(options)
+    if (!scopedConnectionActive || !otaLocalNetwork.isAvailable()) return RNFS.downloadFile(options)
 
     const jobId = nextJobId++
     const id = requestId("download")
     let began = false
     nativeJobs.set(jobId, id)
-    const subscription = LocalNetwork.addListener("downloadProgress", (event: LocalNetworkDownloadProgress) => {
+    const subscription = otaLocalNetwork.onDownloadProgress((event: OtaLocalNetworkDownloadProgress) => {
       if (event.requestId !== id) return
       if (!began) {
         began = true
@@ -116,14 +116,15 @@ export const localNetworkTransport = {
       })
     })
 
-    const promise = LocalNetwork.download(
-      id,
-      options.fromUrl,
-      options.toFile,
-      options.headers || {},
-      options.connectionTimeout || 30_000,
-      options.readTimeout || 30_000,
-    )
+    const promise = otaLocalNetwork
+      .download(
+        id,
+        options.fromUrl,
+        options.toFile,
+        options.headers || {},
+        options.connectionTimeout || 30_000,
+        options.readTimeout || 30_000,
+      )
       .then((result) => {
         if (!began) {
           options.begin?.({
@@ -154,16 +155,16 @@ export const localNetworkTransport = {
 
   stopDownload(jobId: number): void {
     const nativeId = nativeJobs.get(jobId)
-    if (nativeId && LocalNetwork) {
+    if (nativeId && otaLocalNetwork.isAvailable()) {
       cancelledNativeJobs.add(jobId)
-      void LocalNetwork.cancel(nativeId)
+      void otaLocalNetwork.cancel(nativeId)
       return
     }
     RNFS.stopDownload(jobId)
   },
 }
 
-LocalNetwork?.addListener("networkLost", () => {
+otaLocalNetwork.onNetworkLost(() => {
   scopedConnectionActive = false
   nativeJobs.clear()
 })