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

package/src/services/OtaAutoChain.ts

@@ -0,0 +1,130 @@
+import type {OtaCheckCurrentGlassesResult} from "./OtaUpdateCheckService"
+
+export const MAX_OTA_AUTO_CHAIN_PASSES = 8
+export const OTA_AUTO_CHAIN_RECONNECT_TIMEOUT_MS = 120_000
+
+type OtaAutoChainSession = {
+  approvedDowngrade: boolean
+  passCount: number
+  releaseRange: OtaAutoChainReleaseRange
+  reconnectDeadline: number | null
+  seenFingerprints: Set<string>
+}
+
+export type OtaAutoChainReleaseRange = {
+  fromVersion: string | null
+  toVersion: string | null
+  /** Exact coordinated release identity for the OTA pin, absent for legacy manifests. */
+  releaseVersion?: string | null
+}
+
+export type OtaAutoChainAdvanceResult =
+  | {advance: true; passCount: number}
+  | {advance: false; reason: "inactive" | "duplicate" | "max_passes" | "downgrade_not_approved"}
+
+let session: OtaAutoChainSession | null = null
+
+/**
+ * Identify the exact update offer that produced one OTA pass. Including the
+ * observed versions and manifest body lets a changed manifest advance while a
+ * stale post-install version_info response is rejected as a duplicate.
+ */
+export function otaAutoChainFingerprint(result: OtaCheckCurrentGlassesResult): string {
+  return JSON.stringify({
+    manifestUrl: result.manifestUrl ?? "",
+    manifestBody: result.manifestBody ?? "",
+    buildNumber: result.buildNumber ?? "",
+    mtkFirmwareVersion: result.mtkFirmwareVersion ?? "",
+    besFirmwareVersion: result.besFirmwareVersion ?? "",
+    updates: result.updates,
+    targetBuildNumber: result.updateInfo?.versionCode ?? result.latestVersionInfo?.versionCode ?? 0,
+    targetBesVersion: result.besVersion ?? "",
+    mtkPatch: result.mtkPatch
+      ? {
+          startFirmware: result.mtkPatch.start_firmware,
+          endFirmware: result.mtkPatch.end_firmware,
+          url: result.mtkPatch.url,
+        }
+      : null,
+  })
+}
+
+/** Start a chain after the user explicitly approves its first update pass. */
+export function beginOtaAutoChain(
+  initialFingerprint: string,
+  approvedDowngrade: boolean,
+  releaseRange: OtaAutoChainReleaseRange,
+): void {
+  session = {
+    approvedDowngrade,
+    passCount: 1,
+    releaseRange: {...releaseRange},
+    reconnectDeadline: null,
+    seenFingerprints: new Set([initialFingerprint]),
+  }
+}
+
+export function isOtaAutoChainActive(): boolean {
+  return session !== null
+}
+
+export function otaAutoChainReleaseRange(): OtaAutoChainReleaseRange | null {
+  return session ? {...session.releaseRange} : null
+}
+
+/** End the current chain. Safe to call when no chain is active. */
+export function stopOtaAutoChain(): void {
+  session = null
+}
+
+/**
+ * Start (or continue) the bounded wait for glasses that are rebooting between
+ * passes. Re-renders must not extend the original deadline indefinitely.
+ */
+export function otaAutoChainReconnectWaitRemaining(now = performance.now()): number | null {
+  if (!session) return null
+
+  session.reconnectDeadline ??= now + OTA_AUTO_CHAIN_RECONNECT_TIMEOUT_MS
+  return Math.max(0, session.reconnectDeadline - now)
+}
+
+/** A successful reconnect allows a future pass to establish a fresh wait. */
+export function clearOtaAutoChainReconnectWait(): void {
+  if (session) session.reconnectDeadline = null
+}
+
+/**
+ * Admit the next pass of an active chain. Repeated offers, unexpectedly
+ * destructive downgrades, and runaway chains fail closed and end automation.
+ */
+export function tryAdvanceOtaAutoChain(
+  fingerprint: string,
+  isDowngrade: boolean,
+  targetVersion: string | null,
+  releaseVersion: string | null = null,
+): OtaAutoChainAdvanceResult {
+  if (!session) {
+    return {advance: false, reason: "inactive"}
+  }
+
+  if (isDowngrade && !session.approvedDowngrade) {
+    stopOtaAutoChain()
+    return {advance: false, reason: "downgrade_not_approved"}
+  }
+
+  if (session.seenFingerprints.has(fingerprint)) {
+    stopOtaAutoChain()
+    return {advance: false, reason: "duplicate"}
+  }
+
+  if (session.passCount >= MAX_OTA_AUTO_CHAIN_PASSES) {
+    stopOtaAutoChain()
+    return {advance: false, reason: "max_passes"}
+  }
+
+  session.seenFingerprints.add(fingerprint)
+  session.passCount += 1
+  if (targetVersion) session.releaseRange.toVersion = targetVersion
+  if (releaseVersion) session.releaseRange.releaseVersion = releaseVersion
+  return {advance: true, passCount: session.passCount}
+}

package/src/services/OtaErrorMapping.ts

@@ -0,0 +1,80 @@
+import type {OtaProgress, OtaStatus} from "../facades/ota"
+
+export const BES_INSTALL_RESTART_MESSAGE =
+  "Restart your glasses to safely exit firmware update mode before trying again"
+
+function isDownloadPhaseSnapshot(
+  otaStatus: OtaStatus | null | undefined,
+  otaProgress: OtaProgress | null | undefined,
+): boolean {
+  if (otaStatus?.phase === "download") {
+    return true
+  }
+  if (otaProgress?.stage === "download") {
+    return true
+  }
+  return false
+}
+
+/**
+ * Offer Change WiFi whenever the OTA flow failed while the glasses were in the
+ * download step (any download failure — network, SSL, size cap, verify, etc.).
+ *
+ * Also covers phone-side watchdog failures that fire while the store still shows
+ * an active download phase (stall / global timeout mid-download).
+ */
+export function shouldShowChangeWifiForOtaDownloadFailure(
+  otaStatus: OtaStatus | null | undefined,
+  otaProgress: OtaProgress | null | undefined,
+  localErrorMessage: string,
+): boolean {
+  if (otaStatus?.status === "failed" && otaStatus.phase === "download") {
+    return true
+  }
+  if (otaProgress?.status === "FAILED" && otaProgress.stage === "download") {
+    return true
+  }
+  if (localErrorMessage && isDownloadPhaseSnapshot(otaStatus, otaProgress)) {
+    return true
+  }
+  return false
+}
+
+export function getOtaErrorMessage(error?: string): string {
+  switch (error) {
+    case "no_internet":
+      return "Glasses WiFi has no internet connection"
+    case "clock_skew":
+      return "Glasses clock is wrong — syncing time from your phone, then retrying update check"
+    case "ssl_error":
+      return "Secure connection failed — try a different WiFi network"
+    case "download_failed":
+      return "Download failed — check glasses WiFi connection"
+    case "firmware_too_large":
+      return "Firmware file is unexpectedly large — please contact support"
+    case "firmware_verify_failed":
+      return "Firmware verification failed — please try again or contact support"
+    case "apk_verify_failed":
+      return "Update verification failed — please try again or contact support"
+    case "install_failed":
+      return "Install failed — please try again"
+    default:
+      return error || "Update failed"
+  }
+}
+
+/**
+ * Once a BES install has started, any failure conservatively requires a glasses restart. This
+ * avoids adding a BES-specific error code to the wire protocol and, more importantly, never offers
+ * an unsafe retry when a generic failure or silence may mean BES entered its raw OTA parser.
+ */
+export function shouldRequireGlassesRebootForBesFailure(
+  otaStatus: OtaStatus | null | undefined,
+  _otaProgress: OtaProgress | null | undefined,
+  localErrorMessage: string,
+): boolean {
+  if (otaStatus?.stepType !== "bes" || otaStatus.phase !== "install") {
+    return false
+  }
+  return otaStatus.status === "failed" || Boolean(localErrorMessage)
+}

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"
@@ -170,6 +169,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"
@@ -407,7 +408,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 +450,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 +469,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 +507,7 @@ class OtaInstallCoordinator {
       versionChangePhase: this.deriveVersionChangePhase(connected),
       hotspotPhase: this.hotspotPhase,
       hotspotArtifactPercent: this.hotspotArtifactPercent,
+      transport: this.selectedTransport,
     }
   }
 
@@ -1065,7 +1068,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 +1112,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 +1128,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 +1157,7 @@ class OtaInstallCoordinator {
     this.clearProgressTimeout()
     this.onFirstActivity()
     this.onFirstNonZeroProgress()
-    void BluetoothSdk.sendOtaQueryStatus()
+    void BluetoothSdk.queryOtaStatus().catch(() => {})
     useGlassesStore.getState().setMtkUpdatedThisSession(true)
   }
 
@@ -1345,7 +1348,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 +1495,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)

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/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()
 })

package/src/services/gestureClaims.ts

@@ -0,0 +1,28 @@
+/**
+ * Gesture-claim arbitration (CLAIM_GESTURES), split out of
+ * LocalMiniappRuntime so it is unit-testable — the runtime module itself
+ * pulls a native import surface bun can't parse.
+ */
+
+/**
+ * True iff the miniapp in front of the user has claimed `gesture`.
+ *
+ * "In front" spans both screens. Most claiming apps are glasses-side: the
+ * terminal runs as a background miniapp with the phone pocketed, so gating on
+ * the phone's Compositor foreground alone left its double_tap claim inert and
+ * the system dashboard kept opening mid-session. Glasses ownership is the
+ * primary signal; the phone foreground is still honored for apps driven from
+ * the handset. A claimer that owns neither screen is background and never
+ * hijacks a system gesture.
+ */
+export function claimsGesture(
+  claims: ReadonlyMap<string, ReadonlySet<string>>,
+  gesture: string,
+  glassesOwner: string | null,
+  phoneForeground: string | null,
+): boolean {
+  for (const pkg of [glassesOwner, phoneForeground]) {
+    if (pkg && claims.get(pkg)?.has(gesture) === true) return true
+  }
+  return false
+}

package/src/services/gestureDotGlyphs.ts

@@ -0,0 +1,14 @@
+/**
+ * GENERATED by scripts/gen-gesture-dot-glyphs.mjs — do not edit by hand.
+ * 24×24 8-bit grayscale PNGs (white on black) for the gesture-dots indicator.
+ */
+export const GESTURE_DOT_GLYPH_SIZE = 24
+
+export type GestureDotGlyph = "dot" | "up" | "down" | "blank"
+
+export const GESTURE_DOT_GLYPHS: Record<GestureDotGlyph, string> = {
+  dot: "iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAAAAADFHGIkAAAALklEQVR4nM2QsQ0AAAjC/P/pmrhqZ+xIF6DqBQyWbwO3gduAmKjQuj7QL/ETEzQmMptl7Q9NBAAAAABJRU5ErkJggg==",
+  up: "iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAAAAADFHGIkAAAAMElEQVR4nGNgoCv4////f1zi2GT+/4ciTHE4RhdHIlDFUUhkcTQKQx9WBw8PCVoBAIcbOcf3xeeBAAAAAElFTkSuQmCC",
+  down: "iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAAAAADFHGIkAAAALUlEQVR4nGNgoC/4/3+4SkBFUCkkNjKJIoMg0GRgGEMGgrC4CQSwuxanR2gEAO1/Ocfgp8uvAAAAAElFTkSuQmCC",
+  blank: "iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAAAAADFHGIkAAAAD0lEQVR4nGNgGAWjgPoAAAJYAAGgxYwDAAAAAElFTkSuQmCC",
+}

package/src/services/glassesClockSync.ts

@@ -2,7 +2,7 @@
  * Push phone time to glasses only when clock skew is detected (gallery sync, OTA, etc.).
  */
 
-import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
+import BluetoothSdk from "@glassly/bluetooth-sdk"
 import {BgTimer} from "../utils/timers"
 import {useGlassesStore} from "../stores/glasses"
 
@@ -87,6 +87,10 @@ export async function handleOtaClockSkewFromGlasses(
       lastOtaClockFixAt = Date.now()
       const {buildNumber, otaVersionUrl} = useGlassesStore.getState()
       const manifestUrl = resolveOtaManifestUrl(otaVersionUrl, buildNumber)
+      if (!manifestUrl) {
+        console.warn("[GlassesClockSync] OTA restart skipped because this build has no manifest pin")
+        return false
+      }
       console.log("[GlassesClockSync] ⏰ Restarting OTA with ota_start after clock fix")
       await BluetoothSdk.startOtaUpdate(manifestUrl)
       return true

package/src/services/otaDisplayState.ts

@@ -1,4 +1,4 @@
-import type {OtaProgress, OtaStatus} from "@glassly/bluetooth-sdk/internal"
+import type {OtaProgress, OtaStatus} from "@glassly/bluetooth-sdk"
 
 import {isLegacyShapedOtaStatus} from "./otaInstallPolicy"
 

package/src/services/otaInstallPolicy.ts

@@ -1,5 +1,5 @@
 /** Shared OTA progress watchdog timings (see progress-legacy.tsx / progress.tsx). */
-import type {OtaProgress, OtaStatus} from "@glassly/bluetooth-sdk/internal"
+import type {OtaProgress, OtaStatus} from "@glassly/bluetooth-sdk"
 
 /**
  * First glasses `build_number` (ASG `versionCode`) that uses `progress.tsx` with unified

package/src/services/otaLegacyMapping.ts

@@ -1,4 +1,4 @@
-import type {OtaProgress, OtaProgressStatus, OtaStatus} from "@glassly/bluetooth-sdk/internal"
+import type {OtaProgress, OtaProgressStatus, OtaStatus} from "@glassly/bluetooth-sdk"
 
 /** Normalized ota_status fields (snake_case) after bridging Core/expo (snake or camel). */
 export type NormalizedOtaStatusEvent = {