@mentra/engine 3.2.0-dev.116 → 3.2.0-dev.121

package/src/services/GlassesStatusProjection.ts

@@ -14,6 +14,34 @@
 import BluetoothSdk, {type PublicGlassesStatus} from "@mentra/bluetooth-sdk"
 import {useCoreStore} from "../stores/core"
 import {useGlassesStore} from "../stores/glasses"
+import {isGlassesConnected} from "./GlassesReadiness"
+
+/** Miniapp `session.glasses.onConnection` payload. */
+export type MiniappConnectionData = {
+  connected: boolean
+  modelName?: string
+}
+
+/**
+ * Native `glasses_status` is a store delta (`connection.state`, battery, wifi…).
+ * Miniapps subscribe to a boolean `connected` field. Forwarding the raw status
+ * makes `Boolean(data.connected)` false on every heartbeat while the Mentra App
+ * still shows the glasses linked.
+ */
+export function toMiniappConnectionData(status: unknown): MiniappConnectionData | null {
+  if (!status || typeof status !== "object") return null
+  const rec = status as Partial<PublicGlassesStatus> & {connected?: boolean; modelName?: string}
+  if (typeof rec.connected === "boolean") {
+    const modelName = rec.modelName || rec.deviceModel
+    return {connected: rec.connected, ...(modelName ? {modelName} : {})}
+  }
+  if (!rec.connection) return null
+  const modelName = rec.deviceModel
+  return {
+    connected: isGlassesConnected(rec.connection),
+    ...(modelName ? {modelName} : {}),
+  }
+}
 
 let unsubs: Array<() => void> = []
 let projectionRunId = 0

package/src/services/LocalMiniappRuntime.ts

@@ -34,6 +34,7 @@ import {BgTimer} from "../utils/timers"
 import devServerBridge from "./DevServerBridge"
 import {islandNotifications} from "./NotificationsEmitter"
 import {isGlassesConnected} from "./GlassesReadiness"
+import {toMiniappConnectionData} from "./GlassesStatusProjection"
 import audioPlaybackService from "./AudioPlaybackService"
 import {phoneLocationService} from "./PhoneLocationService"
 import {useGlassesStore} from "../stores/glasses"
@@ -67,7 +68,7 @@ import {
 } from "../runtime/config"
 import {getAnalytics, getUiSeams} from "../runtime/bootstrap"
 import {invokeScanQrSeam} from "../runtime/scanQrSeam"
-import {normalizeStreamAudioConfig, normalizeStreamVideoConfig} from "../runtime/streamConfig"
+import {normalizeStreamAudioConfig, normalizeStreamVideoConfig, resolveCaptureAudio} from "../runtime/streamConfig"
 import {toLanguageHint} from "@mentra/cloud-protocol/languages"
 import type {AudioSubscription, LanguageSource, TranscriptionData, TranslationData} from "@mentra/cloud-protocol"
 import {buildMiniappManifestSnapshot, type MiniappRuntimeDiagnosticSnapshot} from "../utils/miniappDiagnostics"
@@ -80,6 +81,7 @@ import {resolveForegroundLocationPermission} from "./ForegroundLocationPermissio
 import {advanceMiniappPingLiveness} from "./MiniappLiveness"
 import {listPhoneCalendarEvents, PhoneCalendarError} from "./PhoneCalendarService"
 import {LocalMiniappStorage} from "./LocalMiniappStorage"
+import acsMeetingService, {parseAcsOutgoingVideo, resolveAcsAudioSource} from "./AcsMeetingService"
 
 // =============================================================================
 // Types
@@ -758,6 +760,22 @@ class LocalMiniappRuntime {
       this.replaceStreamSubscribers(packageName, existing.subscriptions, [])
       this.recomputeMicRequirements()
       this.updateCloudSubscriptions()
+      // Managed streams and ACS meetings deliberately survive a respawn: the new
+      // incarnation re-adopts them on restore (Mentra Call does exactly this) so a
+      // WebView reload does not drop the wearer out of a live call. An unmanaged
+      // stream cannot be re-adopted — startUnmanaged rejects while any stream is
+      // active, even for the same owner — so release it or the respawned miniapp
+      // is stuck behind STREAM_ALREADY_ACTIVE until the process restarts.
+      const streamSnapshot = phoneStreamCoordinator.getDiagnosticSnapshot()
+      if (
+        streamSnapshot.active === true &&
+        streamSnapshot.kind === "unmanaged" &&
+        streamSnapshot.ownerPackageName === packageName
+      ) {
+        void phoneStreamCoordinator.stop(packageName).catch((error) => {
+          console.warn(`${LOG_TAG}: failed to stop unmanaged stream while replacing ${packageName}`, error)
+        })
+      }
     }
     this.connectedApps.set(packageName, {
       subscriptions: new Set(),
@@ -953,6 +971,9 @@ class LocalMiniappRuntime {
     void phoneVideoCoordinator.stopForApp(packageName).catch((error) => {
       console.warn(`${LOG_TAG}: failed to stop video recording for ${packageName} on unregister`, error)
     })
+    void acsMeetingService.leaveIfOwner(packageName).catch((error) => {
+      console.warn(`${LOG_TAG}: failed to leave ACS meeting for ${packageName} on unregister`, error)
+    })
 
     // Detach the per-app nav event forwarder but leave the native nav session
     // running. The user may have just closed the mini-app UI and will reopen
@@ -1307,6 +1328,21 @@ class LocalMiniappRuntime {
       case MiniappRequestType.MANAGED_STREAM_STOP:
         void this.handleManagedStreamStop(packageName, payload, requestId)
         break
+      case MiniappRequestType.MEETING_JOIN:
+        void this.handleMeetingJoin(packageName, payload, requestId)
+        break
+      case MiniappRequestType.MEETING_LEAVE:
+        void this.handleMeetingLeave(packageName, requestId)
+        break
+      case MiniappRequestType.MEETING_SET_MUTED:
+        void this.handleMeetingSetMuted(packageName, payload, requestId)
+        break
+      case MiniappRequestType.MEETING_UPDATE_VIDEO_SOURCE:
+        void this.handleMeetingUpdateVideoSource(packageName, payload, requestId)
+        break
+      case MiniappRequestType.MEETING_GET_STATE:
+        void this.handleMeetingGetState(packageName, requestId)
+        break
       case REQUEST_WIFI_SETUP_TYPE:
         void this.handleRequestWifiSetup(packageName, payload, requestId)
         break
@@ -1409,6 +1445,7 @@ class LocalMiniappRuntime {
         packageName,
         capabilities,
         permissions: declaredPermissions,
+        hostFeatures: {captureAudio: true},
         ...(initialAuth ? {auth: initialAuth} : {}),
       },
       requestId,
@@ -1797,7 +1834,10 @@ class LocalMiniappRuntime {
         this.sendToMiniapp(packageName, {
           type: MiniappResponseType.EVENT,
           streamType: "glasses_connection",
-          data: glassesState,
+          data: {
+            connected: glassesState.connected,
+            modelName: glassesState.deviceModel || undefined,
+          },
         })
       } else if (stream === "glasses_wifi") {
         // Snapshot the current glasses Wi-Fi state on subscribe (like battery).
@@ -1816,6 +1856,7 @@ class LocalMiniappRuntime {
           streamType: "glasses_wifi",
           data: {
             connected,
+            linkConnected: glassesState.connected === true,
             ssid: connected ? wifi?.ssid : undefined,
             localIp: connected ? wifi?.localIp : undefined,
             timestamp: Date.now(),
@@ -3241,6 +3282,30 @@ class LocalMiniappRuntime {
   // Photo + streaming handlers (cloud-coordinated)
   // ===========================================================================
 
+  /**
+   * Manifest permission gate shared by the camera-and-mic RPCs (streams, meetings).
+   * Sends PERMISSION_NOT_DECLARED and returns false when the miniapp did not declare
+   * `permission`; the caller must return without doing the work.
+   */
+  private requireManifestPermission(
+    packageName: string,
+    requestId: string | undefined,
+    permission: "CAMERA" | "MICROPHONE",
+    purpose: string,
+    operation: MiniappRequestType,
+  ): boolean {
+    const app = this.connectedApps.get(packageName)
+    if (app?.installedManifest?.permissions?.some((p) => p.type === permission)) return true
+    logPermissionNotDeclared(packageName, permission, purpose, `{"type": "${permission}"}`)
+    this.sendResult(packageName, requestId, false, undefined, {
+      code: MiniappErrorCode.PERMISSION_NOT_DECLARED,
+      message: `${permission} permission not declared in miniapp.json. Add {"type": "${permission}"} to the "permissions" array.`,
+      permission,
+      operation,
+    })
+    return false
+  }
+
   private async handlePhoto(packageName: string, payload: Record<string, unknown>, requestId?: string): Promise<void> {
     // Manifest CAMERA permission gate.
     const app = this.connectedApps.get(packageName)
@@ -3399,6 +3464,10 @@ class LocalMiniappRuntime {
       })
       return
     }
+    // A stream is the glasses camera (and mic) leaving the device; gate it like a photo.
+    if (!this.requireManifestPermission(packageName, requestId, "CAMERA", "to stream the camera", MiniappRequestType.STREAM_START)) {
+      return
+    }
     try {
       const result = await streaming.startUnmanaged(packageName, {
         streamUrl: payload.streamUrl as string,
@@ -3406,6 +3475,7 @@ class LocalMiniappRuntime {
         audio: normalizeStreamAudioConfig(payload.audio),
         sound: payload.sound as boolean | undefined,
         authToken: typeof payload.authToken === "string" ? payload.authToken : undefined,
+        captureAudio: resolveCaptureAudio(payload.captureAudio, resolveAcsAudioSource().source),
       })
       this.sendResult(packageName, requestId, true, result)
     } catch (err) {
@@ -3455,6 +3525,17 @@ class LocalMiniappRuntime {
       })
       return
     }
+    if (
+      !this.requireManifestPermission(
+        packageName,
+        requestId,
+        "CAMERA",
+        "to stream the camera",
+        MiniappRequestType.MANAGED_STREAM_START,
+      )
+    ) {
+      return
+    }
     try {
       const result = await streaming.startManaged(packageName, {
         restreamDestinations: payload.restreamDestinations as Array<string | {url: string; name?: string}> | undefined,
@@ -3462,6 +3543,7 @@ class LocalMiniappRuntime {
         audio: normalizeStreamAudioConfig(payload.audio),
         sound: payload.sound as boolean | undefined,
         ingest: payload.ingest as "srt" | "whip" | undefined,
+        captureAudio: resolveCaptureAudio(payload.captureAudio, resolveAcsAudioSource().source),
       })
       this.sendResult(packageName, requestId, true, result)
     } catch (err) {
@@ -3482,6 +3564,133 @@ class LocalMiniappRuntime {
     return this.handleStreamStop(packageName, payload, requestId)
   }
 
+  private ensureMeetingStateBridge(): void {
+    acsMeetingService.setStateHandler((owner, state) => {
+      this.sendToMiniapp(owner, {
+        type: MiniappResponseType.MEETING_STATE,
+        ...state,
+      })
+    })
+  }
+
+  private async handleMeetingJoin(
+    packageName: string,
+    payload: Record<string, unknown>,
+    requestId?: string,
+  ): Promise<void> {
+    this.ensureMeetingStateBridge()
+    // A meeting puts the glasses camera and mic in front of remote strangers; it
+    // needs both declared, same as photo/stream and mic capture do individually.
+    if (
+      !this.requireManifestPermission(packageName, requestId, "CAMERA", "to join a meeting", MiniappRequestType.MEETING_JOIN) ||
+      !this.requireManifestPermission(packageName, requestId, "MICROPHONE", "to join a meeting", MiniappRequestType.MEETING_JOIN)
+    ) {
+      return
+    }
+    const meetingUrl = typeof payload.meetingUrl === "string" ? payload.meetingUrl : ""
+    const token = typeof payload.token === "string" ? payload.token : ""
+    const videoSource = payload.videoSource as {type?: string; url?: string} | undefined
+    const whepUrl = videoSource?.type === "whep" ? videoSource.url ?? "" : ""
+    const displayName = typeof payload.displayName === "string" ? payload.displayName : undefined
+    if (!meetingUrl || !token || !whepUrl) {
+      this.sendResult(packageName, requestId, false, undefined, {
+        code: MiniappErrorCode.INVALID_ARGUMENT,
+        message: "meetingUrl, token, and a WHEP videoSource are required",
+      })
+      return
+    }
+    try {
+      let video: ReturnType<typeof parseAcsOutgoingVideo>
+      try {
+        video = parseAcsOutgoingVideo(payload.video)
+      } catch (error) {
+        this.sendResult(packageName, requestId, false, undefined, {
+          code: MiniappErrorCode.INVALID_ARGUMENT,
+          message: error instanceof Error ? error.message : "Invalid meeting video",
+        })
+        return
+      }
+      const state = await acsMeetingService.join(packageName, {
+        meetingUrl,
+        token,
+        whepUrl,
+        displayName,
+        ...(video ? {video} : {}),
+      })
+      this.sendResult(packageName, requestId, true, state)
+    } catch (err) {
+      this.sendResult(packageName, requestId, false, undefined, {
+        code: MiniappErrorCode.INTERNAL,
+        message: err instanceof Error ? err.message : "ACS meeting join failed",
+      })
+    }
+  }
+
+  private async handleMeetingLeave(packageName: string, requestId?: string): Promise<void> {
+    try {
+      await acsMeetingService.leave(packageName)
+      this.sendResult(packageName, requestId, true)
+    } catch (err) {
+      this.sendResult(packageName, requestId, false, undefined, {
+        code: MiniappErrorCode.INTERNAL,
+        message: err instanceof Error ? err.message : "ACS meeting leave failed",
+      })
+    }
+  }
+
+  private async handleMeetingSetMuted(
+    packageName: string,
+    payload: Record<string, unknown>,
+    requestId?: string,
+  ): Promise<void> {
+    try {
+      const state = await acsMeetingService.setMuted(packageName, Boolean(payload.muted))
+      this.sendResult(packageName, requestId, true, state)
+    } catch (err) {
+      this.sendResult(packageName, requestId, false, undefined, {
+        code: MiniappErrorCode.INTERNAL,
+        message: err instanceof Error ? err.message : "ACS mute failed",
+      })
+    }
+  }
+
+  private async handleMeetingUpdateVideoSource(
+    packageName: string,
+    payload: Record<string, unknown>,
+    requestId?: string,
+  ): Promise<void> {
+    const videoSource = payload.videoSource as {type?: string; url?: string} | undefined
+    const whepUrl = videoSource?.type === "whep" ? videoSource.url ?? "" : ""
+    if (!whepUrl) {
+      this.sendResult(packageName, requestId, false, undefined, {
+        code: MiniappErrorCode.INVALID_ARGUMENT,
+        message: "videoSource must be a WHEP URL",
+      })
+      return
+    }
+    try {
+      await acsMeetingService.updateVideoSource(packageName, whepUrl)
+      this.sendResult(packageName, requestId, true)
+    } catch (err) {
+      this.sendResult(packageName, requestId, false, undefined, {
+        code: MiniappErrorCode.INTERNAL,
+        message: err instanceof Error ? err.message : "ACS video source update failed",
+      })
+    }
+  }
+
+  private async handleMeetingGetState(packageName: string, requestId?: string): Promise<void> {
+    try {
+      const state = await acsMeetingService.readState(packageName)
+      this.sendResult(packageName, requestId, true, state)
+    } catch (err) {
+      this.sendResult(packageName, requestId, false, undefined, {
+        code: MiniappErrorCode.INTERNAL,
+        message: err instanceof Error ? err.message : "ACS getState failed",
+      })
+    }
+  }
+
   /**
    * session.glasses.requestWifiSetup — open the phone's glasses Wi-Fi setup
    * flow. The host owns the actual UI via the `engine.configure({ui})` seam;
@@ -3904,6 +4113,9 @@ class LocalMiniappRuntime {
     // The bare `touch_event` stream above still catches `onTouch(handler)`.
     let perGestureStream: string | null = null
     let outboundData = data
+    if (normalizedStream === MiniappStreamType.GLASSES_CONNECTION) {
+      outboundData = toMiniappConnectionData(data) ?? data
+    }
     if (normalizedStream === MiniappStreamType.TOUCH_EVENT) {
       // The Bluetooth SDK delivers the gesture under `gestureName` (single_tap /
       // double_tap / triple_tap / long_press / swipe_up / swipe_down). Surface it

package/src/services/MentraJSRouter.ts

@@ -469,7 +469,13 @@ export class MentraJSRouter {
     //    dead and let the host surface a "tap to retry" banner.
     if (iface === "__error") {
       const payload = this.tryParseArgs(msg.argsJson)
-      this.logger.error(`[${packageName}] ${method}`, payload)
+      // ready_nack is a liveness probe, not a crash. Logging it at error
+      // painted WHIP-start queue delay as a Mentra-Call exception.
+      if (method === "ready_nack") {
+        this.logger.warn(`[${packageName}] ${method}`, payload)
+      } else {
+        this.logger.error(`[${packageName}] ${method}`, payload)
+      }
       if (this.crashController) {
         // Only treat "exception" + "unhandledRejection" + "uncaught" as
         // crash signals. `console.error` calls also flow through the

package/src/services/MiniappLauncher.ts

@@ -25,7 +25,7 @@
 
 import {File} from "expo-file-system"
 
-import {decideDevLaunchRoute} from "../utils/devMiniappLaunch"
+import {resolveDevBundleSource} from "../utils/devMiniappSnapshot"
 import {storage} from "../utils/storage/storage"
 import appRegistry, {getLocalAppRunningState, saveLocalAppRunningState} from "./AppRegistry"
 import devServerBridge from "./DevServerBridge"
@@ -96,67 +96,89 @@ class MiniappLauncher {
    * package. Handles both dev (HTTP off the running dev server) and released
    * (file:// from the installed snapshot). Reads disk/network/storage; does
    * NOT spawn. Returns null when the bundle can't be resolved (dev server
-   * unreachable, missing entry, no installed version).
+   * unreachable with no on-disk snapshot, missing entry, no installed version).
    */
   async resolveBundle(packageName: string, hints?: LaunchHints): Promise<ResolvedBundle | null> {
     const devUrl = hints?.devUrl ?? this.storedDevUrl(packageName)
 
-    // --- Dev: load directly off the local dev server over HTTP. ---
+    // --- Dev: live HTTP, then the last on-disk snapshot if the laptop is gone. ---
     if (devUrl) {
-      const route = await decideDevLaunchRoute(packageName, devUrl)
-      if (route.decision === "offline" || !route.manifest) return null
-      const manifest = route.manifest
-      const entry = manifest.entry as {background?: string; ui?: string} | undefined
-      if (!entry?.background) return null
-
-      // Use the host that actually answered — may differ from the stored IP
-      // after a laptop Wi-Fi change (mDNS / Metro failover inside decideDevLaunchRoute).
-      const base = route.resolvedUrl.replace(/\/$/, "")
-      // entry.* are bundle-root paths (dist/ stripped); the dev server serves
-      // files relative to cwd, so prepend dist/.
-      const bgUrl = `${base}/dist/${entry.background.replace(/^\.?\/+/, "")}`
-      const uiUri = entry.ui ? `${base}/dist/${entry.ui.replace(/^\.?\/+/, "")}` : null
-
-      const perms = manifest.permissions as Array<{type?: string} | string> | undefined
-      const declaredPermissions = (perms ?? [])
-        .map((p) => (typeof p === "string" ? p : p?.type))
-        .filter((t): t is string => typeof t === "string")
-      const installedManifest: InstalledMiniappManifest = {
-        packageName: typeof manifest.packageName === "string" ? manifest.packageName : packageName,
-        name: manifest.name,
-        version: typeof manifest.version === "string" ? manifest.version : undefined,
-        sdkVersion: typeof manifest.sdkVersion === "string" ? manifest.sdkVersion : undefined,
-        minHostVersion: typeof manifest.minHostVersion === "string" ? manifest.minHostVersion : undefined,
-        type: typeof manifest.type === "string" ? manifest.type : undefined,
-        entry: manifest.entry as InstalledMiniappManifest["entry"],
-        permissions: manifest.permissions as InstalledMiniappManifest["permissions"],
-        hardwareRequirements: manifest.hardwareRequirements as InstalledMiniappManifest["hardwareRequirements"],
-        actions: manifest.actions as InstalledMiniappManifest["actions"],
+      const source = await resolveDevBundleSource(packageName, devUrl)
+      if (source.kind === "live") {
+        const live = await this.resolveLiveHttp(packageName, source.resolvedUrl, source.manifest, hints)
+        if (live) return live
+        // Live probe succeeded but the entry fetch failed — still try disk.
       }
-
-      let bgSource: string
-      try {
-        const res = await fetch(bgUrl)
-        if (!res.ok) return null
-        bgSource = await res.text()
-      } catch {
-        return null
-      }
-
-      return {
-        bgSource,
-        uiUri,
-        uiBaseDir: uiUri ? uiUri.replace(/\/[^/]+$/, "/") : null,
-        declaredPermissions,
-        installedManifest,
-        devUrl: route.resolvedUrl,
-        devPort: this.resolveDevPort(hints?.devPort, packageName),
+      const snapshotVersion =
+        source.kind === "snapshot" ? source.version : appRegistry.getLatestDevSnapshotVersion(packageName)
+      if (snapshotVersion) {
+        const snapshot = await this.resolveInstalledBundle(packageName, snapshotVersion)
+        if (snapshot) return snapshot
       }
+      return null
     }
 
     // --- Released: resolve from the installed file:// snapshot. ---
     const version = hints?.version ?? (await appRegistry.getActiveVersion(packageName))
     if (!version) return null
+    return this.resolveInstalledBundle(packageName, version)
+  }
+
+  private async resolveLiveHttp(
+    packageName: string,
+    resolvedUrl: string,
+    manifest: {entry?: unknown; permissions?: unknown; [key: string]: unknown},
+    hints?: LaunchHints,
+  ): Promise<ResolvedBundle | null> {
+    const entry = manifest.entry as {background?: string; ui?: string} | undefined
+    if (!entry?.background) return null
+
+    // Use the host that actually answered — may differ from the stored IP
+    // after a laptop Wi-Fi change (mDNS / Metro failover inside decideDevLaunchRoute).
+    const base = resolvedUrl.replace(/\/$/, "")
+    // entry.* are bundle-root paths (dist/ stripped); the dev server serves
+    // files relative to cwd, so prepend dist/.
+    const bgUrl = `${base}/dist/${entry.background.replace(/^\.?\/+/, "")}`
+    const uiUri = entry.ui ? `${base}/dist/${entry.ui.replace(/^\.?\/+/, "")}` : null
+
+    const perms = manifest.permissions as Array<{type?: string} | string> | undefined
+    const declaredPermissions = (perms ?? [])
+      .map((p) => (typeof p === "string" ? p : p?.type))
+      .filter((t): t is string => typeof t === "string")
+    const installedManifest: InstalledMiniappManifest = {
+      packageName: typeof manifest.packageName === "string" ? manifest.packageName : packageName,
+      name: typeof manifest.name === "string" ? manifest.name : undefined,
+      version: typeof manifest.version === "string" ? manifest.version : undefined,
+      sdkVersion: typeof manifest.sdkVersion === "string" ? manifest.sdkVersion : undefined,
+      minHostVersion: typeof manifest.minHostVersion === "string" ? manifest.minHostVersion : undefined,
+      type: typeof manifest.type === "string" ? manifest.type : undefined,
+      entry: manifest.entry as InstalledMiniappManifest["entry"],
+      permissions: manifest.permissions as InstalledMiniappManifest["permissions"],
+      hardwareRequirements: manifest.hardwareRequirements as InstalledMiniappManifest["hardwareRequirements"],
+      actions: manifest.actions as InstalledMiniappManifest["actions"],
+    }
+
+    let bgSource: string
+    try {
+      const res = await fetch(bgUrl)
+      if (!res.ok) return null
+      bgSource = await res.text()
+    } catch {
+      return null
+    }
+
+    return {
+      bgSource,
+      uiUri,
+      uiBaseDir: uiUri ? uiUri.replace(/\/[^/]+$/, "/") : null,
+      declaredPermissions,
+      installedManifest,
+      devUrl: resolvedUrl,
+      devPort: this.resolveDevPort(hints?.devPort, packageName),
+    }
+  }
+
+  private async resolveInstalledBundle(packageName: string, version: string): Promise<ResolvedBundle | null> {
     const entryPaths = appRegistry.getMiniappEntryPaths(packageName, version)
     if (!entryPaths?.background) return null
 
@@ -203,6 +225,7 @@ class MiniappLauncher {
       uiBaseDir: entryPaths.ui ? entryPaths.ui.replace(/\/[^/]+$/, "/") : null,
       declaredPermissions,
       installedManifest,
+      // Snapshot fallback is file:// — do not wire the sidecar; the laptop is gone.
       devUrl: null,
       devPort: null,
     }

package/src/services/PhoneCameraFovCoordinator.ts

@@ -90,6 +90,40 @@ export class PhoneCameraFovCoordinator {
     })
   }
 
+  /**
+   * Re-assert the current override on the glasses.
+   *
+   * The on-connect device-settings push replays the persistent `camera_fov`,
+   * so glasses that connect mid-call come up at the user's saved value and
+   * silently drop a miniapp's override — a Mentra Call wearer loses the 102°
+   * bottom crop by connecting their glasses after joining.
+   *
+   * The effective lease is recomputed inside [enqueue], not captured at call
+   * time: a `setOverride` or `releaseForApp` already queued ahead of this must
+   * win, and it is this coordinator that has to be the authoritative last
+   * writer. Sends the complete override — `fov` *and* `roiPosition` — because
+   * the scalar alone leaves the ROI wherever the persistent setting put it.
+   *
+   * No-op in legacy mode: those commands restart the camera HAL, which is far
+   * too expensive to fire on every reconnect.
+   */
+  reapplyEffectiveOverride(): Promise<void> {
+    return this.enqueue(async () => {
+      if (this.legacyMode) return
+      const leaseId = this.effectiveLeaseId
+      if (!leaseId) return
+      const entry = [...this.overrides.values()].find((candidate) => candidate.leaseId === leaseId)
+      if (!entry) return
+      await BluetoothSdk.setCameraFovOverride({
+        leaseId,
+        fov: entry.fov,
+        roiPosition: entry.roiPosition,
+        ttlMs: CAMERA_FOV_OVERRIDE_TTL_MS,
+      })
+      this.scheduleRefresh()
+    })
+  }
+
   releaseForApp(packageName: string): Promise<void> {
     return this.enqueue(async () => {
       const removed = this.overrides.get(packageName)