@q9labsai/chalk-client 5.2.6 → 5.3.1

package/dist/{chunk-I7Y4HR2P.js → chunk-2CEMOTZF.js}

@@ -1,3 +1,7 @@
+import {
+  AccessGrantError,
+  requireParsedAccessGrant
+} from "./chunk-MHJ4UPM3.js";
 import {
   CloudflareSFUClient,
   CloudflareSFUError,
@@ -6,11 +10,7 @@ import {
   describeMediaCaptureError,
   grantedMediaFromStream,
   markMediaFailure
-} from "./chunk-YIDKETOX.js";
-import {
-  AccessGrantError,
-  requireParsedAccessGrant
-} from "./chunk-CJVLTSIO.js";
+} from "./chunk-O5JB5XVX.js";
 import {
   ChatAttachmentMimeTypeSchema,
   ChatReactionSetFrameSchema,
@@ -24,7 +24,10 @@ import {
   formatSyncConnectDiagnostic,
   scheduleSyncDialDeadline,
   syncConnectFailureCode
-} from "./chunk-5YPQNMJE.js";
+} from "./chunk-FD7ZSDTM.js";
+import {
+  withRequestContext
+} from "./chunk-N4IPKRS6.js";
 
 // src/access/manager.ts
 import { Clock, Context, Data, Deferred, Effect, Layer, SynchronizedRef } from "effect";
@@ -56,31 +59,31 @@ var makeConnectionAccessLayer = (provider, refreshWindowMs = DEFAULT_REFRESH_WIN
       });
     });
     const automaticMediaReplacementListeners = /* @__PURE__ */ new Set();
-    const fetch2 = (reason, replaceMediaConnection, force) => SynchronizedRef.modifyEffect(state, (current) => fetchAccessGrant(provider, { current, reason, replaceMediaConnection, force, refreshWindowMs, replacementGate })).pipe(
+    const fetch = (reason, replaceMediaConnection, force) => SynchronizedRef.modifyEffect(state, (current) => fetchAccessGrant(provider, { current, reason, replaceMediaConnection, force, refreshWindowMs, replacementGate })).pipe(
       Effect.catchTag(
         "MediaReplacementPending",
         ({ done }) => Deferred.await(done).pipe(
-          Effect.flatMap(() => fetch2(reason, replaceMediaConnection, force)),
+          Effect.flatMap(() => fetch(reason, replaceMediaConnection, force)),
           Effect.map((access) => ({ access, automaticMediaReplacement: false }))
         )
       ),
       Effect.tap((result) => Effect.sync(() => notifyAutomaticMediaReplacement(automaticMediaReplacementListeners, result))),
       Effect.map((result) => result.access)
     );
-    const initialize = (reason = "join") => fetch2(reason, false, false).pipe(Effect.catchTag("ConnectionAccessFailure", (failure2) => failure2.code === "access.invalid" && SynchronizedRef.getUnsafe(state).access === null ? fetch2(reason, false, true) : Effect.fail(failure2)));
+    const initialize = (reason = "join") => fetch(reason, false, false).pipe(Effect.catchTag("ConnectionAccessFailure", (failure2) => failure2.code === "access.invalid" && SynchronizedRef.getUnsafe(state).access === null ? fetch(reason, false, true) : Effect.fail(failure2)));
     const millisecondsUntilRefresh = Effect.gen(function* () {
       const access = yield* SynchronizedRef.get(state);
       if (!access.access) return null;
       return millisecondsUntil(access.access, yield* Clock.currentTimeMillis, refreshWindowMs);
     });
-    const ensureFresh = (reason = "scheduled_refresh") => fetch2(reason, false, false);
+    const ensureFresh = (reason = "scheduled_refresh") => fetch(reason, false, false);
     return {
       current: SynchronizedRef.get(state).pipe(Effect.map((value) => value.access)),
       currentUnsafe: () => SynchronizedRef.getUnsafe(state).access,
       initialize,
       ensureFresh,
-      refresh: (reason, replaceMediaConnection) => fetch2(reason, replaceMediaConnection, true),
-      refreshAfterRejection: () => fetch2("access_retry", true, true),
+      refresh: (reason, replaceMediaConnection) => fetch(reason, replaceMediaConnection, true),
+      refreshAfterRejection: () => fetch("access_retry", true, true),
       getSyncToken: (reason = "sync_recovery") => ensureFresh(reason).pipe(Effect.map((access) => access.sync.token)),
       getMediaToken: () => ensureFresh("scheduled_refresh").pipe(Effect.map((access) => access.media.token)),
       subscribeAutomaticMediaReplacement: (listener) => Effect.sync(() => {
@@ -291,8 +294,9 @@ function invalidUpload(message) {
   throw chatFileError("initiate_upload", "invalid_payload", false, message);
 }
 function createChatFileRequest(options) {
-  const fetchImplementation = options.fetch ?? globalThis.fetch;
-  const baseUrl = options.baseUrl.replace(/\/+$/u, "");
+  const fetchImplementation = withRequestContext(options.fetch);
+  let baseUrl = options.baseUrl;
+  while (baseUrl.endsWith("/")) baseUrl = baseUrl.slice(0, -1);
   return async function request(operation, path, init, accepts) {
     const headers = new Headers(init.headers);
     try {
@@ -786,7 +790,7 @@ var ChalkWhiteboardViewBounds = {
 
 // src/whiteboard/file-download-transport.ts
 function createChalkWhiteboardV1FileDownloadTransport(options) {
-  const fetchImplementation = options.fetch ?? globalThis.fetch;
+  const fetchImplementation = withRequestContext(options.fetch);
   let baseUrlEnd = options.baseUrl.length;
   while (baseUrlEnd > 0 && options.baseUrl[baseUrlEnd - 1] === "/") baseUrlEnd -= 1;
   const baseUrl = options.baseUrl.slice(0, baseUrlEnd);
@@ -2565,6 +2569,7 @@ function screenShareCapture(track) {
 }
 
 // src/connection/production.ts
+var apiFetch = withRequestContext();
 function createDefaultConnectionDependencies(options) {
   return {
     clock: {
@@ -2585,7 +2590,7 @@ function createDefaultConnectionDependencies(options) {
           return () => globalThis.window?.removeEventListener("online", listener);
         },
         send: async (grant, report, signal, traceparent) => {
-          const response = await fetch(`${options.apiBaseURL.replace(/\/$/, "")}/v1/tenants/${encodeURIComponent(grant.subject.tenantId)}/connection-reports`, {
+          const response = await apiFetch(`${options.apiBaseURL.replace(/\/$/, "")}/v1/tenants/${encodeURIComponent(grant.subject.tenantId)}/connection-reports`, {
             method: "POST",
             headers: { Authorization: `Bearer ${grant.media.token}`, "Content-Type": "application/json", traceparent },
             body: JSON.stringify(report),
@@ -2601,7 +2606,7 @@ function createDefaultConnectionDependencies(options) {
     getEpisodeStatus: async (access, signal) => {
       const { tenantId, spaceId, episodeId, participantId } = access.subject;
       const path = [tenantId, spaceId, episodeId, participantId].map(encodeURIComponent);
-      const response = await fetch(`${options.apiBaseURL.replace(/\/$/, "")}/v1/tenants/${path[0]}/spaces/${path[1]}/episodes/${path[2]}/participants/${path[3]}/episode-status`, {
+      const response = await apiFetch(`${options.apiBaseURL.replace(/\/$/, "")}/v1/tenants/${path[0]}/spaces/${path[1]}/episodes/${path[2]}/participants/${path[3]}/episode-status`, {
         headers: { Authorization: `Bearer ${access.media.token}` },
         signal,
         cache: "no-store",
@@ -2618,7 +2623,7 @@ function createDefaultConnectionDependencies(options) {
       let baseEnd = options.apiBaseURL.length;
       while (baseEnd > 0 && options.apiBaseURL[baseEnd - 1] === "/") baseEnd--;
       const baseURL = options.apiBaseURL.slice(0, baseEnd);
-      const response = await fetch(`${baseURL}/v1/tenants/${path[0]}/spaces/${path[1]}/episodes/${path[2]}/participants/${path[3]}/cancel-join`, {
+      const response = await apiFetch(`${baseURL}/v1/tenants/${path[0]}/spaces/${path[1]}/episodes/${path[2]}/participants/${path[3]}/cancel-join`, {
         method: "POST",
         headers: { Authorization: `Bearer ${access.media.token}` },
         signal
@@ -2853,7 +2858,7 @@ var ConnectionDiagnostics = class {
 // src/connection/lifecycle.ts
 var MEDIA_RECOVERY_TIMEOUT_MS = 6e4;
 var START_TIMEOUT_MS = 3e4;
-var LEAVE_TIMEOUT_MS = 5e3;
+var LEAVE_TIMEOUT_MS = 4e4;
 var RECOVERY_BUDGET_MS = MEDIA_RECOVERY_TIMEOUT_MS;
 var MAX_RECOVERY_ATTEMPTS = 3;
 var REFRESH_RETRY_MS = 5e3;
@@ -3291,6 +3296,12 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
         if (model.failure) return yield* Effect2.fail(lifecycleFailure("leave_unconfirmed", false, model.failure.message));
         return;
       }
+      yield* Effect2.sync(() => {
+        for (const { track } of model.media?.getSnapshot().localTracks ?? []) {
+          track.enabled = false;
+          track.stop();
+        }
+      });
       yield* transition("leaving");
       const confirmed = yield* leaveIsConfirmed();
       yield* stopPorts();
@@ -3771,9 +3782,14 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       yield* publish();
     });
     const handleMediaFailure = (media, cause, binding) => {
+      if (model.state === "leaving") return Effect2.void;
       if (media !== model.media || binding !== access.currentUnsafe()?.media.clientPayload.connectionId) return Effect2.void;
-      if (sfuAccessRejected(cause)) stopRejectedMedia();
-      if (sfuAccessRejected(cause) || cause instanceof CloudflareSFUError && cause.options.status === 410 || active(model) && connectionSuperseded(cause)) return failForSnapshot(failureFromCause(cause, "media_start_failed", "Media transport needs recovery"));
+      const failure2 = failureFromCause(cause, "media_start_failed", "Media transport needs recovery");
+      if (sfuAccessRejected(cause)) {
+        stopRejectedMedia();
+        return failForSnapshot(failure2);
+      }
+      if (cause instanceof CloudflareSFUError && cause.options.status === 410 || active(model) && connectionSuperseded(cause)) return failForSnapshot(failure2);
       return handleMediaSnapshot(media, media.getSnapshot());
     };
     const applyAutomaticMediaReplacement = (grant) => Effect2.gen(function* () {
@@ -4455,13 +4471,13 @@ var ChatControllerRuntime = class {
   #unsubscribeConnection = null;
   #unsubscribeEvents = null;
   #unsubscribeSnapshot = null;
-  constructor(connection, store, transport, apiBaseUrl, fetch2, fork, offline) {
+  constructor(connection, store, transport, apiBaseUrl, fetch, fork, offline) {
     this.#offline = offline;
     this.#apiBaseUrl = apiBaseUrl.replace(/\/+$/u, "");
     this.#connection = connection;
     this.#store = store;
     this.#transport = transport;
-    this.#fetch = fetch2;
+    this.#fetch = fetch;
     this.#fork = fork;
     this.#unsubscribeConnection = connection.subscribePorts((ports) => this.#bind(ports));
   }
@@ -4539,7 +4555,7 @@ var ChatControllerRuntime = class {
     });
   };
   upload = (file) => {
-    const fetch2 = this.#fetch;
+    const fetch = this.#fetch;
     return Effect4.suspend(() => {
       if (!this.#transport) {
         return Effect4.fail(new SpaceClientError({ code: "collaboration.unavailable", recoverable: false, message: "Chat file upload is unavailable" }));
@@ -4555,7 +4571,7 @@ var ChatControllerRuntime = class {
                     (upload) => Effect4.void.pipe(
                       Effect4.andThen(
                         Effect4.tryPromise({
-                          try: () => fetch2(upload.uploadUrl, { method: upload.method, headers: upload.headers, body: bytes }),
+                          try: () => fetch(upload.uploadUrl, { method: upload.method, headers: upload.headers, body: bytes }),
                           catch: () => new SpaceClientError({ code: "collaboration.unavailable", recoverable: true, message: CHAT_FILE_REACHABILITY_MESSAGE })
                         }).pipe(
                           Effect4.flatMap((response) => {
@@ -4877,6 +4893,20 @@ function chatError(message) {
   return new SpaceClientError({ code: "chat.payload_invalid", recoverable: false, message });
 }
 
+// src/space-client/same-identity.ts
+function otherDevices(participants, participantId, ownIdentityId) {
+  const identityId = ownIdentityId ?? participants.find((item) => item.participantId === participantId)?.identityId;
+  return identityId ? participants.filter((item) => item.participantId !== participantId && item.identityId === identityId) : [];
+}
+function otherDeviceHasMicrophone(snapshot, participants) {
+  if (snapshot.control?.status === "ended") return false;
+  const admitted = snapshot.control ? new Set(snapshot.control.participants.map((item) => item.participantId)) : null;
+  const devices = new Set(
+    otherDevices(participants, snapshot.participantId, snapshot.participantIdentityId).filter((item) => !admitted || admitted.has(item.participantId)).map((item) => item.participantId)
+  );
+  return snapshot.media?.items.some((item) => devices.has(item.participantId) && item.source === "microphone" && item.enabled) ?? false;
+}
+
 // src/space-client/media-controller.ts
 import { Clock as Clock3, Context as Context6, Deferred as Deferred3, Effect as Effect5, Exit as Exit2, Layer as Layer6, Semaphore } from "effect";
 
@@ -4949,8 +4979,35 @@ var MediaProjectionMonitor = class {
 // src/space-client/media-controller.ts
 var MEDIA_SOURCES = ["microphone", "camera", "screen"];
 var MEDIA_READY_TIMEOUT_MS = 1e4;
+var OFF_RETRY_INITIAL_MS = 1e3;
+var OFF_RETRY_MAX_MS = 3e4;
+function locallyOff(state) {
+  return !state.desired.enabled || !state.localEnabled;
+}
+function owesRemoteOff(state) {
+  return state.offDebt === "owed" && locallyOff(state);
+}
 function sourceWorker(enabled) {
-  return { desired: { enabled, revision: 0, controlRevision: -1, previousEnabled: enabled }, result: { revision: 0, status: "confirmed" }, initialRevision: 0, localEnabled: enabled, pause: null, serverSequence: -1, forcedRevision: null, pausedPublicationId: null, capturePause: "none" };
+  return {
+    desired: { enabled, revision: 0, controlRevision: -1, previousEnabled: enabled },
+    result: { revision: 0, status: "confirmed" },
+    initialRevision: 0,
+    localEnabled: enabled,
+    pause: null,
+    offDebt: "none",
+    offRetry: { timer: null, delayMs: OFF_RETRY_INITIAL_MS, running: false },
+    serverSequence: -1,
+    forcedRevision: null,
+    pausedPublicationId: null,
+    capturePause: "none",
+    awaitingLive: null
+  };
+}
+function rejectOffline(state, intent) {
+  if (intent.enabled) state.result = { revision: intent.revision, status: "failed", cause: new V1SyncError("Media enable requires a live call", "not_live"), cleanup: !intent.previousEnabled };
+}
+function ownProjection(snapshot, source) {
+  return snapshot.media?.items.find((item) => item.participantId === snapshot.participantId && item.source === source);
 }
 var MediaControllerService = class extends Context6.Service()("@chalk/client/MediaController") {
 };
@@ -5012,6 +5069,7 @@ var MediaControllerRuntime = class {
   #unsubscribePorts = null;
   #microphoneWatch = null;
   #projection;
+  #microphoneMutedByOtherDevice = false;
   constructor(connection, store, selection, gates, now, fork) {
     this.#connection = connection;
     this.#store = store;
@@ -5037,7 +5095,10 @@ var MediaControllerRuntime = class {
     if (intent.microphone !== void 0) this.#recordIntent("microphone", intent.microphone);
     if (intent.camera !== void 0) this.#recordIntent("camera", intent.camera);
   }
-  setMicrophoneEnabled = (enabled) => this.#set("microphone", enabled);
+  setMicrophoneEnabled = (enabled) => Effect5.sync(() => {
+    this.#microphoneMutedByOtherDevice = false;
+    this.#publish();
+  }).pipe(Effect5.andThen(this.#set("microphone", enabled)));
   setCameraEnabled = (enabled) => this.#set("camera", enabled);
   captureCameraPreview = () => this.#cameraSource("preview").pipe(Effect5.mapError(normalizeMediaError));
   setScreenShareEnabled = (enabled, options) => enabled ? this.#mediaAction(true, this.#startScreen(options)) : this.#stopScreen();
@@ -5133,6 +5194,8 @@ var MediaControllerRuntime = class {
   }
   dispose() {
     this.#disposed = true;
+    this.#cancelOffRetries();
+    for (const source of MEDIA_SOURCES) this.#sources[source].offDebt = "none";
     this.#projection.reset();
     for (const check of this.#readinessChecks) check(normalizeMediaError(this.#cancelledCaptureError()));
     this.#cancelCaptures();
@@ -5186,8 +5249,27 @@ var MediaControllerRuntime = class {
       }).pipe(Effect5.ensuring(Effect5.sync(() => cleanup())));
     });
   }
+  /** While a user enable waits for the call, its revision belongs to that wait; another source worker must not run it. */
+  #awaitLive(source, revision) {
+    const state = this.#sources[source];
+    return Effect5.suspend(() => {
+      state.awaitingLive = revision;
+      return this.#waitForLive(source, revision);
+    }).pipe(
+      Effect5.ensuring(
+        Effect5.sync(() => {
+          if (state.awaitingLive === revision) state.awaitingLive = null;
+        })
+      )
+    );
+  }
   #set(source, enabled) {
-    return Effect5.suspend(() => this.#store.getSnapshot().connection.status === "joining" ? this.#act(source, enabled) : this.#mediaAction(enabled, this.#act(source, enabled)));
+    return Effect5.suspend(() => this.#store.getSnapshot().connection.status === "joining" || this.#replacingMediaConnection() ? this.#act(source, enabled) : this.#mediaAction(enabled, this.#act(source, enabled)));
+  }
+  /** Sync is live and only the media connection is being replaced, e.g. while another source moves to a fresh SFU connection. */
+  #replacingMediaConnection() {
+    const { state, connection } = this.#connection.getSnapshot();
+    return (state === "live" || state === "reconnecting") && connection.sync === "healthy" && (connection.media === "connecting" || connection.media === "recovering");
   }
   #startScreen(options) {
     return this.#act("screen", true, options);
@@ -5234,7 +5316,9 @@ var MediaControllerRuntime = class {
     return Effect5.suspend(() => {
       if (this.#ports?.media.getSnapshot().connection.phase === "stopped") return Effect5.void;
       const desired = this.#recordIntent(source, enabled, options);
-      const ready = enabled && source !== "screen" && this.#store.getSnapshot().connection.status !== "live" ? this.#waitForLive(source, desired.revision).pipe(
+      if (!enabled) this.#sources[source].offDebt = "owed";
+      else this.#cancelOffRetry(source);
+      const ready = enabled && source !== "screen" && this.#store.getSnapshot().connection.status !== "live" ? this.#awaitLive(source, desired.revision).pipe(
         Effect5.tapError(
           (cause) => Effect5.sync(() => {
             if (this.#sources[source].desired.revision === desired.revision) {
@@ -5269,12 +5353,12 @@ var MediaControllerRuntime = class {
   #work(source) {
     return Effect5.gen({ self: this }, function* () {
       const state = this.#sources[source];
-      while (state.result.revision !== state.desired.revision || state.result.status === "failed" && state.result.cleanup) {
+      while (state.result.revision !== state.desired.revision || state.result.status === "failed" && state.result.cleanup || owesRemoteOff(state)) {
         const intent = state.desired;
         yield* this.#runRevision(source, intent);
         if (state.desired.revision === intent.revision) return;
       }
-    });
+    }).pipe(Effect5.ensuring(Effect5.sync(() => this.#scheduleOffRetry(source))));
   }
   #runRevision(source, intent) {
     return Effect5.gen({ self: this }, function* () {
@@ -5283,11 +5367,12 @@ var MediaControllerRuntime = class {
       state.pause = null;
       const paused = yield* Effect5.exit(pause ? foreign2(() => pause) : Effect5.void);
       if (state.desired.revision !== intent.revision) return;
+      if (state.awaitingLive === intent.revision) return yield* paused;
       const ports = this.#ports;
       const cleanup = source === "screen" && !intent.enabled ? yield* Effect5.exit(this.#stopScreenLocally(ports)) : Exit2.succeed(void 0);
       if (state.desired.revision !== intent.revision) return;
       if (ports && this.#syncLive) yield* this.#executeRevision(ports, source, intent);
-      else if (intent.enabled) state.result = { revision: intent.revision, status: "failed", cause: new V1SyncError("Media enable requires a live call", "not_live"), cleanup: !intent.previousEnabled };
+      else rejectOffline(state, intent);
       yield* paused;
       yield* cleanup;
     });
@@ -5295,16 +5380,13 @@ var MediaControllerRuntime = class {
   #executeRevision(ports, source, intent) {
     return Effect5.gen({ self: this }, function* () {
       const state = this.#sources[source];
-      if (state.result.revision === intent.revision && state.result.status === "failed") {
-        yield* this.#connection.runCommand((p) => this.#send(p, source, intent, false));
-        if (state.result.revision === intent.revision && state.result.status === "failed") state.result.cleanup = false;
-        return;
-      }
+      if (state.result.revision === intent.revision && (state.result.status === "failed" || owesRemoteOff(state))) return yield* this.#sendOwedOff(source, intent);
       const operation = source === "screen" ? this.#prepareScreen(ports, intent) : this.#prepareDevice(ports, source, intent);
       const result = yield* Effect5.exit(this.#connection.runCommand(() => operation));
       if (state.desired.revision !== intent.revision) return;
       if (Exit2.isSuccess(result)) {
         state.result = { revision: intent.revision, status: "confirmed" };
+        state.offDebt = intent.enabled ? "none" : "sent";
         state.localEnabled = state.forcedRevision === intent.revision ? false : intent.enabled;
       } else {
         const cause = yield* Effect5.flip(result);
@@ -5312,6 +5394,16 @@ var MediaControllerRuntime = class {
       }
     });
   }
+  #sendOwedOff(source, intent) {
+    return Effect5.gen({ self: this }, function* () {
+      const state = this.#sources[source];
+      yield* this.#connection.runCommand((p) => this.#send(p, source, intent, false));
+      state.offDebt = "sent";
+      if (state.result.revision !== intent.revision || state.result.status !== "failed") return;
+      if (intent.enabled) state.result.cleanup = false;
+      else state.result = { revision: intent.revision, status: "confirmed" };
+    });
+  }
   #failRevision(ports, source, intent, cause) {
     return Effect5.sync(() => {
       const state = this.#sources[source];
@@ -5462,19 +5554,36 @@ var MediaControllerRuntime = class {
     }
   }
   startInitial(media, stream) {
+    const waitForSync = Effect5.callback((resume) => {
+      const sync = this.#ports?.sync;
+      if (!sync) return resume(Effect5.void);
+      const check = () => {
+        if (sync.getSnapshot().connection.phase === "live" || media.getSnapshot().connection.phase === "stopped") resume(Effect5.void);
+      };
+      const unsubscribe = sync.subscribe(check);
+      const unsubscribeMedia = media.subscribe(check);
+      check();
+      return Effect5.sync(() => {
+        unsubscribe();
+        unsubscribeMedia();
+      });
+    });
     const publish = foreign2(async () => {
       const revisions = { microphone: this.#sources.microphone.initialRevision, camera: this.#sources.camera.initialRevision };
-      const tracks = stream.getTracks().filter((track) => {
-        const source = track.kind === "audio" ? "microphone" : "camera";
-        const enabled = this.#hasConsent(source);
-        track.enabled = enabled;
-        if (!enabled) {
-          this.#deleteTrack(source);
-          if (source === "microphone") track.stop();
-        }
-        return enabled;
-      });
-      await media.start(streamFromTracks(tracks));
+      const tracks = this.#consentedTracks(stream.getTracks());
+      await media.start(
+        streamFromTracks(tracks),
+        () => Effect5.runPromise(
+          waitForSync.pipe(
+            Effect5.map(() => {
+              const snapshot = this.#ports?.sync.getSnapshot();
+              this.#microphoneMutedByOtherDevice = Boolean(snapshot && this.#hasConsent("microphone") && otherDeviceHasMicrophone(snapshot, this.#store.getSnapshot().participants.roster));
+              if (this.#microphoneMutedByOtherDevice) this.#recordIntent("microphone", false);
+              return streamFromTracks(this.#consentedTracks(tracks));
+            })
+          )
+        )
+      );
       for (const source of ["microphone", "camera"]) {
         const state = this.#sources[source];
         if (state.desired.revision === revisions[source]) state.result = { revision: revisions[source], status: "confirmed" };
@@ -5482,6 +5591,18 @@ var MediaControllerRuntime = class {
     });
     return this.#serialize("microphone", this.#serialize("camera", publish));
   }
+  #consentedTracks(tracks) {
+    return tracks.filter((track) => {
+      const source = track.kind === "audio" ? "microphone" : "camera";
+      const enabled = this.#hasConsent(source);
+      track.enabled = enabled;
+      if (!enabled) {
+        this.#deleteTrack(source);
+        if (source === "microphone") track.stop();
+      }
+      return enabled;
+    });
+  }
   #send(ports, source, intent, enabled) {
     const command = this.#mediaAction(
       enabled,
@@ -5499,19 +5620,97 @@ var MediaControllerRuntime = class {
   }
   #reconcileIntents() {
     const live = this.#connection.getSnapshot().state === "live" && this.#ports?.sync.getSnapshot().connection.phase === "live";
-    if (this.#syncLive && !live) this.#rememberRecoveryIntents();
+    if (this.#syncLive && !live) {
+      this.#rememberRecoveryIntents();
+      this.#cancelOffRetries();
+    }
     const resumed = live && !this.#syncLive;
     this.#syncLive = live;
     if (!resumed) return;
-    if (this.#ports) this.#pauseRecoveredIntents(this.#ports, this.#ports.sync.getSnapshot());
+    if (this.#ports) {
+      const snapshot = this.#ports.sync.getSnapshot();
+      this.#pauseRecoveredIntents(this.#ports, snapshot);
+      this.#oweOffsSyncStillShows(snapshot);
+    }
     this.#resumePendingActions();
   }
   #resumePendingActions() {
+    for (const source of MEDIA_SOURCES) {
+      this.#sources[source].offRetry.delayMs = OFF_RETRY_INITIAL_MS;
+      if (source === "screen" && !owesRemoteOff(this.#sources[source])) this.#runWork(source);
+      else this.#resendOwedOff(source);
+    }
+  }
+  /** After a reconnect, Sync's snapshot decides: a source the device turned off but Sync still shows on, with the publication the device paused, is an off to resend. */
+  #oweOffsSyncStillShows(snapshot) {
     for (const source of MEDIA_SOURCES) {
       const state = this.#sources[source];
-      if (source !== "screen" && (state.desired.enabled || state.result.revision === state.desired.revision)) continue;
-      this.#fork(this.#serialize(source, this.#work(source)).pipe(Effect5.ignore));
+      if (state.offDebt !== "sent" || state.pausedPublicationId === null) continue;
+      if (ownProjection(snapshot, source)?.publicationId === state.pausedPublicationId) state.offDebt = "owed";
+    }
+  }
+  /** Sync needs no off from this device: it shows the source off, or on with a publication this device never paused (another device's). */
+  #syncNeedsNoOff(source) {
+    const snapshot = this.#ports?.sync.getSnapshot();
+    if (!snapshot?.media) return false;
+    const item = ownProjection(snapshot, source);
+    if (!item) return false;
+    return !item.enabled || this.#sources[source].pausedPublicationId !== null && item.publicationId !== this.#sources[source].pausedPublicationId;
+  }
+  /** The one place an owed off is resent after the user's own attempt. At most one is in flight per source, and none while a user action on the source is pending. */
+  #resendOwedOff(source) {
+    const state = this.#sources[source];
+    if (!this.#syncLive || this.#disposed || !owesRemoteOff(state) || state.offRetry.running || this.#pendingSources.has(source)) return;
+    this.#cancelOffRetry(source);
+    if (this.#syncNeedsNoOff(source)) {
+      state.offDebt = "none";
+      state.result = { revision: state.desired.revision, status: "confirmed" };
+      return;
+    }
+    this.#runWork(source);
+  }
+  /** A Sync snapshot repays an owed off now, unless an attempt for that source is already queued or running. */
+  #retryOffs() {
+    for (const source of MEDIA_SOURCES) this.#resendOwedOff(source);
+  }
+  #runWork(source) {
+    const retry = this.#sources[source].offRetry;
+    retry.running = true;
+    this.#fork(
+      this.#serialize(source, this.#work(source)).pipe(
+        Effect5.ignore,
+        Effect5.ensuring(
+          Effect5.sync(() => {
+            retry.running = false;
+          })
+        )
+      )
+    );
+  }
+  /** An off that Sync still has not shown is retried on a timer with doubling backoff, one timer per source, so a quiet healthy connection repairs itself. */
+  #scheduleOffRetry(source) {
+    const state = this.#sources[source];
+    const retry = state.offRetry;
+    if (!owesRemoteOff(state)) {
+      this.#cancelOffRetry(source);
+      retry.delayMs = OFF_RETRY_INITIAL_MS;
+      return;
     }
+    if (!this.#syncLive || this.#disposed || retry.timer !== null) return;
+    retry.timer = this.#connection.scheduleUnsafe(() => {
+      retry.timer = null;
+      this.#resendOwedOff(source);
+    }, retry.delayMs);
+    retry.delayMs = Math.min(retry.delayMs * 2, OFF_RETRY_MAX_MS);
+  }
+  #cancelOffRetry(source) {
+    const retry = this.#sources[source].offRetry;
+    if (retry.timer === null) return;
+    this.#connection.cancelScheduleUnsafe(retry.timer);
+    retry.timer = null;
+  }
+  #cancelOffRetries() {
+    for (const source of MEDIA_SOURCES) this.#cancelOffRetry(source);
   }
   #clearScreenAudio(media) {
     return foreign2(() => media.clearPreparedLocalTrack("screen_audio")).pipe(
@@ -5882,8 +6081,8 @@ var MediaControllerRuntime = class {
     this.#pauseTracks(source);
     if (cause === "capture_cleanup" && source !== "screen" && ports.media.pauseLocalCapture) {
       state.capturePause = "pending";
-      this.#retainPause(state, ports.media.pauseLocalCapture(source));
       this.#notifyCapturePauses(ports);
+      this.#retainPause(state, ports.media.pauseLocalCapture(source));
     } else {
       ports.media.setLocalSourceIntent?.(source, false, cause);
       this.#retainPause(state, this.#beginLocalPause(ports, source, cause));
@@ -5918,6 +6117,7 @@ var MediaControllerRuntime = class {
     this.#ports = ports;
     this.#projection.reset();
     this.#syncLive = false;
+    this.#cancelOffRetries();
     this.#bindCamera(ports);
     if (!ports) {
       this.#resetObservations();
@@ -5964,6 +6164,7 @@ var MediaControllerRuntime = class {
       this.#removeRequestsFromMissingParticipants(snapshot);
       this.#applyRemoteMediaState(ports, snapshot);
       this.#reconcileIntents();
+      this.#retryOffs();
       this.#notifyCapturePauses(ports);
       this.#publish();
     });
@@ -6101,6 +6302,7 @@ var MediaControllerRuntime = class {
     const remote = Object.freeze((snapshot?.remoteTracks ?? []).map((track) => Object.freeze({ participantId: track.participantId, source: track.source, publicationId: track.publicationId, track: track.track })));
     const media = Object.freeze({
       ...current.media,
+      microphoneMutedByOtherDevice: this.#microphoneMutedByOtherDevice,
       local,
       remote,
       screenShare: {
@@ -6491,6 +6693,12 @@ var ParticipantsControllerRuntime = class {
   #unsubscribePorts = null;
   #unsubscribe = null;
   #unsubscribeMedia = null;
+  #deviceScope = null;
+  // Retain verified seats while the local Sync replica is recovering, and for older servers
+  // whose negotiated hints disappear with sockets. New servers send every admitted seat.
+  #devices = /* @__PURE__ */ new Map();
+  #presenceCursor = null;
+  #invalidatedDevices = /* @__PURE__ */ new Set();
   constructor(connection, store, offline) {
     this.#offline = offline;
     this.#connection = connection;
@@ -6544,6 +6752,8 @@ var ParticipantsControllerRuntime = class {
     return ({ sync }) => foreign3(() => sync.setDisplayName(displayName));
   });
   dispose() {
+    this.#devices.clear();
+    this.#invalidatedDevices.clear();
     this.#unsubscribePorts?.();
     this.#unsubscribe?.();
     this.#unsubscribeMedia?.();
@@ -6563,6 +6773,10 @@ var ParticipantsControllerRuntime = class {
     this.#unsubscribe = null;
     this.#unsubscribeMedia = null;
     if (!ports) {
+      if (["idle", "leaving", "left", "failed"].includes(this.#connection.getSnapshot().state)) {
+        this.#devices.clear();
+        this.#invalidatedDevices.clear();
+      }
       this.#publish(null, {});
       return;
     }
@@ -6571,11 +6785,57 @@ var ParticipantsControllerRuntime = class {
     this.#unsubscribeMedia = ports.media.subscribe(publish);
     publish();
   }
+  #syncDeviceScope() {
+    const subject = this.#connection.getSnapshot().subject;
+    const scope = subject ? JSON.stringify([subject.tenantId, subject.spaceId, subject.episodeId, subject.participantId, subject.participantGeneration]) : null;
+    if (scope !== this.#deviceScope) {
+      this.#devices.clear();
+      this.#invalidatedDevices.clear();
+    }
+    this.#deviceScope = scope;
+  }
+  #rememberDevices(snapshot) {
+    this.#syncDeviceScope();
+    const control = snapshot?.control;
+    if (!control) return;
+    this.#pruneDevices(control, snapshot.presence);
+    const retained = /* @__PURE__ */ new Map();
+    if (control.status !== "ended") {
+      for (const participant of control.participants) {
+        const device = this.#deviceFor(participant, snapshot.presence?.items ?? []);
+        if (device) retained.set(participant.participantId, device);
+      }
+    }
+    this.#devices = retained;
+  }
+  #pruneDevices(control, presence) {
+    const cursor = presence ? JSON.stringify([presence.projectionId, presence.sequence]) : null;
+    if (cursor !== this.#presenceCursor) this.#invalidatedDevices.clear();
+    this.#presenceCursor = cursor;
+    for (const [id, device] of this.#devices) {
+      if (!control.participants.some((participant) => participant.participantId === id && participant.admissionRevision === device.admissionRevision)) this.#invalidatedDevices.add(id);
+    }
+  }
+  #deviceFor(participant, presence) {
+    const previous = this.#devices.get(participant.participantId);
+    const known = previous && previous.admissionRevision === participant.admissionRevision ? previous : {};
+    const hint = this.#hintFor(participant, presence) ?? {};
+    const identityId = hint.identityId ?? known.identityId;
+    return identityId ? { admissionRevision: participant.admissionRevision, identityId, deviceType: hint.deviceType ?? known.deviceType } : void 0;
+  }
+  #hintFor(participant, presence) {
+    return presence.find((item) => {
+      if (item.participantId !== participant.participantId) return false;
+      if (item.admissionRevision !== void 0) return item.admissionRevision === participant.admissionRevision;
+      return !this.#invalidatedDevices.has(participant.participantId);
+    });
+  }
   #publish(snapshot, collaborationCapabilities, media) {
+    this.#rememberDevices(snapshot);
     if (snapshot && !controlFor(snapshot)) return;
     const audioParticipants = new Set(media?.remoteTracks.filter((track) => track.source === "screen_audio" && track.track.readyState === "live").map((track) => track.participantId));
     if (snapshot?.participantId && media?.localTracks.some((track) => track.source === "screen_audio" && track.enabled && track.track.readyState === "live")) audioParticipants.add(snapshot.participantId);
-    const projected = participantsFor(snapshot, collaborationCapabilities);
+    const projected = participantsFor(snapshot, collaborationCapabilities, this.#devices);
     const participants = Object.freeze({
       ...projected,
       roster: Object.freeze(projected.roster.map((participant) => Object.freeze({ ...participant, media: Object.freeze({ ...participant.media, screenShareHasAudio: participant.media.screenShare === "active" && audioParticipants.has(participant.participantId) }) })))
@@ -6601,10 +6861,10 @@ function invalid(message) {
 function directed(result) {
   return Object.freeze({ status: result.result, requestId: result.request_id });
 }
-function participantsFor(snapshot, collaborationCapabilities) {
+function participantsFor(snapshot, collaborationCapabilities, devices) {
   const control = controlFor(snapshot);
-  if (!control) return EMPTY_PARTICIPANTS;
-  return Object.freeze({ roster: rosterFor(control.participants, collaborationCapabilities, mediaFor(snapshot), presenceFor(snapshot)), admissionQueue: admissionQueueFor(control.admissionRequests) });
+  if (!control || control.status === "ended") return EMPTY_PARTICIPANTS;
+  return Object.freeze({ roster: rosterFor(control.participants, collaborationCapabilities, mediaFor(snapshot), presenceFor(snapshot), devices), admissionQueue: admissionQueueFor(control.admissionRequests) });
 }
 function controlFor(snapshot) {
   if (!snapshot) return null;
@@ -6618,11 +6878,13 @@ function mediaFor(snapshot) {
 function presenceFor(snapshot) {
   return snapshot?.presence ?? null;
 }
-function rosterFor(participants, collaborationCapabilities, media, presence) {
+function rosterFor(participants, collaborationCapabilities, media, presence, devices) {
   return Object.freeze(
     participants.map(
       (participant) => Object.freeze({
         participantId: participant.participantId,
+        identityId: devices.get(participant.participantId)?.identityId,
+        deviceType: devices.get(participant.participantId)?.deviceType,
         displayName: participant.displayName,
         role: participant.role,
         eligibleRoles: Object.freeze([...participant.eligibleRoles]),
@@ -6644,13 +6906,20 @@ function admissionQueueFor(requests) {
 function selfFor(snapshot, roster) {
   const participantId = snapshot?.participantId ?? null;
   const participant = roster.find((candidate) => candidate.participantId === participantId);
-  if (!participant) return emptySelf(participantId);
+  const identityId = selfIdentityFor(snapshot, participant);
+  if (!participant) return emptySelf(participantId, identityId);
   const capabilities = participant.capabilities;
   const allowed = new Set(capabilities);
-  return Object.freeze({ participantId, displayName: participant.displayName, role: participant.role, capabilities, handRaised: participant.handRaised, can: (capability) => allowed.has(capability) });
+  return Object.freeze({ participantId, identityId, displayName: participant.displayName, role: participant.role, capabilities, handRaised: participant.handRaised, can: (capability) => allowed.has(capability) });
+}
+function selfIdentityFor(snapshot, participant) {
+  if (!snapshot) return void 0;
+  if (snapshot.connection.phase === "terminal") return void 0;
+  if (snapshot.control?.status === "ended") return void 0;
+  return snapshot.participantIdentityId ?? participant?.identityId;
 }
-function emptySelf(participantId) {
-  return Object.freeze({ participantId, displayName: null, role: null, capabilities: Object.freeze([]), handRaised: false, can: () => false });
+function emptySelf(participantId, identityId) {
+  return Object.freeze({ participantId, identityId, displayName: null, role: null, capabilities: Object.freeze([]), handRaised: false, can: () => false });
 }
 function capabilitiesFor(control, collaboration) {
   const capabilities = /* @__PURE__ */ new Set();
@@ -6684,10 +6953,10 @@ function sameParticipantMedia(left, right) {
   return left.media.microphone === right.media.microphone && left.media.camera === right.media.camera && left.media.screenShare === right.media.screenShare && left.media.screenShareHasAudio === right.media.screenShareHasAudio;
 }
 function sameParticipantPresence(left, right) {
-  return left.presence.state === right.presence.state && left.presence.speaking === right.presence.speaking && left.presence.activeSpeaker === right.presence.activeSpeaker;
+  return left.identityId === right.identityId && left.deviceType === right.deviceType && left.presence.state === right.presence.state && left.presence.speaking === right.presence.speaking && left.presence.activeSpeaker === right.presence.activeSpeaker;
 }
 function sameSelf(left, right) {
-  return left.participantId === right.participantId && left.displayName === right.displayName && left.role === right.role && left.handRaised === right.handRaised && sameValues(left.capabilities, right.capabilities);
+  return left.participantId === right.participantId && left.identityId === right.identityId && left.displayName === right.displayName && left.role === right.role && left.handRaised === right.handRaised && sameValues(left.capabilities, right.capabilities);
 }
 function sameArray(left, right, equal) {
   return left.length === right.length && left.every((value, index) => equal(value, right[index]));