@ai-matrx/meet 0.11.28 → 0.11.30

package/dist/core.cjs

@@ -36,6 +36,7 @@ __export(core_exports, {
   CAPTION_LANGUAGES: () => CAPTION_LANGUAGES,
   CONSENT_NOTICE_ATTRIBUTE: () => CONSENT_NOTICE_ATTRIBUTE,
   DATA_TOPICS: () => DATA_TOPICS,
+  DEFAULT_CONNECTION_POLICY: () => DEFAULT_CONNECTION_POLICY,
   DEFAULT_EFFECTS: () => DEFAULT_EFFECTS,
   DEFAULT_PAGE_SIZE: () => DEFAULT_PAGE_SIZE,
   EMPTY_COLLAB: () => EMPTY_COLLAB,
@@ -46,10 +47,12 @@ __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,
   LISTEN_ONLY_NOTICE: () => LISTEN_ONLY_NOTICE,
+  LIVEKIT_BASE_DELAYS_MS: () => LIVEKIT_BASE_DELAYS_MS,
   LIVE_PHASES: () => LIVE_PHASES,
   MEETING_INVITE_KIND: () => MEETING_INVITE_KIND,
   MEETING_INVITE_VERSION: () => MEETING_INVITE_VERSION,
@@ -73,6 +76,7 @@ __export(core_exports, {
   PARTICIPANT_STANDING_ATTRIBUTE: () => PARTICIPANT_STANDING_ATTRIBUTE,
   REACTION_TTL_MS: () => REACTION_TTL_MS,
   REFUSED_ABSENCE: () => REFUSED_ABSENCE,
+  RESUME_WINDOW_MS: () => RESUME_WINDOW_MS,
   ROLE_RANK: () => ROLE_RANK,
   ROOM_EVENTS: () => ROOM_EVENTS,
   ROOM_EVENT_PREFIX: () => ROOM_EVENT_PREFIX,
@@ -102,6 +106,7 @@ __export(core_exports, {
   attendanceTotals: () => attendanceTotals,
   attendeeKey: () => attendeeKey,
   autoAssign: () => autoAssign,
+  autoRejoinDelayMs: () => autoRejoinDelayMs,
   availableActivities: () => availableActivities,
   breakoutRemainingMs: () => breakoutRemainingMs,
   callInviteAction: () => callInviteAction,
@@ -113,15 +118,19 @@ __export(core_exports, {
   captionSegment: () => captionSegment,
   captureHeldOf: () => captureHeldOf,
   changesPatch: () => changesPatch,
+  classifyDeviceFailure: () => classifyDeviceFailure,
   clockPosition: () => clockPosition,
   collabFromState: () => collabFromState,
   computeStage: () => computeStage,
+  connectionPolicyFrom: () => connectionPolicyFrom,
   countLabel: () => countLabel,
   createCallCenter: () => createCallCenter,
   createCallInviteHandler: () => createCallInviteHandler,
+  createConnectionSupervisor: () => createConnectionSupervisor,
   createDeviceManager: () => createDeviceManager,
   createInRoomClient: () => createInRoomClient,
   createLiveKitDriver: () => createLiveKitDriver,
+  createMediaSupervisor: () => createMediaSupervisor,
   createMeetAi: () => createMeetAi,
   createMeetApi: () => createMeetApi,
   createMeetRepository: () => createMeetRepository,
@@ -130,13 +139,23 @@ __export(core_exports, {
   createMeetingRecordCache: () => createMeetingRecordCache,
   createMeetingSession: () => createMeetingSession,
   createMemoryDeviceStorage: () => createMemoryDeviceStorage,
+  createReachabilityProbe: () => createReachabilityProbe,
+  createReconnectPolicy: () => createReconnectPolicy,
   createRecordingController: () => createRecordingController,
   createRoomEngine: () => createRoomEngine,
   createTokenClient: () => createTokenClient,
   createWebDeviceStorage: () => createWebDeviceStorage,
   createWebEffectsStorage: () => createWebEffectsStorage,
+  createWebNetworkPort: () => createWebNetworkPort,
+  createWebResumeStorage: () => createWebResumeStorage,
   createWebRoomTokenStorage: () => createWebRoomTokenStorage,
   defaultCaptionLanguage: () => defaultCaptionLanguage,
+  detectBrowser: () => detectBrowser,
+  detectOs: () => detectOs,
+  deviceChipLabel: () => deviceChipLabel,
+  deviceFixSteps: () => deviceFixSteps,
+  deviceNoticeCode: () => deviceNoticeCode,
+  deviceUnavailableReason: () => deviceUnavailableReason,
   displayNameFor: () => displayNameFor,
   fileDownloadPath: () => fileDownloadPath,
   focusFromRow: () => focusFromRow,
@@ -147,6 +166,7 @@ __export(core_exports, {
   guestRecordAccessSetting: () => guestRecordAccessSetting,
   hasEnded: () => hasEnded,
   hostUserIds: () => hostUserIds,
+  httpUrlOf: () => httpUrlOf,
   invalidResponse: () => invalidResponse,
   isGuest: () => isGuest,
   isGuestIdentity: () => isGuestIdentity,
@@ -160,6 +180,7 @@ __export(core_exports, {
   isRealName: () => isRealName,
   isRefusedPhase: () => isRefusedPhase,
   isRoomEventTopic: () => isRoomEventTopic,
+  isUnannouncedDeparture: () => isUnannouncedDeparture,
   isWaitingPhase: () => isWaitingPhase,
   learnName: () => learnName,
   learnNames: () => learnNames,
@@ -181,6 +202,7 @@ __export(core_exports, {
   meetingTopic: () => meetingTopic,
   meetingWhen: () => meetingWhen,
   mergeCaption: () => mergeCaption,
+  mergeGhosts: () => mergeGhosts,
   mergeRecord: () => mergeRecord,
   microphoneNoticeCode: () => microphoneNoticeCode,
   moveToRoom: () => moveToRoom,
@@ -245,6 +267,7 @@ __export(core_exports, {
   untranslatedLines: () => untranslatedLines,
   userTopic: () => userTopic,
   wasRefused: () => wasRefused,
+  webMediaPlatform: () => webMediaPlatform,
   withItem: () => withItem,
   wrapUpStatus: () => wrapUpStatus
 });
@@ -456,6 +479,352 @@ function invalidResponse(operation, detail) {
   );
 }
 
+// src/core/connection-supervisor.ts
+var DEFAULT_CONNECTION_POLICY = {
+  bannerDelayMs: 2e3,
+  autoRejoin: true,
+  autoRejoinMaxAttempts: 5,
+  reconnectGraceSeconds: 30
+};
+function clampInt(value, min, max, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.min(max, Math.max(min, Math.round(value)));
+}
+function connectionPolicyFrom(raw) {
+  if (typeof raw !== "object" || raw === null) return DEFAULT_CONNECTION_POLICY;
+  const row = raw;
+  const d = DEFAULT_CONNECTION_POLICY;
+  return {
+    bannerDelayMs: clampInt(row["reconnect_banner_delay_ms"], 0, 1e4, d.bannerDelayMs),
+    autoRejoin: typeof row["auto_rejoin"] === "boolean" ? row["auto_rejoin"] : d.autoRejoin,
+    autoRejoinMaxAttempts: clampInt(row["auto_rejoin_max_attempts"], 0, 20, d.autoRejoinMaxAttempts),
+    reconnectGraceSeconds: clampInt(row["reconnect_grace_seconds"], 0, 600, d.reconnectGraceSeconds)
+  };
+}
+var LIVEKIT_BASE_DELAYS_MS = [0, 300, 1200, 2700, 4800, 7e3];
+function createReconnectPolicy(options = {}) {
+  const delays = options.delaysMs !== void 0 && options.delaysMs.length > 0 ? options.delaysMs : LIVEKIT_BASE_DELAYS_MS;
+  const giveUpMs = options.giveUpMs ?? 45e3;
+  const maxAttempts = options.maxAttempts ?? 12;
+  const random = options.random ?? Math.random;
+  return {
+    nextRetryDelayInMs({ retryCount, elapsedMs }) {
+      if (retryCount >= maxAttempts || elapsedMs >= giveUpMs) return null;
+      const base = delays[Math.min(retryCount, delays.length - 1)] ?? 0;
+      const spread = Math.min(2e3, Math.max(500, base / 2));
+      return Math.round(base + random() * spread);
+    }
+  };
+}
+function createWebNetworkPort() {
+  const scope = globalThis;
+  return {
+    online: () => scope.navigator?.onLine !== false,
+    subscribe(listener) {
+      if (typeof scope.addEventListener !== "function") return () => void 0;
+      const on = () => listener(true);
+      const off = () => listener(false);
+      scope.addEventListener("online", on);
+      scope.addEventListener("offline", off);
+      return () => {
+        scope.removeEventListener?.("online", on);
+        scope.removeEventListener?.("offline", off);
+      };
+    }
+  };
+}
+function createReachabilityProbe(urls, timeoutMs = 4e3) {
+  return async () => {
+    const targets = urls().filter((url) => url.length > 0);
+    if (targets.length === 0 || typeof fetch !== "function") return true;
+    const one = async (url) => {
+      const controller = typeof AbortController === "function" ? new AbortController() : null;
+      const timer = setTimeout(() => controller?.abort(), timeoutMs);
+      try {
+        await fetch(url, {
+          method: "GET",
+          mode: "no-cors",
+          cache: "no-store",
+          credentials: "omit",
+          ...controller !== null ? { signal: controller.signal } : {}
+        });
+        return true;
+      } catch {
+        return false;
+      } finally {
+        clearTimeout(timer);
+      }
+    };
+    const answers = await Promise.all(targets.map(one));
+    return answers.every(Boolean);
+  };
+}
+function httpUrlOf(serverUrl) {
+  return serverUrl.replace(/^ws(s?):\/\//i, "http$1://");
+}
+var RESUME_WINDOW_MS = 15 * 6e4;
+var RESUME_KEY = "mx-meet:resume:";
+function createWebResumeStorage() {
+  const storage = globalThis.sessionStorage;
+  if (storage === void 0) return void 0;
+  return {
+    load(roomName) {
+      try {
+        const raw = storage.getItem(RESUME_KEY + roomName);
+        if (raw === null) return null;
+        const parsed = JSON.parse(raw);
+        return typeof parsed?.at === "number" && typeof parsed.request?.roomName === "string" ? parsed : null;
+      } catch {
+        return null;
+      }
+    },
+    save(roomName, marker) {
+      try {
+        storage.setItem(RESUME_KEY + roomName, JSON.stringify(marker));
+      } catch {
+      }
+    },
+    clear(roomName) {
+      try {
+        storage.removeItem(RESUME_KEY + roomName);
+      } catch {
+      }
+    }
+  };
+}
+var CLEARS_RESUME = (phase) => phase === "left" || phase === "removed" || phase === "superseded" || phase === "inactive" || phase === "ended" || phase === "record" || phase === "prejoin" || phase.startsWith("refused:") || phase.startsWith("waiting:");
+function autoRejoinDelayMs(attempt, random = Math.random) {
+  const base = Math.min(15e3, 1e3 * 2 ** Math.max(0, attempt));
+  return Math.round(base * (0.5 + random()));
+}
+function createConnectionSupervisor(options) {
+  const { store, network } = options;
+  const now = options.now ?? (() => Date.now());
+  const random = options.random ?? Math.random;
+  const probeEveryMs = options.probeEveryMs ?? 3e3;
+  let driverRegion = null;
+  let probeTimer = null;
+  let probing = false;
+  let bannerTimer = null;
+  let rejoinTimer = null;
+  let rejoinAttempts = 0;
+  let lastPhase = store.snapshot().phase;
+  let lastSavedAt = 0;
+  let disposed = false;
+  const inCall = () => store.snapshot().phase === "in_call";
+  const dropped = () => store.snapshot().phase === "disconnected";
+  function setRegion(next) {
+    if (store.snapshot().connection !== next) store.patch({ connection: next });
+  }
+  function regionFor(reachable) {
+    if (!network.online()) return "offline";
+    if (reachable === false) return "server_unreachable";
+    if (dropped()) return reachable === true ? "stable" : store.snapshot().connection;
+    return driverRegion ?? "stable";
+  }
+  function needsWatch() {
+    const snap = store.snapshot();
+    if (dropped()) return true;
+    return inCall() && (driverRegion !== null || snap.connection !== "stable");
+  }
+  function stopProbe() {
+    if (probeTimer !== null) clearTimeout(probeTimer);
+    probeTimer = null;
+  }
+  function scheduleProbe(delayMs) {
+    if (disposed || probeTimer !== null) return;
+    probeTimer = setTimeout(() => {
+      probeTimer = null;
+      void runProbe();
+    }, delayMs);
+  }
+  async function runProbe() {
+    if (disposed || probing) return;
+    if (!needsWatch()) return;
+    if (!network.online()) {
+      setRegion("offline");
+      scheduleProbe(probeEveryMs);
+      return;
+    }
+    probing = true;
+    let reachable = false;
+    try {
+      reachable = await options.probe();
+    } catch {
+      reachable = false;
+    } finally {
+      probing = false;
+    }
+    if (disposed) return;
+    if (inCall() || dropped()) setRegion(regionFor(reachable));
+    if (dropped() && reachable) maybeRejoin();
+    if (needsWatch()) scheduleProbe(Math.round(probeEveryMs * (0.75 + random() * 0.5)));
+  }
+  function syncBanner() {
+    const snap = store.snapshot();
+    const unstable = snap.phase === "in_call" && snap.connection !== "stable";
+    if (!unstable) {
+      if (bannerTimer !== null) clearTimeout(bannerTimer);
+      bannerTimer = null;
+      if (snap.connectionBanner) store.patch({ connectionBanner: false });
+      return;
+    }
+    if (snap.connectionBanner || bannerTimer !== null) return;
+    const delay = options.policy().bannerDelayMs;
+    if (delay <= 0) {
+      store.patch({ connectionBanner: true });
+      return;
+    }
+    bannerTimer = setTimeout(() => {
+      bannerTimer = null;
+      const latest = store.snapshot();
+      if (latest.phase === "in_call" && latest.connection !== "stable" && !latest.connectionBanner) {
+        store.patch({ connectionBanner: true });
+      }
+    }, delay);
+  }
+  function stopRejoin() {
+    if (rejoinTimer !== null) clearTimeout(rejoinTimer);
+    rejoinTimer = null;
+  }
+  function maybeRejoin() {
+    if (disposed || rejoinTimer !== null || !dropped()) return;
+    const policy = options.policy();
+    if (!policy.autoRejoin) return;
+    if (rejoinAttempts >= policy.autoRejoinMaxAttempts) return;
+    if (!network.online()) return;
+    const attempt = rejoinAttempts;
+    rejoinTimer = setTimeout(() => {
+      rejoinTimer = null;
+      if (disposed || !dropped() || !network.online()) return;
+      rejoinAttempts = attempt + 1;
+      options.report?.("info", `meet: rejoining by itself (attempt ${rejoinAttempts} of ${policy.autoRejoinMaxAttempts})`);
+      void options.autoRejoin().catch(() => void 0);
+    }, autoRejoinDelayMs(attempt, random));
+  }
+  function saveMarker(force) {
+    const resume = options.resume;
+    const snap = store.snapshot();
+    if (resume === void 0 || snap.roomName === null) return;
+    const at = now();
+    if (!force && at - lastSavedAt < 1e4) return;
+    const request = options.currentRequest();
+    if (request === null) return;
+    lastSavedAt = at;
+    resume.save(snap.roomName, { request, at });
+  }
+  const unsubscribeStore = store.subscribe(() => {
+    if (disposed) return;
+    const snap = store.snapshot();
+    const phase = snap.phase;
+    const changed = phase !== lastPhase;
+    lastPhase = phase;
+    if (changed) {
+      if (phase === "in_call") {
+        rejoinAttempts = 0;
+        stopRejoin();
+        saveMarker(true);
+      } else if (phase === "disconnected") {
+        driverRegion = null;
+        saveMarker(true);
+        stopProbe();
+        scheduleProbe(0);
+      } else {
+        stopRejoin();
+        if (phase !== "joining") driverRegion = null;
+        if (CLEARS_RESUME(phase) && snap.roomName !== null) options.resume?.clear(snap.roomName);
+      }
+    } else if (phase === "in_call" || phase === "disconnected") {
+      saveMarker(false);
+    }
+    syncBanner();
+  });
+  const unsubscribeNetwork = network.subscribe((online) => {
+    if (disposed) return;
+    if (!online) {
+      if (inCall() || dropped()) setRegion("offline");
+      stopRejoin();
+      stopProbe();
+      if (needsWatch()) scheduleProbe(probeEveryMs);
+      return;
+    }
+    stopProbe();
+    if (needsWatch()) scheduleProbe(0);
+  });
+  return {
+    driverState(state) {
+      if (disposed) return;
+      if (state === "connected") {
+        driverRegion = null;
+        if (inCall() || store.snapshot().phase === "joining") setRegion(network.online() ? "stable" : "offline");
+        if (!needsWatch()) stopProbe();
+        return;
+      }
+      if (state === "reconnecting" || state === "signal_reconnecting") {
+        driverRegion = state;
+        if (inCall()) {
+          setRegion(network.online() ? state : "offline");
+          stopProbe();
+          scheduleProbe(0);
+        }
+      }
+    },
+    exitConnection() {
+      return network.online() ? "server_unreachable" : "offline";
+    },
+    resumable(roomName) {
+      const resume = options.resume;
+      if (resume === void 0) return null;
+      const marker = resume.load(roomName);
+      if (marker === null) return null;
+      if (now() - marker.at > RESUME_WINDOW_MS) {
+        resume.clear(roomName);
+        return null;
+      }
+      return marker;
+    },
+    dispose() {
+      disposed = true;
+      stopProbe();
+      stopRejoin();
+      if (bannerTimer !== null) clearTimeout(bannerTimer);
+      bannerTimer = null;
+      unsubscribeStore();
+      unsubscribeNetwork();
+    }
+  };
+}
+var DELIBERATE_DEPARTURES = /* @__PURE__ */ new Set([
+  "CLIENT_INITIATED",
+  "PARTICIPANT_REMOVED",
+  "ROOM_DELETED",
+  "ROOM_CLOSED",
+  "DUPLICATE_IDENTITY",
+  "USER_REJECTED",
+  "USER_UNAVAILABLE",
+  "SIP_TRUNK_FAILURE"
+]);
+function isUnannouncedDeparture(reason) {
+  return reason === null || !DELIBERATE_DEPARTURES.has(reason);
+}
+function mergeGhosts(live, ghosts, at) {
+  const present = new Set(live.map((p) => p.identity));
+  const kept = /* @__PURE__ */ new Map();
+  const extra = [];
+  for (const [identity, ghost] of ghosts) {
+    if (present.has(identity) || ghost.until <= at) continue;
+    kept.set(identity, ghost);
+    extra.push({
+      ...ghost.participant,
+      micEnabled: false,
+      cameraEnabled: false,
+      screenSharing: false,
+      reconnecting: true
+    });
+  }
+  return { roster: [...live, ...extra], kept };
+}
+
 // src/core/tokens.ts
 function createWebRoomTokenStorage(onDiagnostic) {
   const store = globalThis.localStorage;
@@ -641,7 +1010,8 @@ function parseRoomToken(body, roomName) {
     admissionState: readString(payload, "admission_state") ?? void 0,
     pollSeconds: typeof payload["poll_seconds"] === "number" ? payload["poll_seconds"] : void 0,
     breakoutRoomId: readString(payload, "breakout_room_id") ?? null,
-    observersVisibleTo: readString(payload, "observers_visible_to") === "hosts" ? "hosts" : "everyone"
+    observersVisibleTo: readString(payload, "observers_visible_to") === "hosts" ? "hosts" : "everyone",
+    connectionPolicy: connectionPolicyFrom(payload["connection_policy"])
   };
 }
 function createTokenClient(options) {
@@ -1371,6 +1741,10 @@ function nextPhase(from, event) {
       return from === "resolving" && event.reason !== null && isJoinRefusalReason(event.reason) ? refusalPhase(event.reason) : null;
     case "join":
       return JOINABLE_FROM.has(from) ? "joining" : null;
+    case "auto_rejoin":
+      return from === "disconnected" ? "joining" : null;
+    case "resumed":
+      return from === "resolving" ? "joining" : null;
     case "back_to_prejoin":
       return from === "left" || from === "disconnected" ? "prejoin" : null;
     case "retry":
@@ -3248,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) {
@@ -3284,6 +3664,7 @@ var EMPTY = {
   phaseNotice: null,
   roomName: null,
   connection: "stable",
+  connectionBanner: false,
   share: NO_SHARE,
   call: null,
   waiting: null,
@@ -3315,6 +3696,7 @@ var EMPTY = {
   wrapUp: null,
   noteTakerRefusal: null,
   media: IDLE_MEDIA,
+  mediaRegion: IDLE_MEDIA_REGION,
   failure: null,
   collab: EMPTY_COLLAB,
   breakoutRoomId: null
@@ -3532,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 } });
@@ -4238,8 +4620,11 @@ function mapConnectionState(state) {
     case "connecting":
       return "connecting";
     case "reconnecting":
-    case "signalReconnecting":
       return "reconnecting";
+    // Only the signal socket is down (S6b): its own region value, so the supervisor can tell a
+    // signal blip from a full media reconnect.
+    case "signalReconnecting":
+      return "signal_reconnecting";
     default:
       return "disconnected";
   }
@@ -4320,8 +4705,12 @@ function createLiveKitDriver(handlers, options = {}) {
       // R5: large meetings degrade gracefully instead of melting a laptop.
       adaptiveStream: true,
       dynacast: true,
+      // S6b: OUR retry schedule — jittered from attempt 0 (the SDK's default has no jitter on its
+      // first two attempts), give-up limits in one place (`connection-supervisor.ts`).
+      reconnectPolicy: createReconnectPolicy(),
       ...options.roomOptions
     });
+    const reasonName = (reason) => reason === void 0 || reason === null ? null : module2.DisconnectReason?.[reason] ?? String(reason);
     const roster = () => {
       const local = snapshotParticipant(created.localParticipant, true);
       const remotes = [...created.remoteParticipants.values()].map(
@@ -4339,8 +4728,17 @@ function createLiveKitDriver(handlers, options = {}) {
       if (track.kind !== Track.Kind.Audio) return;
       for (const element of track.detach()) element.remove();
     });
-    created.on(RoomEvent.ParticipantConnected, roster).on(RoomEvent.ParticipantDisconnected, 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) => {
+    created.on(RoomEvent.ParticipantConnected, roster).on(RoomEvent.ParticipantDisconnected, (participant, reason) => {
+      handlers.participantLeft?.(participant.identity, reasonName(reason));
+      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) => {
@@ -4356,8 +4754,7 @@ function createLiveKitDriver(handlers, options = {}) {
     }).on(RoomEvent.Disconnected, (reason) => {
       audioContainer?.remove();
       audioContainer = null;
-      const named = reason === void 0 ? null : module2?.DisconnectReason?.[reason] ?? String(reason);
-      handlers.disconnected(named);
+      handlers.disconnected(reasonName(reason));
     });
     try {
       created.registerTextStreamHandler(TRANSCRIPTION_TOPIC, (reader, participantInfo) => {
@@ -4438,6 +4835,7 @@ function createLiveKitDriver(handlers, options = {}) {
       }
       projectRoster?.();
       handlers.roomMetadata?.(target.metadata ?? "");
+      handlers.audioPlayback?.(target.canPlaybackAudio);
     },
     async disconnect() {
       if (room === null) return;
@@ -4564,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();
     }
   };
 }
@@ -5659,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;
@@ -5730,6 +6469,18 @@ function createRoomEngine(options) {
   let disposed = false;
   let moving = false;
   const confirmingEnds = /* @__PURE__ */ new WeakSet();
+  let lastServerUrl = null;
+  let connectionPolicy = DEFAULT_CONNECTION_POLICY;
+  let ghosts = /* @__PURE__ */ new Map();
+  let ghostTimer = null;
+  let liveRoster = [];
+  const departures = /* @__PURE__ */ new Map();
+  function requestAsNow() {
+    if (lastRequest === null) return null;
+    const media2 = store.snapshot().media;
+    if (store.snapshot().phase !== "in_call") return lastRequest;
+    return { ...lastRequest, mode: media2.camera.enabled ? "video" : "audio", microphone: media2.microphone.enabled };
+  }
   async function dropRoom() {
     const target = driver;
     driver = null;
@@ -5739,7 +6490,9 @@ 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();
   }
   async function leaveRoom() {
@@ -5803,11 +6556,26 @@ 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));
-      store.setParticipants(list.map((entry) => projectParticipant(entry, joinedAt)));
+      projectRoster(list, joinedAt);
       const snapshot = store.snapshot();
       const newcomer = snapshot.participants.some(
         (participant) => !participant.isLocal && !before.has(participant.identity)
@@ -5819,6 +6587,9 @@ function createRoomEngine(options) {
         );
       }
     },
+    participantLeft(who, reason) {
+      departures.set(who, reason);
+    },
     roomMetadata(metadata) {
       let spotlight = null;
       if (metadata.length > 0) {
@@ -5845,12 +6616,8 @@ function createRoomEngine(options) {
       store.setQuality(asParticipantIdentity(who), value);
     },
     connectionState(state) {
-      if (state === "connected") {
-        if (store.snapshot().connection !== "stable") store.patch({ connection: "stable" });
-        store.dispatch({ type: "connected" });
-      } else if (state === "reconnecting") {
-        store.patch({ connection: "reconnecting" });
-      }
+      supervisor.driverState(state);
+      if (state === "connected" && store.snapshot().phase === "joining") store.dispatch({ type: "connected" });
     },
     transcription(event) {
       const snapshot = store.snapshot();
@@ -5983,6 +6750,7 @@ function createRoomEngine(options) {
   };
   async function resolveExitAndApply(hint) {
     const connection = current?.identity ?? store.snapshot().localIdentity ?? null;
+    lastRequest = requestAsNow();
     await dropRoom();
     let server;
     if (options.readExit === void 0 || connection === null || store.snapshot().meeting === null) {
@@ -5996,7 +6764,7 @@ function createRoomEngine(options) {
     }
     if (disposed) return;
     const resolved = resolveExit({ server, hint, frozen: options.wasFrozen?.() ?? false });
-    store.patch({ connection: resolved.connection });
+    store.patch({ connection: server === null ? supervisor.exitConnection() : resolved.connection });
     if (resolved.to === "waiting:knocking") {
       store.patch({
         waiting: {
@@ -6028,6 +6796,8 @@ function createRoomEngine(options) {
       ...request.observe === true ? { observe: true } : {}
     });
     current = token;
+    lastServerUrl = token.serverUrl;
+    connectionPolicy = token.connectionPolicy ?? DEFAULT_CONNECTION_POLICY;
     store.patch({
       localIdentity: token.identity,
       breakoutRoomId: token.breakoutRoomId ?? null,
@@ -6067,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") {
@@ -6091,6 +6862,7 @@ function createRoomEngine(options) {
     if (request.microphone !== false) {
       await enableTrack(created, "microphone", true);
     }
+    media.onConnected();
   }
   async function enableTrack(target, kind, enabled) {
     try {
@@ -6100,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;
     }
   }
@@ -6132,7 +6904,59 @@ function createRoomEngine(options) {
       throw normalized;
     }
   }
-  return {
+  function projectRoster(list, joinedAt) {
+    const at = now();
+    const previous = new Map(liveRoster.map((p) => [p.identity, p]));
+    const present = new Set(list.map((p) => p.identity));
+    const graceMs = connectionPolicy.reconnectGraceSeconds * 1e3;
+    for (const [who, reason] of departures) {
+      const last = previous.get(who);
+      if (last !== void 0 && !last.isLocal && !present.has(who) && graceMs > 0 && isUnannouncedDeparture(reason)) {
+        ghosts.set(who, { participant: last, until: at + graceMs });
+      }
+    }
+    departures.clear();
+    liveRoster = list;
+    const merged = mergeGhosts(list, ghosts, at);
+    ghosts = merged.kept;
+    store.setParticipants(
+      merged.roster.map((entry) => {
+        const projected = projectParticipant(entry, joinedAt);
+        return entry.reconnecting === true ? { ...projected, reconnecting: true, quality: "lost" } : projected;
+      })
+    );
+    scheduleGhostExpiry();
+  }
+  function scheduleGhostExpiry() {
+    if (ghostTimer !== null) clearTimeout(ghostTimer);
+    ghostTimer = null;
+    if (ghosts.size === 0 || disposed) return;
+    const next = Math.min(...[...ghosts.values()].map((g) => g.until));
+    ghostTimer = setTimeout(() => {
+      ghostTimer = null;
+      if (disposed || driver === null) return;
+      projectRoster(liveRoster, new Date(now()).toISOString());
+    }, Math.max(0, next - now()) + 50);
+  }
+  function clearGhosts() {
+    ghosts = /* @__PURE__ */ new Map();
+    departures.clear();
+    liveRoster = [];
+    if (ghostTimer !== null) clearTimeout(ghostTimer);
+    ghostTimer = null;
+  }
+  const supervisor = createConnectionSupervisor({
+    store,
+    network: options.connection?.network ?? createWebNetworkPort(),
+    probe: () => options.connection?.probe?.(current?.serverUrl ?? lastServerUrl) ?? Promise.resolve(true),
+    policy: () => connectionPolicy,
+    autoRejoin: () => engine.autoRejoin(),
+    currentRequest: requestAsNow,
+    resume: options.connection?.resume,
+    now,
+    report: (level, message) => report(level, message)
+  });
+  const engine = {
     join(request) {
       if (joining !== null) return joining;
       if (store.snapshot().phase !== "joining" && !store.dispatch({ type: "join", click: true })) {
@@ -6177,6 +7001,35 @@ function createRoomEngine(options) {
       });
       return joining;
     },
+    async autoRejoin() {
+      const request = lastRequest;
+      if (request === null || joining !== null) return joining ?? void 0;
+      if (!store.dispatch({ type: "auto_rejoin" })) return;
+      tokens.invalidate(request.roomName);
+      current = null;
+      joining = connect(request).catch((error) => {
+        throw failJoin(error, "meet.autoRejoin");
+      }).finally(() => {
+        joining = null;
+      });
+      return joining;
+    },
+    resume(roomName) {
+      const marker = supervisor.resumable(roomName);
+      if (marker === null || joining !== null) return false;
+      if (!store.dispatch({ type: "resumed" })) return false;
+      lastRequest = { ...marker.request, roomName };
+      report("info", "meet: this tab was in the call before the page reloaded \u2014 rejoining");
+      tokens.invalidate(roomName);
+      current = null;
+      joining = connect(lastRequest).catch((error) => {
+        throw failJoin(error, "meet.resume");
+      }).finally(() => {
+        joining = null;
+      });
+      joining.catch(() => void 0);
+      return true;
+    },
     async moveToBreakout(roomId) {
       const request = lastRequest;
       if (request === null || driver === null) {
@@ -6331,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" });
     },
@@ -6344,6 +7201,9 @@ function createRoomEngine(options) {
     token: () => current,
     async dispose() {
       disposed = true;
+      supervisor.dispose();
+      media.stop();
+      clearGhosts();
       if (driver !== null) {
         const target = driver;
         driver = null;
@@ -6352,6 +7212,7 @@ function createRoomEngine(options) {
       store.reset();
     }
   };
+  return engine;
 }
 function canModerate(participant) {
   return participant !== void 0 && isHostRole(participant.role);
@@ -7326,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;
@@ -7374,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) {
@@ -7437,13 +8287,13 @@ function participantAttributes(p) {
     "data-meet-participant-role": observedRole(p.role, p.standing),
     "data-meet-participant-self": String(p.isLocal)
   };
-  const quality = observedQuality(p.quality);
+  const quality = p.reconnecting === true ? "reconnecting" : observedQuality(p.quality);
   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