@ai-matrx/meet 0.11.29 → 0.11.31

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog — `@ai-matrx/meet`
 
+## 0.11.31
+
+Automatic changed-only republish (docs/metadata drift since the last tag — see
+`git diff npm/meet/v0.11.30..npm/meet/v0.11.31 -- apps/shared/meet`).
+No source changes intended and no consumer action required.
+
+## 0.11.30
+
+Automatic changed-only republish (docs/metadata drift since the last tag — see
+`git diff npm/meet/v0.11.29..npm/meet/v0.11.30 -- apps/shared/meet`).
+No source changes intended and no consumer action required.
+
 ## 0.11.29
 
 Automatic changed-only republish (docs/metadata drift since the last tag — see

package/dist/core.cjs

@@ -47,6 +47,7 @@ __export(core_exports, {
   GUEST_RECORD_ACCESS_METADATA_KEY: () => GUEST_RECORD_ACCESS_METADATA_KEY,
   GUEST_RECORD_NOT_SHARED: () => GUEST_RECORD_NOT_SHARED,
   IDLE_MEDIA: () => IDLE_MEDIA,
+  IDLE_MEDIA_REGION: () => IDLE_MEDIA_REGION,
   IDLE_PHASES: () => IDLE_PHASES,
   IDLE_TRACK: () => IDLE_TRACK,
   JOIN_REFUSAL_REASONS: () => JOIN_REFUSAL_REASONS,
@@ -117,6 +118,7 @@ __export(core_exports, {
   captionSegment: () => captionSegment,
   captureHeldOf: () => captureHeldOf,
   changesPatch: () => changesPatch,
+  classifyDeviceFailure: () => classifyDeviceFailure,
   clockPosition: () => clockPosition,
   collabFromState: () => collabFromState,
   computeStage: () => computeStage,
@@ -128,6 +130,7 @@ __export(core_exports, {
   createDeviceManager: () => createDeviceManager,
   createInRoomClient: () => createInRoomClient,
   createLiveKitDriver: () => createLiveKitDriver,
+  createMediaSupervisor: () => createMediaSupervisor,
   createMeetAi: () => createMeetAi,
   createMeetApi: () => createMeetApi,
   createMeetRepository: () => createMeetRepository,
@@ -147,6 +150,12 @@ __export(core_exports, {
   createWebResumeStorage: () => createWebResumeStorage,
   createWebRoomTokenStorage: () => createWebRoomTokenStorage,
   defaultCaptionLanguage: () => defaultCaptionLanguage,
+  detectBrowser: () => detectBrowser,
+  detectOs: () => detectOs,
+  deviceChipLabel: () => deviceChipLabel,
+  deviceFixSteps: () => deviceFixSteps,
+  deviceNoticeCode: () => deviceNoticeCode,
+  deviceUnavailableReason: () => deviceUnavailableReason,
   displayNameFor: () => displayNameFor,
   fileDownloadPath: () => fileDownloadPath,
   focusFromRow: () => focusFromRow,
@@ -258,6 +267,7 @@ __export(core_exports, {
   untranslatedLines: () => untranslatedLines,
   userTopic: () => userTopic,
   wasRefused: () => wasRefused,
+  webMediaPlatform: () => webMediaPlatform,
   withItem: () => withItem,
   wrapUpStatus: () => wrapUpStatus
 });
@@ -2864,7 +2874,7 @@ function createMeetRepository(options) {
         guard("meet.meetingBySlug", () => db.rpc(RPCS.meetingBySlug, { p_slug: slug })),
         readLinkRun(slug)
       ]);
-      const record = withRunNoteTaker(projectMeeting(row));
+      const record = await withRunNoteTaker(projectMeeting(row));
       return linkRun === void 0 ? record : { ...record, linkRun };
     },
     async meeting(id) {
@@ -3612,13 +3622,19 @@ function recordingLabel(state) {
 }
 
 // src/core/attendance.ts
+var IDLE_MEDIA_REGION = {
+  permission: { microphone: "unknown", camera: "unknown" },
+  audioOutput: "ok",
+  notice: null,
+  offer: null
+};
 var IDLE_TRACK = { enabled: false, unavailable: null };
 var IDLE_MEDIA = {
   microphone: IDLE_TRACK,
   camera: IDLE_TRACK
 };
-function unavailableFrom(error) {
-  return { code: error.code, message: error.message, remedy: error.remedy };
+function unavailableFrom(error, reason) {
+  return reason === void 0 ? { code: error.code, message: error.message, remedy: error.remedy } : { code: error.code, message: error.message, remedy: error.remedy, reason };
 }
 var LISTEN_ONLY_NOTICE = "You're attending without a microphone \u2014 others can't hear you";
 function isListenOnly(media) {
@@ -3680,6 +3696,7 @@ var EMPTY = {
   wrapUp: null,
   noteTakerRefusal: null,
   media: IDLE_MEDIA,
+  mediaRegion: IDLE_MEDIA_REGION,
   failure: null,
   collab: EMPTY_COLLAB,
   breakoutRoomId: null
@@ -3897,7 +3914,7 @@ function createMeetStore(initial = {}) {
     },
     setLocalTrack(kind, next) {
       const current = state.media[kind];
-      if (current.enabled === next.enabled && current.unavailable?.code === next.unavailable?.code && current.unavailable?.message === next.unavailable?.message) {
+      if (current.enabled === next.enabled && current.unavailable?.code === next.unavailable?.code && current.unavailable?.reason === next.unavailable?.reason && current.unavailable?.message === next.unavailable?.message) {
         return;
       }
       commit({ ...state, media: { ...state.media, [kind]: next } });
@@ -4716,6 +4733,12 @@ function createLiveKitDriver(handlers, options = {}) {
       roster();
     }).on(RoomEvent.TrackSubscribed, roster).on(RoomEvent.TrackUnsubscribed, roster).on(RoomEvent.TrackMuted, roster).on(RoomEvent.TrackUnmuted, roster).on(RoomEvent.LocalTrackPublished, roster).on(RoomEvent.LocalTrackUnpublished, roster).on(RoomEvent.ParticipantNameChanged, roster).on(RoomEvent.ParticipantAttributesChanged, roster).on(RoomEvent.ParticipantMetadataChanged, roster).on(RoomEvent.RoomMetadataChanged, (metadata) => {
       handlers.roomMetadata?.(metadata ?? "");
+    }).on(RoomEvent.AudioPlaybackStatusChanged, (canPlay) => {
+      handlers.audioPlayback?.(canPlay);
+    }).on(RoomEvent.MediaDevicesChanged, () => {
+      handlers.devicesChanged?.();
+    }).on(RoomEvent.MediaDevicesError, (error, kind) => {
+      handlers.mediaDeviceError?.(error, kind === "audioinput" || kind === "videoinput" ? kind : null);
     }).on(RoomEvent.ActiveSpeakersChanged, (speakers) => {
       handlers.activeSpeakers(speakers.map((speaker) => speaker.identity));
     }).on(RoomEvent.ConnectionQualityChanged, (quality, participant) => {
@@ -4812,6 +4835,7 @@ function createLiveKitDriver(handlers, options = {}) {
       }
       projectRoster?.();
       handlers.roomMetadata?.(target.metadata ?? "");
+      handlers.audioPlayback?.(target.canPlaybackAudio);
     },
     async disconnect() {
       if (room === null) return;
@@ -4938,6 +4962,11 @@ function createLiveKitDriver(handlers, options = {}) {
       } catch (error) {
         throw normalizeDeviceError(error, "meet.switchDevice");
       }
+    },
+    async startAudio() {
+      const target = room;
+      if (target === null) return;
+      await target.startAudio();
     }
   };
 }
@@ -6033,6 +6062,342 @@ async function pushMeetingToGoogleCalendar(api, meetingId, target) {
   return await response.json();
 }
 
+// src/core/media-supervisor.ts
+function classifyDeviceFailure(error, permission) {
+  if (permission === "denied") return "denied";
+  switch (error.code) {
+    case "permission-denied":
+      if (/by system/i.test(error.message) || permission === "granted") return "blocked_os";
+      return "denied";
+    case "device-not-found":
+      return "none";
+    case "device-in-use":
+      return "busy";
+    case "insecure-context":
+      return "blocked_site";
+    default:
+      return "failed";
+  }
+}
+function deviceNoticeCode(kind, reason) {
+  if (reason === "denied" || reason === "blocked_site" || reason === "blocked_os") {
+    return kind === "microphone" ? "mic-blocked" : "camera-blocked";
+  }
+  return "device-lost";
+}
+function deviceUnavailableReason(track, permission) {
+  if (track.enabled) return null;
+  if (permission === "denied") return "denied";
+  const refused = track.unavailable;
+  if (refused === null) return null;
+  return refused.reason ?? classifyDeviceFailure({ code: refused.code, message: refused.message }, permission);
+}
+function deviceChipLabel(kind, reason) {
+  const what = kind === "microphone" ? "Mic" : "Camera";
+  switch (reason) {
+    case "denied":
+    case "blocked_site":
+    case "blocked_os":
+      return `${what} blocked`;
+    case "none":
+      return kind === "microphone" ? "No microphone found" : "No camera found";
+    case "busy":
+      return `${what} in use by another app`;
+    case "revoked":
+      return `${what} access was turned off`;
+    default:
+      return `${what} didn't start`;
+  }
+}
+function deviceFixSteps(kind, reason, where) {
+  const device = kind === "microphone" ? "Microphone" : "Camera";
+  const lower = device.toLowerCase();
+  switch (reason) {
+    case "denied":
+    case "revoked":
+    case "blocked_site":
+      switch (where.browser) {
+        case "firefox":
+          return [`Click the crossed-out ${lower} icon in the address bar`, "Clear the Blocked setting", "Press Try again and choose Allow"];
+        case "safari":
+          return where.os === "ios" ? [`Settings \u203A Apps \u203A Safari \u203A ${device}`, "Choose Allow", "Return here and press Try again"] : ["Safari \u203A Settings for This Website", `Set ${device} to Allow`, "Press Try again"];
+        default:
+          return ["Click the icon left of the web address", `Set ${device} to Allow`, "Press Try again"];
+      }
+    case "blocked_os": {
+      const app = where.browser === "chrome" ? "Google Chrome" : where.browser === "edge" ? "Microsoft Edge" : where.browser === "firefox" ? "Firefox" : "your browser";
+      if (where.os === "mac") return [`System Settings \u203A Privacy & Security \u203A ${device}`, `Turn on ${app}`, "Reopen the browser if asked, then Try again"];
+      if (where.os === "windows") return [`Settings \u203A Privacy & security \u203A ${device}`, `Turn on ${device} access for apps`, "Press Try again"];
+      return [`Allow ${lower} access for ${app} in your system settings`, "Press Try again"];
+    }
+    case "busy":
+      return [`Close other apps using the ${lower} (Zoom, Teams, another tab)`, "Press Try again"];
+    case "none":
+      return [`Connect a ${lower}`, "Press Try again"];
+    default:
+      return [`Pick another ${lower} in Settings`, "Press Try again"];
+  }
+}
+function detectBrowser(userAgent) {
+  if (/Edg\//.test(userAgent)) return "edge";
+  if (/Firefox\//.test(userAgent)) return "firefox";
+  if (/Chrome\/|Chromium\/|CriOS\//.test(userAgent)) return "chrome";
+  if (/Safari\//.test(userAgent)) return "safari";
+  return "other";
+}
+function detectOs(userAgent, maxTouchPoints = 0) {
+  if (/iPhone|iPad|iPod/.test(userAgent)) return "ios";
+  if (/Macintosh/.test(userAgent)) return maxTouchPoints > 1 ? "ios" : "mac";
+  if (/Android/.test(userAgent)) return "android";
+  if (/Windows/.test(userAgent)) return "windows";
+  if (/Linux|CrOS/.test(userAgent)) return "linux";
+  return "other";
+}
+function webMediaPlatform() {
+  const scope = globalThis;
+  const nav = scope.navigator;
+  if (nav === void 0) return null;
+  const ua = nav.userAgent ?? "";
+  const reading = (state) => state === "granted" || state === "denied" || state === "prompt" ? state : "unknown";
+  const query = async (kind) => {
+    try {
+      return await nav.permissions?.query({ name: kind }) ?? null;
+    } catch {
+      return null;
+    }
+  };
+  return {
+    browser: detectBrowser(ua),
+    os: detectOs(ua, nav.maxTouchPoints ?? 0),
+    async queryPermission(kind) {
+      return reading((await query(kind))?.state);
+    },
+    watchPermission(kind, onChange) {
+      let status = null;
+      let stopped = false;
+      void query(kind).then((found) => {
+        if (stopped || found === null) return;
+        status = found;
+        found.onchange = () => onChange(reading(found.state));
+      });
+      return () => {
+        stopped = true;
+        if (status !== null) status.onchange = null;
+      };
+    },
+    async listDevices() {
+      try {
+        return await nav.mediaDevices?.enumerateDevices() ?? [];
+      } catch {
+        return [];
+      }
+    },
+    onVisible(callback) {
+      const doc = scope.document;
+      if (doc === void 0) return () => void 0;
+      const handler = () => {
+        if (doc.visibilityState === "visible") callback();
+      };
+      doc.addEventListener("visibilitychange", handler);
+      return () => doc.removeEventListener("visibilitychange", handler);
+    }
+  };
+}
+var INPUT_KIND = { microphone: "audioinput", camera: "videoinput" };
+function isAlias(deviceId) {
+  return deviceId === "default" || deviceId === "communications" || deviceId === "";
+}
+function createMediaSupervisor(options) {
+  const { store, platform } = options;
+  let unsubscribers = [];
+  let started = false;
+  let noticeId = 0;
+  let known = null;
+  let inUse = { audioinput: null, videoinput: null };
+  function region() {
+    return store.snapshot().mediaRegion;
+  }
+  function setRegion(next) {
+    const current = region();
+    const merged = { ...current, ...next };
+    if (merged.audioOutput === current.audioOutput && merged.notice === current.notice && merged.offer === current.offer && merged.permission.microphone === current.permission.microphone && merged.permission.camera === current.permission.camera) {
+      return;
+    }
+    store.patch({ mediaRegion: merged });
+  }
+  function setPermission(kind, reading) {
+    const current = region().permission;
+    if (current[kind] === reading) return;
+    setRegion({ permission: { ...current, [kind]: reading } });
+    const track = store.snapshot().media[kind];
+    if (reading === "granted" && !track.enabled && track.unavailable?.reason === "denied") {
+      store.setLocalTrack(kind, {
+        enabled: false,
+        unavailable: { ...track.unavailable, reason: "failed", remedy: "Access is allowed now. Press Try again." }
+      });
+    }
+  }
+  async function snapshotDevices() {
+    const list = platform === null ? [] : await platform.listDevices();
+    const out = { audioinput: /* @__PURE__ */ new Map(), videoinput: /* @__PURE__ */ new Map() };
+    for (const device of list) {
+      if (device.kind === "audioinput" || device.kind === "videoinput") out[device.kind].set(device.deviceId, device.label);
+    }
+    return out;
+  }
+  function readInUse() {
+    const driver = options.driver();
+    if (driver === null) return;
+    const active = driver.activeDevices();
+    inUse = { audioinput: active.audioinput, videoinput: active.videoinput };
+  }
+  async function handleDevicesChanged() {
+    if (platform === null) return;
+    const before = known;
+    const now = await snapshotDevices();
+    known = now;
+    const driver = options.driver();
+    if (driver === null || before === null) {
+      readInUse();
+      return;
+    }
+    for (const kind of ["microphone", "camera"]) {
+      const deviceKind = INPUT_KIND[kind];
+      const previous = inUse[deviceKind];
+      const track = store.snapshot().media[kind];
+      const gone = previous !== null && !isAlias(previous) && before[deviceKind].has(previous) && !now[deviceKind].has(previous);
+      if (gone) {
+        const from = before[deviceKind].get(previous) ?? "";
+        const remaining = [...now[deviceKind].entries()].filter(([id]) => !isAlias(id));
+        if (remaining.length === 0) {
+          store.setLocalTrack(kind, {
+            enabled: false,
+            unavailable: {
+              code: "device-not-found",
+              message: `meet.${kind}: the ${kind} was disconnected and no other is connected`,
+              remedy: `Connect a ${kind === "microphone" ? "microphone" : "camera"}, then press Try again.`,
+              reason: "none"
+            }
+          });
+          setRegion({ notice: { id: ++noticeId, kind, outcome: "lost", from, to: null } });
+          continue;
+        }
+        if (kind === "camera") {
+          const [nextId, nextLabel] = remaining[0];
+          try {
+            await driver.switchDevice("videoinput", nextId);
+            if (track.enabled || track.unavailable !== null) {
+              await driver.setCameraEnabled(true);
+              store.setLocalTrack("camera", { enabled: true, unavailable: null });
+            }
+            setRegion({ notice: { id: ++noticeId, kind, outcome: "switched", from, to: nextLabel } });
+          } catch (error) {
+            const refused = await unavailable(error, "camera", "meet.camera(fallback)");
+            store.setLocalTrack("camera", { enabled: false, unavailable: refused });
+            setRegion({ notice: { id: ++noticeId, kind, outcome: "lost", from, to: null } });
+          }
+        } else {
+          const active = driver.activeDevices().audioinput;
+          const to = (active !== null ? now.audioinput.get(active) : void 0) ?? now.audioinput.get("default") ?? remaining[0][1];
+          setRegion({ notice: { id: ++noticeId, kind, outcome: "switched", from, to } });
+        }
+        continue;
+      }
+      const added = [...now[deviceKind].entries()].find(([id]) => !isAlias(id) && !before[deviceKind].has(id));
+      if (added !== void 0 && added[0] !== driver.activeDevices()[deviceKind]) {
+        setRegion({ offer: { kind, deviceId: added[0], label: added[1] } });
+      }
+    }
+    readInUse();
+  }
+  async function unavailable(error, kind, operation) {
+    const normalized = normalizeDeviceError(error, operation);
+    const permission = platform === null ? "unknown" : await platform.queryPermission(kind);
+    if (permission !== "unknown") setPermission(kind, permission);
+    return unavailableFrom(normalized, classifyDeviceFailure(normalized, permission));
+  }
+  return {
+    start() {
+      if (started || platform === null) return;
+      started = true;
+      for (const kind of ["microphone", "camera"]) {
+        void platform.queryPermission(kind).then((reading) => setPermission(kind, reading));
+        unsubscribers.push(platform.watchPermission(kind, (reading) => setPermission(kind, reading)));
+      }
+      unsubscribers.push(
+        platform.onVisible(() => {
+          const driver = options.driver();
+          if (driver?.startAudio === void 0 || region().audioOutput !== "blocked") return;
+          driver.startAudio().catch(() => void 0);
+        })
+      );
+    },
+    stop() {
+      for (const off of unsubscribers) off();
+      unsubscribers = [];
+      started = false;
+    },
+    unavailable,
+    onAudioPlayback(canPlay) {
+      setRegion({ audioOutput: canPlay ? "ok" : "blocked" });
+    },
+    onDevicesChanged() {
+      void handleDevicesChanged().catch((error) => {
+        options.report("warn", `meet: device change could not be handled: ${String(error)}`, "Pick the device in Settings.");
+      });
+    },
+    onDeviceError(error, deviceKind) {
+      if (deviceKind === null) return;
+      const kind = deviceKind === "audioinput" ? "microphone" : "camera";
+      void unavailable(error, kind, `meet.${kind}`).then((refused) => {
+        const track = store.snapshot().media[kind];
+        if (track.enabled) return;
+        store.setLocalTrack(kind, { enabled: false, unavailable: refused });
+      });
+    },
+    onConnected() {
+      void snapshotDevices().then((now) => {
+        known = now;
+        readInUse();
+      });
+    },
+    onDisconnected() {
+      known = null;
+      inUse = { audioinput: null, videoinput: null };
+      setRegion({ audioOutput: "ok", notice: null, offer: null });
+    },
+    async enableAudio() {
+      const driver = options.driver();
+      if (driver?.startAudio === void 0) return;
+      try {
+        await driver.startAudio();
+        setRegion({ audioOutput: "ok" });
+      } catch (error) {
+        options.report("warn", `meet: sound could not be enabled: ${String(error)}`, "Click Enable sound again, or check the tab is not muted.");
+      }
+    },
+    async acceptOffer() {
+      const offer = region().offer;
+      const driver = options.driver();
+      setRegion({ offer: null });
+      if (offer === null || driver === null) return;
+      try {
+        await driver.switchDevice(INPUT_KIND[offer.kind], offer.deviceId);
+        readInUse();
+      } catch (error) {
+        const refused = await unavailable(error, offer.kind, "meet.switchDevice");
+        options.report("warn", refused.message, refused.remedy);
+      }
+    },
+    dismissOffer() {
+      setRegion({ offer: null });
+    },
+    dismissNotice() {
+      setRegion({ notice: null });
+    }
+  };
+}
+
 // src/core/room.ts
 function SCREEN_SHARE_BLOCKED_REMEDY_FOR(remedy) {
   return /administrator|policy/i.test(remedy) ? remedy : SCREEN_SHARE_BLOCKED_REMEDY;
@@ -6112,9 +6477,9 @@ function createRoomEngine(options) {
   const departures = /* @__PURE__ */ new Map();
   function requestAsNow() {
     if (lastRequest === null) return null;
-    const media = store.snapshot().media;
+    const media2 = store.snapshot().media;
     if (store.snapshot().phase !== "in_call") return lastRequest;
-    return { ...lastRequest, mode: media.camera.enabled ? "video" : "audio", microphone: media.microphone.enabled };
+    return { ...lastRequest, mode: media2.camera.enabled ? "video" : "audio", microphone: media2.microphone.enabled };
   }
   async function dropRoom() {
     const target = driver;
@@ -6125,6 +6490,7 @@ function createRoomEngine(options) {
     }
     store.setLocalTrack("microphone", IDLE_TRACK);
     store.setLocalTrack("camera", IDLE_TRACK);
+    media.onDisconnected();
     store.patch({ share: NO_SHARE, connection: "stable" });
     clearGhosts();
     await target?.disconnect();
@@ -6190,7 +6556,22 @@ function createRoomEngine(options) {
     report("error", normalized.message, normalized.remedy);
     return normalized;
   }
+  const media = createMediaSupervisor({
+    store,
+    platform: options.mediaPlatform === void 0 ? webMediaPlatform() : options.mediaPlatform,
+    driver: () => driver,
+    report
+  });
   const handlers = {
+    audioPlayback(canPlay) {
+      media.onAudioPlayback(canPlay);
+    },
+    devicesChanged() {
+      media.onDevicesChanged();
+    },
+    mediaDeviceError(error, kind) {
+      media.onDeviceError(error, kind);
+    },
     participants(list) {
       const joinedAt = new Date(now()).toISOString();
       const before = new Set(store.snapshot().participants.map((p) => p.identity));
@@ -6456,6 +6837,7 @@ function createRoomEngine(options) {
     store.dispatch({ type: "connected" });
     store.setLocalTrack("microphone", IDLE_TRACK);
     store.setLocalTrack("camera", IDLE_TRACK);
+    media.start();
     const effects = options.effectsStorage?.load() ?? store.snapshot().effects;
     store.patch({ effects });
     if (!effects.noiseSuppression || effects.background !== "none") {
@@ -6480,6 +6862,7 @@ function createRoomEngine(options) {
     if (request.microphone !== false) {
       await enableTrack(created, "microphone", true);
     }
+    media.onConnected();
   }
   async function enableTrack(target, kind, enabled) {
     try {
@@ -6489,10 +6872,10 @@ function createRoomEngine(options) {
       store.setLocalTrack(kind, state);
       return state;
     } catch (error) {
-      const normalized = normalizeDeviceError(error, `meet.${kind}`);
-      const state = { enabled: false, unavailable: unavailableFrom(normalized) };
+      const refused = await media.unavailable(error, kind, `meet.${kind}`);
+      const state = { enabled: false, unavailable: refused };
       store.setLocalTrack(kind, state);
-      report("warn", normalized.message, normalized.remedy);
+      report("warn", refused.message, refused.remedy);
       return state;
     }
   }
@@ -6801,6 +7184,10 @@ function createRoomEngine(options) {
       if (driver === null) return;
       await driver.switchDevice(kind, deviceId);
     },
+    enableAudio: () => media.enableAudio(),
+    acceptDeviceOffer: () => media.acceptOffer(),
+    dismissDeviceOffer: () => media.dismissOffer(),
+    dismissDeviceNotice: () => media.dismissNotice(),
     pin(who) {
       store.patch({ pinned: who, layout: who === null ? "grid" : "speaker" });
     },
@@ -6815,6 +7202,7 @@ function createRoomEngine(options) {
     async dispose() {
       disposed = true;
       supervisor.dispose();
+      media.stop();
       clearGhosts();
       if (driver !== null) {
         const target = driver;
@@ -7799,22 +8187,10 @@ function observedRole(role, standing) {
   if (role === "host" || role === "cohost") return role;
   return isLinkFollower(standing) ? "guest" : "participant";
 }
-function observedDevice(track) {
+function observedDevice(track, permission = "unknown") {
   if (track.enabled) return "on";
-  const refused = track.unavailable;
-  if (refused === null) return "muted_by_me";
-  switch (refused.code) {
-    case "permission-denied":
-      return "unavailable:denied";
-    case "device-not-found":
-      return "unavailable:none";
-    case "device-in-use":
-      return "unavailable:busy";
-    case "insecure-context":
-      return "unavailable:blocked_site";
-    default:
-      return "unavailable:failed";
-  }
+  const reason = deviceUnavailableReason(track, permission);
+  return reason === null ? "muted_by_me" : `unavailable:${reason}`;
 }
 function endedRecord(snapshot, given) {
   const record = snapshot?.meeting ?? given;
@@ -7847,9 +8223,10 @@ function observe(input) {
     hostPresent: inCall && snapshot !== null ? snapshot.participants.some((p) => ADMITTER_ROLES.has(p.role)) : snapshot !== null && isWaitingPhase(snapshot.phase) ? snapshot.waiting?.admittersPresent ?? null : null,
     lobbyCount: canAdmit && snapshot !== null ? snapshot.lobby.filter((entry) => entry.state === "knocking").length : 0,
     recording: snapshot?.recording === "recording" || snapshot?.recording === "stopping",
-    audioBlocked: null,
-    camera: deviceInPlay && snapshot !== null ? observedDevice(snapshot.media.camera) : null,
-    microphone: deviceInPlay && snapshot !== null ? observedDevice(snapshot.media.microphone) : null
+    // S6c: the autoplay region is known only inside the room (no remote audio exists elsewhere).
+    audioBlocked: inCall && snapshot !== null ? snapshot.mediaRegion.audioOutput === "blocked" : null,
+    camera: deviceInPlay && snapshot !== null ? observedDevice(snapshot.media.camera, snapshot.mediaRegion.permission.camera) : null,
+    microphone: deviceInPlay && snapshot !== null ? observedDevice(snapshot.media.microphone, snapshot.mediaRegion.permission.microphone) : null
   };
 }
 function staticObservation(phase, reason = null) {
@@ -7914,9 +8291,9 @@ function participantAttributes(p) {
   if (quality !== null) attrs["data-meet-participant-connection"] = quality;
   return attrs;
 }
-function microphoneNoticeCode(track) {
-  const refused = track.unavailable;
-  if (refused === null) return null;
-  return refused.code === "permission-denied" || refused.code === "insecure-context" ? "mic-blocked" : "device-lost";
+function microphoneNoticeCode(track, permission = "unknown") {
+  const reason = deviceUnavailableReason(track, permission);
+  if (reason === null) return null;
+  return deviceNoticeCode("microphone", reason) === "mic-blocked" ? "mic-blocked" : "device-lost";
 }
 //# sourceMappingURL=core.cjs.map