@q9labsai/chalk-client 5.3.0 → 5.4.0

package/dist/{chunk-DHUHTIU7.js → chunk-TA2BJXI7.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-3TGVTP6Z.js";
-import {
-  AccessGrantError,
-  requireParsedAccessGrant
-} from "./chunk-GOSWSXTH.js";
+} from "./chunk-UVWRTXNO.js";
 import {
   ChatAttachmentMimeTypeSchema,
   ChatReactionSetFrameSchema,
@@ -24,7 +24,10 @@ import {
   formatSyncConnectDiagnostic,
   scheduleSyncDialDeadline,
   syncConnectFailureCode
-} from "./chunk-XSB2GDRW.js";
+} from "./chunk-XF567GPH.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
@@ -2707,6 +2712,7 @@ function bindConnectionMediaClient(client, restart) {
     ...client.remoteParticipantsChanged ? { remoteParticipantsChanged: client.remoteParticipantsChanged.bind(client) } : {},
     ...client.remotePublicationsChanged ? { remotePublicationsChanged: client.remotePublicationsChanged.bind(client) } : {},
     ...client.remotePublicationResumed ? { remotePublicationResumed: client.remotePublicationResumed.bind(client) } : {},
+    ...client.localPublicationWithdrawn ? { localPublicationWithdrawn: client.localPublicationWithdrawn.bind(client) } : {},
     start: client.start.bind(client),
     stop: client.stop.bind(client),
     restart,
@@ -3777,9 +3783,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* () {
@@ -4461,13 +4472,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));
   }
@@ -4545,7 +4556,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" }));
@@ -4561,7 +4572,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) => {
@@ -4969,8 +4980,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") {
 };
@@ -5014,7 +5052,10 @@ var MediaControllerRuntime = class {
   #sources = { microphone: sourceWorker(true), camera: sourceWorker(true), screen: sourceWorker(false) };
   #syncLive = false;
   #disposed = false;
+  /** The wanted-on sources when recovery began, with the intent revision each one had then. */
   #recovering = null;
+  /** The Sync client's last proof of contact when the current recovery began: where its drop is measured from. */
+  #proof = null;
   #pendingSources = /* @__PURE__ */ new Map();
   #pendingCaptures = /* @__PURE__ */ new Set();
   #readinessChecks = /* @__PURE__ */ new Set();
@@ -5157,6 +5198,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();
@@ -5210,8 +5253,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);
@@ -5258,7 +5320,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) {
@@ -5293,12 +5357,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* () {
@@ -5307,11 +5371,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;
     });
@@ -5319,16 +5384,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);
@@ -5336,6 +5398,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];
@@ -5469,7 +5541,10 @@ var MediaControllerRuntime = class {
     return state.desired.enabled && state.forcedRevision !== state.desired.revision;
   }
   #resetObservations() {
-    if (this.#connection.getSnapshot().state !== "reconnecting") this.#recovering = null;
+    if (this.#connection.getSnapshot().state !== "reconnecting") {
+      this.#recovering = null;
+      this.#proof = null;
+    }
     for (const source of MEDIA_SOURCES) {
       const state = this.#sources[source];
       state.result = { revision: state.desired.revision, status: "confirmed" };
@@ -5552,19 +5627,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.#applyRecoveryRule(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(
@@ -5971,6 +6124,7 @@ var MediaControllerRuntime = class {
     this.#ports = ports;
     this.#projection.reset();
     this.#syncLive = false;
+    this.#cancelOffRetries();
     this.#bindCamera(ports);
     if (!ports) {
       this.#resetObservations();
@@ -6002,21 +6156,65 @@ var MediaControllerRuntime = class {
   #rememberRecoveryIntents() {
     for (const state of Object.values(this.#sources)) if (state.capturePause === "announced") state.capturePause = "pending";
     if (!this.#ports) return;
+    if (this.#recovering === null) this.#proof = this.#ports.sync.link?.proof() ?? null;
     this.#recovering ??= new Map(MEDIA_SOURCES.filter((source) => this.#sources[source].desired.enabled).map((source) => [source, this.#sources[source].desired.revision]));
   }
-  #pauseRecoveredIntents(ports, snapshot) {
-    const recovering = this.#recovering;
+  /**
+   * The rule depends on what the connected Sync advertised. Sync's snapshot items carry `off_reason` only when its welcome said
+   * `media_off_reason`, and only then can recovery tell a host stop from a publication that is merely missing. Without it the rule
+   * is the one this SDK had before: a wanted-on source whose own item is missing or not enabled is paused (#597).
+   */
+  #applyRecoveryRule(ports, snapshot) {
+    const recovering = this.#recovering ?? /* @__PURE__ */ new Map();
+    const proof = this.#proof;
     this.#recovering = null;
-    for (const [source, revision] of recovering ?? []) {
-      const current = snapshot.media?.items.find((item) => item.participantId === snapshot.participantId && item.source === source);
-      if (!current?.enabled) this.#pausePublication(ports, source, revision, "sync_recovery_loss");
+    this.#proof = null;
+    if (ports.sync.offReasonNegotiated?.() === true) this.#pauseOnEvidence(ports, snapshot, recovering, ports.sync.link?.longSince(proof) ?? true);
+    else this.#pauseWhenSyncLostIt(ports, snapshot, recovering);
+  }
+  #pauseWhenSyncLostIt(ports, snapshot, recovering) {
+    for (const [source, revision] of recovering) {
+      if (!ownProjection(snapshot, source)?.enabled) this.#pausePublication(ports, source, revision, "sync_recovery_loss");
     }
   }
+  /**
+   * A wanted-on source is paused when Sync's item says the host stopped it after the user's intent (`off_reason: "host"` with a newer
+   * `off_revision`; a replayed stop event reaches `#subscribePauses` the same way). This holds for every source that is wanted on when
+   * the snapshot arrives, including one the user turned on after recovery began, and for every source recovery began with. With no such
+   * evidence the drop decides, whatever Sync lists: the source stays wanted-on after a drop proven short and turns off, like a tap, after
+   * any other. The drop cutoff applies only to the intent the source had when recovery began (`recovering`), so a newer intent from the
+   * user is left alone.
+   */
+  #pauseOnEvidence(ports, snapshot, recovering, longDrop) {
+    for (const source of MEDIA_SOURCES) {
+      const intentRevision = recovering.get(source);
+      if (intentRevision === void 0 && !this.#sources[source].desired.enabled) continue;
+      const item = ownProjection(snapshot, source);
+      const stopRevision = this.#hostStopNewerThanIntent(source, item);
+      if (stopRevision !== null) this.#pauseForHostStop(ports, source, stopRevision);
+      else if (longDrop && intentRevision !== void 0 && this.#sources[source].desired.revision === intentRevision) this.#turnOffLikeATap(source);
+    }
+  }
+  #hostStopNewerThanIntent(source, item) {
+    if (item?.offReason !== "host" || item.offRevision === void 0) return null;
+    return item.offRevision > this.#sources[source].desired.controlRevision ? item.offRevision : null;
+  }
+  #pauseForHostStop(ports, source, stopRevision) {
+    const state = this.#sources[source];
+    state.serverSequence = Math.max(state.serverSequence, stopRevision);
+    this.#pausePublication(ports, source, state.desired.revision, "moderation_pause");
+  }
+  // The intent becomes off exactly as a tap makes it, so the UI shows it off and the user can tap to turn it on.
+  #turnOffLikeATap(source) {
+    this.#recordIntent(source, false);
+    this.#sources[source].offDebt = "owed";
+  }
   #subscribeSync(ports) {
     return ports.sync.subscribe((snapshot) => {
       this.#removeRequestsFromMissingParticipants(snapshot);
       this.#applyRemoteMediaState(ports, snapshot);
       this.#reconcileIntents();
+      this.#retryOffs();
       this.#notifyCapturePauses(ports);
       this.#publish();
     });