@mentra/engine 3.2.0-dev.248 → 3.2.0-dev.250

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/engine",
-  "version": "3.2.0-dev.248",
+  "version": "3.2.0-dev.250",
   "description": "Mentra Engine — miniapp registry, WebView bridge, and miniapp store",
   "main": "build/index.js",
   "react-native": "src/index.ts",
@@ -97,13 +97,13 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@mentra/acs-meeting": "3.2.0-dev.248",
-    "@mentra/glasses-media": "3.2.0-dev.248",
-    "@mentra/bluetooth-sdk": "3.2.0-dev.248",
-    "@mentra/cloud-client": "3.2.0-dev.248",
-    "@mentra/cloud-protocol": "3.2.0-dev.248",
-    "@mentra/crust": "3.2.0-dev.248",
-    "@mentra/miniapp": "3.2.0-dev.248",
+    "@mentra/acs-meeting": "3.2.0-dev.250",
+    "@mentra/glasses-media": "3.2.0-dev.250",
+    "@mentra/bluetooth-sdk": "3.2.0-dev.250",
+    "@mentra/cloud-client": "3.2.0-dev.250",
+    "@mentra/cloud-protocol": "3.2.0-dev.250",
+    "@mentra/crust": "3.2.0-dev.250",
+    "@mentra/miniapp": "3.2.0-dev.250",
     "buffer": "^6.0.3",
     "events": "^3.3.0",
     "react-native-marked": "8.1.1",

package/src/generated/releaseMetadata.ts

@@ -12,9 +12,9 @@ export interface EngineReleaseMetadata {
 export const ENGINE_RELEASE_METADATA: Readonly<EngineReleaseMetadata> = Object.freeze({
   "schemaVersion": 1,
   "familyBaseVersion": "3.2.0",
-  "releaseIdentity": "3.2.0-dev.248",
-  "releaseSetId": "mentra-3.2.0-dev.248",
-  "sourceCommit": "8bc5eb096a0c404e1d599796727e66d973678575",
-  "otaManifestUrl": "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.248.json",
-  "otaManifestSha256": "7e649fb7601d70d6c235be79540fd6508d72932461b97118abc0cdbd5d36d268"
+  "releaseIdentity": "3.2.0-dev.250",
+  "releaseSetId": "mentra-3.2.0-dev.250",
+  "sourceCommit": "3707f9ec51f41355d71e1783e2783bd0e451c9e6",
+  "otaManifestUrl": "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.250.json",
+  "otaManifestSha256": "39fa2567b9b83b52200f266058ed23f44633fa3239a6f3659a1afbee820d4523"
 })

package/src/services/AcsMeetingService.ts

@@ -569,6 +569,8 @@ class AcsMeetingService {
   private lastMediaRestartAt = 0
   /** Callers parked in [waitForFirstFrame], woken by the next `mediaSource` verdict. */
   private readonly firstFrameWaiters = new Set<(error?: Error) => void>()
+  /** Mid-call republish waiters: live resolves true, leave/timeout resolves false. Failed is ignored. */
+  private readonly mediaLiveWaiters = new Set<(live: boolean) => void>()
   private scopedLostSub: {remove: () => void} | null = null
   private readonly scopedLostListeners = new Set<(error: {code: string; message: string}) => void>()
   /**
@@ -837,6 +839,42 @@ class AcsMeetingService {
     if (mediaSource !== "live" && mediaSource !== "failed") return
     const error = mediaSource === "failed" ? new Error("The glasses video feed failed") : undefined
     for (const settle of [...this.firstFrameWaiters]) settle(error)
+    if (mediaSource === "live") this.settleMediaLiveWaiters(true)
+  }
+
+  private settleMediaLiveWaiters(live: boolean): void {
+    for (const settle of [...this.mediaLiveWaiters]) settle(live)
+  }
+
+  /**
+   * Mid-call SoftAP camera recovery. Resolves `true` only when ingest is live again.
+   * A standing `failed` is why we republished, so it must not abort the wait the way
+   * [waitForFirstFrame] does on join.
+   */
+  waitUntilMediaLive(timeoutMs: number): Promise<boolean> {
+    if (this.lastState.mediaSource === "live") return Promise.resolve(true)
+    const startedAt = Date.now()
+    softapTrace("acs_media_live_wait", {
+      timeoutMs,
+      mediaSource: this.lastState.mediaSource ?? "unknown",
+      state: this.lastState.state,
+    })
+    return new Promise<boolean>((resolve) => {
+      const settle = (live: boolean) => {
+        if (done) return
+        done = true
+        clearTimeout(timer)
+        this.mediaLiveWaiters.delete(settle)
+        softapTrace("acs_media_live_wait_done", {
+          waitedMs: Date.now() - startedAt,
+          live,
+        })
+        resolve(live)
+      }
+      let done = false
+      const timer = setTimeout(() => settle(false), timeoutMs)
+      this.mediaLiveWaiters.add(settle)
+    })
   }
 
   /**
@@ -1164,6 +1202,8 @@ class AcsMeetingService {
     // rejected, or a leave mid-join leaves the orchestrator waiting out its whole timeout.
     for (const settle of [...this.firstFrameWaiters]) settle(new Error("The meeting ended"))
     this.firstFrameWaiters.clear()
+    this.settleMediaLiveWaiters(false)
+    this.mediaLiveWaiters.clear()
     this.stopGlassesMicUplink()
     this.unwatchPhoneNetwork()
     await this.stopPcm()

package/src/services/LocalMiniappRuntime.ts

@@ -3748,6 +3748,9 @@ class LocalMiniappRuntime {
         type: MiniappResponseType.MEETING_STATE,
         ...state,
       })
+      if (attempt?.ownsResources && attempt.transport?.shouldRepublish(state.mediaSource)) {
+        void attempt.transport.republish(state.mediaSourceReason ?? "mediaSource failed")
+      }
     })
   }
 
@@ -4102,6 +4105,7 @@ class LocalMiniappRuntime {
         displayName: args.displayName,
         video: args.video,
         awaitFirstFrame: () => acsMeetingService.waitForFirstFrame(SOFTAP_FIRST_FRAME_MS),
+        waitUntilLive: (timeoutMs) => acsMeetingService.waitUntilMediaLive(timeoutMs),
         subsystems: {
           setHotspotState: async (enabled) => {
             const status = await this.setGlassesHotspotState(enabled)

package/src/services/SoftapCallTransport.ts

@@ -205,6 +205,13 @@ export interface SoftapCallDeps {
    * that never delivers a frame reads as healthy behind a frozen tile.
    */
   awaitFirstFrame(report?: SoftapStepReporter): Promise<void>
+  /**
+   * Mid-call camera recovery. Resolves `true` only when ingest is live again.
+   * A standing `failed` is the reason we are republishing, so it must not abort the wait.
+   */
+  waitUntilLive?(timeoutMs: number): Promise<boolean>
+  /** Delay after a failed `start_stream` before the next republish attempt. Tests set 0. */
+  republishRetryDelayMs?: number
 }
 
 export interface SoftapCallOptions {
@@ -246,6 +253,15 @@ function deferred(): {promise: Promise<void>; resolve: () => void} {
   return {promise, resolve}
 }
 
+function sleep(ms: number): Promise<void> {
+  if (ms <= 0) return Promise.resolve()
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+/** How long a mid-call republish waits for a frame after re-issuing `start_stream`. */
+export const SOFTAP_REPUBLISH_LIVE_MS = 20_000
+const REPUBLISH_RETRY_DELAY_MS = 2_000
+
 /**
  * How a call is being taken down.
  *
@@ -322,6 +338,9 @@ export class SoftapCallTransport {
   private startedAt = 0
   private traceId = ""
   private onProgress: ((progress: SoftapProgress) => void) | undefined
+  private republishing: Promise<void> | null = null
+  /** Bumped by `stop` so an in-flight republish cannot start_stream after Leave. */
+  private republishGeneration = 0
 
   constructor(private readonly deps: SoftapCallDeps) {}
 
@@ -329,6 +348,71 @@ export class SoftapCallTransport {
     return this.phase
   }
 
+  /**
+   * The glasses camera died after this call was already live. Re-issue `start_stream` at the
+   * existing ingest URL — do not rebind the WHIP listener, or the glasses POST to a dead port.
+   */
+  shouldRepublish(mediaSource?: string): boolean {
+    return this.phase === "live" && !this.terminating && mediaSource === "failed"
+  }
+
+  /**
+   * Rebuild the glasses publisher onto the standing SoftAP ingest URL.
+   *
+   * ACS, BLE mic, and the WHIP listener stay up. The glasses process is what usually vanished
+   * (UVC/`system_server` crash); a new `start_stream` is what they need after ASG comes back.
+   */
+  republish(reason: string): Promise<void> {
+    if (this.phase !== "live" || this.terminating || !this.ingestUrl) return Promise.resolve()
+    if (this.republishing) return this.republishing
+    const generation = this.republishGeneration
+    this.republishing = this.runRepublish(reason, generation).finally(() => {
+      if (this.republishGeneration === generation) this.republishing = null
+    })
+    return this.republishing
+  }
+
+  private async runRepublish(reason: string, generation: number): Promise<void> {
+    const ingestUrl = this.ingestUrl
+    if (!ingestUrl) return
+    const retryDelayMs = this.deps.republishRetryDelayMs ?? REPUBLISH_RETRY_DELAY_MS
+    let attempt = 0
+    softapTrace("glasses_republish_begin", {reason, ingestUrl})
+    while (
+      generation === this.republishGeneration &&
+      !this.terminating &&
+      this.phase === "live" &&
+      this.ingestUrl === ingestUrl
+    ) {
+      attempt += 1
+      try {
+        await this.deps.stopPublishing()
+        if (generation !== this.republishGeneration || this.terminating) return
+        await this.deps.startPublishing({ingestUrl, traceId: this.traceId})
+        if (generation !== this.republishGeneration || this.terminating) {
+          await this.deps.stopPublishing().catch(() => undefined)
+          return
+        }
+        softapTrace("glasses_republish_sent", {attempt, ingestUrl})
+        if (!this.deps.waitUntilLive) return
+        const live = await this.deps.waitUntilLive(SOFTAP_REPUBLISH_LIVE_MS)
+        if (generation !== this.republishGeneration || this.terminating) return
+        if (live) {
+          softapTrace("glasses_republish_live", {attempt})
+          return
+        }
+        softapTraceFailure("glasses_republish_no_frame", {attempt})
+      } catch (error) {
+        if (generation !== this.republishGeneration || this.terminating) return
+        softapTraceFailure("glasses_republish_start_failed", {
+          attempt,
+          reason: error instanceof Error ? error.message : String(error),
+        })
+        await sleep(retryDelayMs)
+      }
+    }
+  }
+
   /**
    * True once a teardown has been decided. Anything that would otherwise report a failure — a lost
    * hotspot, a dropped ACS call — must check this first: after the wearer asks to leave, those are
@@ -577,6 +661,7 @@ export class SoftapCallTransport {
     // Intent before action, always: a watcher must be able to tell a deliberate teardown from a
     // failure even during the very first await below.
     this.terminating = true
+    this.republishGeneration++
     if (options.mode) this.teardownMode = options.mode
     if (this.stopping) {
       softapTrace("softap_stop_joined_in_flight", {mode: this.teardownMode})
@@ -833,6 +918,11 @@ export function createSoftapCallDeps(args: {
   video?: {width: number; height: number; fps: number; maxBitrateBps: number}
   /** Resolves when the meeting reports a frame reached ACS; rejects on a failed feed. */
   awaitFirstFrame: () => Promise<void>
+  /**
+   * Mid-call camera recovery. Resolves `true` only when ingest is live again.
+   * A standing `failed` is the reason we are republishing, so it must not abort the wait.
+   */
+  waitUntilLive?: (timeoutMs: number) => Promise<boolean>
   subsystems: {
     setHotspotState: (enabled: boolean) => Promise<{state: string; ssid?: string; password?: string; localIp?: string}>
     /** Whether this phone's Wi-Fi radio is on. Optional: only Android hosts can answer it. */
@@ -1080,5 +1170,6 @@ export function createSoftapCallDeps(args: {
     },
     stopPublishing: () => subsystems.stopPublishing(packageName),
     awaitFirstFrame: args.awaitFirstFrame,
+    waitUntilLive: args.waitUntilLive,
   }
 }