@q9labsai/chalk-client 5.2.3 → 5.2.5

package/dist/{chunk-4ZUN55Z2.js → chunk-BUNSEDXL.js}

@@ -1,12 +1,16 @@
 import {
   CloudflareSFUClient,
+  CloudflareSFUError,
+  classifyMediaFailure,
   createCloudflareSFUHTTPTransport,
-  describeMediaCaptureError
-} from "./chunk-DWKTGBHR.js";
+  describeMediaCaptureError,
+  grantedMediaFromStream,
+  markMediaFailure
+} from "./chunk-FD25AMLG.js";
 import {
   AccessGrantError,
   requireParsedAccessGrant
-} from "./chunk-GA3JDPFI.js";
+} from "./chunk-UMAE5GCV.js";
 import {
   ChatAttachmentMimeTypeSchema,
   ChatReactionSetFrameSchema,
@@ -20,22 +24,46 @@ import {
   formatSyncConnectDiagnostic,
   scheduleSyncDialDeadline,
   syncConnectFailureCode
-} from "./chunk-IMMT22US.js";
+} from "./chunk-5YPQNMJE.js";
 
 // src/access/manager.ts
-import { Clock, Context, Data, Effect, Layer, SynchronizedRef } from "effect";
+import { Clock, Context, Data, Deferred, Effect, Layer, SynchronizedRef } from "effect";
 var DEFAULT_REFRESH_WINDOW_MS = 6e4;
 var ACCESS_PROVIDER_TIMEOUT_MS = 7e3;
 var ConnectionAccessFailure = class extends Data.TaggedError("ConnectionAccessFailure") {
 };
+var MediaReplacementPending = class extends Data.TaggedError("MediaReplacementPending") {
+};
 var ConnectionAccessService = class extends Context.Service()("@chalk/client/ConnectionAccess") {
 };
 var makeConnectionAccessLayer = (provider, refreshWindowMs = DEFAULT_REFRESH_WINDOW_MS) => Layer.effect(
   ConnectionAccessService,
   Effect.gen(function* () {
     const state = yield* SynchronizedRef.make({ access: null });
+    const holds = /* @__PURE__ */ new Map();
+    const replacementGate = () => {
+      const binding = SynchronizedRef.getUnsafe(state).access?.media.clientPayload.connectionId;
+      return binding ? holds.get(binding)?.done : void 0;
+    };
+    const holdMediaBinding = (binding) => Effect.gen(function* () {
+      const hold = holds.get(binding) ?? { count: 0, done: yield* Deferred.make() };
+      hold.count++;
+      holds.set(binding, hold);
+      return Effect.gen(function* () {
+        if (--hold.count !== 0) return;
+        holds.delete(binding);
+        yield* Deferred.succeed(hold.done, void 0);
+      });
+    });
     const automaticMediaReplacementListeners = /* @__PURE__ */ new Set();
-    const fetch2 = (reason, replaceMediaConnection, force) => SynchronizedRef.modifyEffect(state, (current) => fetchAccessGrant(provider, { current, reason, replaceMediaConnection, force, refreshWindowMs })).pipe(
+    const fetch2 = (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.map((access) => ({ access, automaticMediaReplacement: false }))
+        )
+      ),
       Effect.tap((result) => Effect.sync(() => notifyAutomaticMediaReplacement(automaticMediaReplacementListeners, result))),
       Effect.map((result) => result.access)
     );
@@ -59,9 +87,14 @@ var makeConnectionAccessLayer = (provider, refreshWindowMs = DEFAULT_REFRESH_WIN
         automaticMediaReplacementListeners.add(listener);
         return () => automaticMediaReplacementListeners.delete(listener);
       }),
-      requiresRefresh: millisecondsUntilRefresh.pipe(Effect.map((milliseconds) => milliseconds === null || milliseconds === 0)),
+      requiresRefresh: millisecondsUntilRefresh.pipe(Effect.map((milliseconds2) => milliseconds2 === null || milliseconds2 === 0)),
       millisecondsUntilRefresh,
-      clear: SynchronizedRef.set(state, { access: null })
+      holdMediaBinding,
+      clear: Effect.gen(function* () {
+        yield* SynchronizedRef.set(state, { access: null });
+        for (const hold of holds.values()) yield* Deferred.fail(hold.done, new ConnectionAccessFailure({ code: "access.unavailable", cause: "Connection closed during media rejection classification" }));
+        holds.clear();
+      })
     };
   })
 );
@@ -70,17 +103,21 @@ function fetchAccessGrant(provider, input) {
   return Effect.gen(function* () {
     const now = yield* Clock.currentTimeMillis;
     const currentAccess = input.current.access;
-    if (!input.force && currentAccess && millisecondsUntil(currentAccess, now, input.refreshWindowMs) > 0) {
+    if (canReuseAccess(input, now) && currentAccess) {
       return [{ access: currentAccess, automaticMediaReplacement: false }, input.current];
     }
-    const mediaExpired = currentAccess !== null && expiresAt(currentAccess.media.expiresAt) <= now;
-    const shouldReplaceMediaConnection = input.replaceMediaConnection || mediaExpired;
+    const gate = input.replacementGate();
+    const shouldReplaceMediaConnection = mediaReplacementRequested(input, now, Boolean(gate));
+    if (shouldReplaceMediaConnection && gate) return yield* Effect.fail(new MediaReplacementPending({ done: gate }));
     const next = yield* provider(connectionAccessRequest(input, shouldReplaceMediaConnection)).pipe(
       Effect.timeout(ACCESS_PROVIDER_TIMEOUT_MS),
       Effect.mapError((cause) => cause instanceof ConnectionAccessFailure ? cause : new ConnectionAccessFailure({ code: "access.unavailable", cause }))
     );
     yield* Effect.try({
-      try: () => validateFetchedAccess(currentAccess, next, now, shouldReplaceMediaConnection),
+      try: () => {
+        validateFetchedAccess(currentAccess, next, now, shouldReplaceMediaConnection);
+        validateHeldBinding(input, next);
+      },
       catch: (cause) => new ConnectionAccessFailure({ code: "access.invalid", cause })
     });
     return [{ access: next, automaticMediaReplacement: currentAccess !== null && !input.replaceMediaConnection && !hasSameMediaConnection(currentAccess, next) }, { access: next }];
@@ -92,7 +129,8 @@ function connectionAccessRequest(input, replaceMediaConnection) {
     replaceMediaConnection,
     ...input.current.access ? {
       currentMediaToken: input.current.access.media.token,
-      expectedParticipantGeneration: input.current.access.subject.participantGeneration
+      expectedParticipantGeneration: input.current.access.subject.participantGeneration,
+      ...replaceMediaConnection && input.reason !== "access_retry" ? { expectedMediaConnectionId: input.current.access.media.clientPayload.connectionId } : {}
     } : {}
   });
 }
@@ -138,6 +176,17 @@ function expiresAt(value) {
   if (!Number.isFinite(timestamp)) throw new TypeError("Access grant expiration is invalid");
   return timestamp;
 }
+function canReuseAccess(input, now) {
+  return !input.force && input.current.access !== null && millisecondsUntil(input.current.access, now, input.refreshWindowMs) > 0;
+}
+function mediaReplacementRequested(input, now, held) {
+  const current = input.current.access;
+  return input.replaceMediaConnection || current !== null && expiresAt(current.media.expiresAt) <= now && !held;
+}
+function validateHeldBinding(input, next) {
+  const previous = input.current.access;
+  if (input.replacementGate() && previous && !hasSameMediaConnection(previous, next)) throw new TypeError("Cannot replace a rejected media binding before classification");
+}
 
 // src/connection/dependencies.ts
 import { Context as Context2, Layer as Layer2 } from "effect";
@@ -2156,7 +2205,7 @@ var ChalkWhiteboardV1Client = class {
     return this.#options.clock ?? {
       now: Date.now,
       monotonicNow: () => globalThis.performance.now(),
-      setTimeout: (callback, milliseconds) => globalThis.setTimeout(callback, milliseconds),
+      setTimeout: (callback, milliseconds2) => globalThis.setTimeout(callback, milliseconds2),
       clearTimeout: (handle) => globalThis.clearTimeout(handle)
     };
   }
@@ -2288,6 +2337,162 @@ function createChalkWhiteboardV1Client(options) {
   });
 }
 
+// src/connection/episode-status.ts
+var EpisodeStatusError = class extends Error {
+  constructor(status, retryAfterMs = 0) {
+    super(`Episode status unavailable: HTTP ${status}`);
+    this.status = status;
+    this.retryAfterMs = retryAfterMs;
+  }
+  status;
+  retryAfterMs;
+};
+function episodeStatusRetryDelay(attempt, error2) {
+  const retryAfterMs = error2 instanceof EpisodeStatusError ? error2.retryAfterMs : 0;
+  const ceiling = Math.min(1e3 * 2 ** Math.min(attempt, 5), 1e4);
+  return Math.max(retryAfterMs, ceiling * (0.5 + Math.random() * 0.5));
+}
+function retryAfterMilliseconds(value, now) {
+  if (!value) return 0;
+  const seconds = Number(value);
+  const delay = Number.isFinite(seconds) ? seconds * 1e3 : Date.parse(value) - now;
+  return Number.isFinite(delay) ? Math.max(0, delay) : 0;
+}
+
+// src/connection/report.ts
+var MAX_EVENTS = 64;
+var MAX_BYTES = 32768;
+var MAX_MS = 2147483647;
+var COOLDOWN_MS = 6e4;
+var participantCooldowns = /* @__PURE__ */ new Map();
+var milliseconds = (value) => Math.max(0, Math.min(MAX_MS, Math.round(Number.isFinite(value) ? value : 0)));
+var optionalMilliseconds = (value) => value == null ? void 0 : milliseconds(value);
+function mediaReportFields(media) {
+  if (!media) return {};
+  return {
+    media_error_kind: media.media_error_kind,
+    media_error_step: media.media_error_step,
+    granted_audio: media.granted_audio,
+    granted_video: media.granted_video,
+    http_status: media.http_status
+  };
+}
+function reserveParticipantReport(access, now) {
+  const key = `${access.subject.tenantId}:${access.subject.participantId}`;
+  for (const [participant, until] of participantCooldowns) if (until <= now) participantCooldowns.delete(participant);
+  if (participantCooldowns.has(key)) return false;
+  if (participantCooldowns.size >= 128) participantCooldowns.delete(participantCooldowns.keys().next().value ?? "");
+  participantCooldowns.set(key, now + COOLDOWN_MS);
+  return true;
+}
+var ConnectionReporter = class {
+  #events = [];
+  #startedAt;
+  #options;
+  #pending = null;
+  #unsubscribe;
+  #controller = null;
+  #retryOnReconnect = false;
+  #disposed = false;
+  constructor(options) {
+    this.#options = options;
+    this.#startedAt = options.now();
+  }
+  recordDiagnostic(diagnostic) {
+    this.#record({
+      event: diagnostic.event,
+      elapsed_ms: this.#elapsed(),
+      state: diagnostic.state,
+      step: diagnostic.step,
+      outcome: diagnostic.outcome,
+      code: diagnostic.code,
+      attempt: optionalMilliseconds(diagnostic.attempt),
+      duration_ms: optionalMilliseconds(diagnostic.sync?.durationMs ?? diagnostic.durationMs),
+      close_code: diagnostic.sync?.closeCode ?? void 0,
+      heartbeat_gap_ms: optionalMilliseconds(diagnostic.recovery?.lastHeartbeatReplyAgoMs),
+      ...mediaReportFields(diagnostic.media)
+    });
+    if (diagnostic.event === "recovery_exhausted") this.#report("recovery_exhausted");
+    else if (diagnostic.event === "connection_failed") this.#report(diagnostic.state === "joining" ? "join_failed" : "connection_lost");
+  }
+  recordTransport(event) {
+    this.#record({
+      event: event.event,
+      elapsed_ms: this.#elapsed(),
+      ...event.phase ? { phase: event.phase } : {},
+      ...event.attempt == null ? {} : { attempt: milliseconds(event.attempt) },
+      ...event.duration_ms == null ? {} : { duration_ms: milliseconds(event.duration_ms) },
+      ...event.heartbeat_gap_ms == null ? {} : { heartbeat_gap_ms: milliseconds(event.heartbeat_gap_ms) },
+      ...event.close_code == null ? {} : { close_code: event.close_code },
+      ...event.http_status == null ? {} : { http_status: event.http_status },
+      source: event.source,
+      publication_state: event.publication_state,
+      projection_state: event.projection_state,
+      outcome: event.outcome
+    });
+    if (event.event === "media_projection_mismatch") this.#report("media_projection_mismatch");
+  }
+  dispose() {
+    this.#disposed = true;
+    this.#controller?.abort();
+    this.#stopListening();
+    this.#pending = null;
+    this.#events.length = 0;
+  }
+  get traceparent() {
+    return this.#options.traceparent;
+  }
+  #elapsed() {
+    return milliseconds(this.#options.now() - this.#startedAt);
+  }
+  #record(event) {
+    if (this.#disposed) return;
+    this.#events.push(event);
+    if (this.#events.length > MAX_EVENTS) this.#events.shift();
+  }
+  #report(trigger) {
+    if (this.#disposed || this.#pending) return;
+    const access = this.#options.access();
+    if (!access) return;
+    if (!reserveParticipantReport(access, this.#options.now())) return;
+    const events = this.#events.slice();
+    const report = { version: 1, trigger, events };
+    while (events.length && new TextEncoder().encode(JSON.stringify(report)).byteLength > MAX_BYTES) events.shift();
+    if (!events.length) return;
+    this.#pending = { access, report, attempts: 0 };
+    this.#unsubscribe = this.#options.subscribeOnline(() => {
+      this.#retryOnReconnect = true;
+      void this.#flush();
+    });
+    void this.#flush();
+  }
+  async #flush() {
+    const pending = this.#pending;
+    if (!pending || this.#controller || this.#disposed || !this.#options.online()) return;
+    this.#retryOnReconnect = false;
+    const controller = new AbortController();
+    this.#controller = controller;
+    pending.attempts += 1;
+    const timer = globalThis.setTimeout(() => controller.abort(), 5e3);
+    try {
+      await this.#options.send(pending.access, pending.report, controller.signal, this.traceparent);
+      this.#pending = null;
+    } catch {
+      if (pending.attempts >= 2) this.#pending = null;
+    } finally {
+      globalThis.clearTimeout(timer);
+      this.#controller = null;
+      if (!this.#pending) this.#stopListening();
+      if (this.#retryOnReconnect) void this.#flush();
+    }
+  }
+  #stopListening() {
+    this.#unsubscribe?.();
+    this.#unsubscribe = void 0;
+    this.#retryOnReconnect = false;
+  }
+};
+
 // src/connection/types.ts
 var ConnectionError = class extends Error {
   code;
@@ -2309,7 +2514,12 @@ function createBrowserMediaDevices(mediaDevices = globalThis.navigator?.mediaDev
   return {
     async getUserMedia(constraints) {
       if (!mediaDevices?.getUserMedia || globalThis.isSecureContext === false) throw new ConnectionError({ code: "unsupported_environment", action: null, recoverable: false, message: "Browser media capture is unavailable. Use a supported browser over HTTPS." });
-      return mediaDevices.getUserMedia(constraints);
+      try {
+        return await mediaDevices.getUserMedia(constraints);
+      } catch (error2) {
+        markMediaFailure(error2, "local_capture");
+        throw error2;
+      }
     },
     async getDisplayMedia(constraints) {
       if (!mediaDevices?.getDisplayMedia) throw new DOMException("Browser display capture is unavailable", "NotSupportedError");
@@ -2359,10 +2569,49 @@ function createDefaultConnectionDependencies(options) {
   return {
     clock: {
       now: () => Date.now(),
-      setTimeout: (callback, milliseconds) => globalThis.setTimeout(callback, milliseconds),
+      setTimeout: (callback, milliseconds2) => globalThis.setTimeout(callback, milliseconds2),
       clearTimeout: (handle) => globalThis.clearTimeout(handle)
     },
+    createConnectionReporter: (access) => {
+      const random = globalThis.crypto;
+      if (!random?.randomUUID) return void 0;
+      return new ConnectionReporter({
+        traceparent: `00-${random.randomUUID().replaceAll("-", "")}-${random.randomUUID().replaceAll("-", "").slice(0, 16)}-01`,
+        now: () => performance.now(),
+        access,
+        online: () => globalThis.navigator?.onLine !== false,
+        subscribeOnline: (listener) => {
+          globalThis.window?.addEventListener("online", listener);
+          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`, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${grant.media.token}`, "Content-Type": "application/json", traceparent },
+            body: JSON.stringify(report),
+            signal,
+            keepalive: true,
+            credentials: "omit"
+          });
+          await response.body?.cancel();
+        }
+      });
+    },
     mediaDevices: createBrowserMediaDevices(),
+    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`, {
+        headers: { Authorization: `Bearer ${access.media.token}` },
+        signal,
+        cache: "no-store",
+        credentials: "omit"
+      });
+      if (!response.ok) throw new EpisodeStatusError(response.status, retryAfterMilliseconds(response.headers.get("Retry-After"), Date.now()));
+      const body = await response.json();
+      if (typeof body === "object" && body !== null && "status" in body && (body.status === "active" || body.status === "ending" || body.status === "ended")) return body.status;
+      throw new TypeError("Invalid Episode status");
+    },
     cancelPendingAdmission: async (access, signal) => {
       const { tenantId, spaceId, episodeId, participantId } = access.subject;
       const path = [tenantId, spaceId, episodeId, participantId].map(encodeURIComponent);
@@ -2426,6 +2675,8 @@ function createMediaClient(apiBaseURL, input) {
     transport: createCloudflareSFUHTTPTransport({
       apiBaseURL,
       credential: input.credential,
+      onDiagnostic: input.onTransportDiagnostic,
+      traceparent: input.traceparent,
       tenantId: subject.tenantId,
       spaceId: subject.spaceId,
       episodeId: subject.episodeId,
@@ -2467,6 +2718,8 @@ function bindConnectionMediaClient(client, restart) {
 function createSyncClient(syncURL, input) {
   return createV1SyncClient({
     url: syncURL,
+    onDiagnostic: input.onTransportDiagnostic,
+    traceparent: input.traceparent,
     token: input.token,
     mediaPlane: input.media,
     collaboration: { name: "collaboration_v2", chatCursor: { afterSequence: null, retainedFloorSequence: null } },
@@ -2498,7 +2751,7 @@ function whiteboardURL(syncURL) {
 }
 
 // src/foreground-deadline.ts
-function scheduleForegroundDeadline(clock, milliseconds, expired) {
+function scheduleForegroundDeadline(clock, milliseconds2, expired) {
   let timer;
   let cancelled = false;
   const arm = () => {
@@ -2506,9 +2759,9 @@ function scheduleForegroundDeadline(clock, milliseconds, expired) {
     timer = clock.setTimeout(() => {
       if (cancelled) return;
       const elapsed = clock.now() - started;
-      if (typeof document !== "undefined" && document.visibilityState === "hidden" || elapsed > milliseconds + 2e3 || elapsed < 0) arm();
+      if (typeof document !== "undefined" && document.visibilityState === "hidden" || elapsed > milliseconds2 + 2e3 || elapsed < 0) arm();
       else expired();
-    }, milliseconds);
+    }, milliseconds2);
   };
   arm();
   return () => {
@@ -2518,7 +2771,7 @@ function scheduleForegroundDeadline(clock, milliseconds, expired) {
 }
 
 // src/connection/lifecycle.ts
-import { Clock as Clock2, Context as Context3, Data as Data2, Deferred, Duration, Effect as Effect2, Exit, Fiber, Layer as Layer3, Queue, Scope, SubscriptionRef } from "effect";
+import { Clock as Clock2, Context as Context3, Data as Data2, Deferred as Deferred2, Duration, Effect as Effect2, Exit, Fiber, Layer as Layer3, Queue, Scope, SubscriptionRef } from "effect";
 
 // src/connection/diagnostics.ts
 var ConnectionDiagnostics = class {
@@ -2543,11 +2796,17 @@ var ConnectionDiagnostics = class {
   }
   recordRecoveryExhausted(input) {
     const { state, epoch, code, attempts, transport } = input;
+    const media = input.media ?? (code === "media_recovery_exhausted" ? {
+      media_error_kind: "timeout",
+      media_error_step: "peer_connection",
+      ...input.grantedMedia
+    } : void 0);
     this.record({
       event: "recovery_exhausted",
       state,
       epoch,
       code,
+      ...media ? { media } : {},
       recovery: {
         reference: `connection.${code}`,
         attempts,
@@ -2579,7 +2838,8 @@ var ConnectionDiagnostics = class {
           ...input.parentSpanId ? { parentSpanId: input.parentSpanId } : {},
           outcome: end.outcome,
           durationMs: Math.max(0, this.#now() - startedAt),
-          ...end.code ? { code: end.code } : {}
+          ...end.code ? { code: end.code } : {},
+          ...end.media ? { media: end.media } : {}
         });
       }
     };
@@ -2593,7 +2853,7 @@ var ConnectionDiagnostics = class {
 var MEDIA_RECOVERY_TIMEOUT_MS = 6e4;
 var START_TIMEOUT_MS = 3e4;
 var LEAVE_TIMEOUT_MS = 5e3;
-var RECOVERY_BUDGET_MS = 1e4;
+var RECOVERY_BUDGET_MS = MEDIA_RECOVERY_TIMEOUT_MS;
 var MAX_RECOVERY_ATTEMPTS = 3;
 var REFRESH_RETRY_MS = 5e3;
 var RECONNECT_GRACE_MS = 250;
@@ -2634,7 +2894,18 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
     const clock = yield* Clock2.Clock;
     const context = yield* Effect2.context();
     const serviceScope = yield* Effect2.scope;
-    const diagnostics = new ConnectionDiagnostics({ now: () => clock.currentTimeMillisUnsafe(), ...options.diagnostics });
+    const reporter = platform.createConnectionReporter?.(access.currentUnsafe);
+    let grantedMedia = { granted_audio: "unknown", granted_video: "unknown" };
+    let mediaFailure;
+    const diagnostics = new ConnectionDiagnostics({
+      now: () => clock.currentTimeMillisUnsafe(),
+      ...options.diagnostics,
+      onEvent: (event) => {
+        reporter?.recordDiagnostic(event);
+        options.diagnostics?.onEvent?.(event);
+      }
+    });
+    const onTransportDiagnostic = (event) => reporter?.recordTransport(event);
     const snapshotRef = yield* SubscriptionRef.make(idleSnapshot());
     const queue = yield* Queue.unbounded();
     const listeners = /* @__PURE__ */ new Set();
@@ -2645,6 +2916,8 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
     let fallbackIdentifier = 0;
     let emittedPorts = null;
     let foregroundRecoveryDeadline = 0;
+    let pendingEpisodeEnd = null;
+    let rejectionCheck = null;
     const model = {
       state: "idle",
       sync: null,
@@ -2676,11 +2949,11 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       epoch: 0
     };
     const mediaAttempt = { expiresAt: null };
-    const foreign7 = (operation, code = "internal_error", message = "A browser transport operation failed") => Effect2.tryPromise({ try: operation, catch: (cause) => accessRejected(cause) ? lifecycleFailure("invalid_access", false, "Access was rejected", cause) : lifecycleFailure(code, true, message, cause) });
-    const withinForegroundBudget = (effect, milliseconds, failure2) => Effect2.raceFirst(
+    const foreign7 = (operation, code = "internal_error", message = "A browser transport operation failed") => Effect2.tryPromise({ try: operation, catch: (cause) => accessRejected(cause) ? lifecycleFailure("invalid_access", false, "Access was rejected", cause) : sfuAccessRejected(cause) ? failureFromCause(cause, code, message) : lifecycleFailure(code, true, message, cause) });
+    const withinForegroundBudget = (effect, milliseconds2, failure2) => Effect2.raceFirst(
       effect,
       Effect2.callback((resume) => {
-        const cancel = scheduleForegroundDeadline(platform.clock, milliseconds, () => resume(Effect2.fail(typeof failure2 === "function" ? failure2() : failure2)));
+        const cancel = scheduleForegroundDeadline(platform.clock, milliseconds2, () => resume(Effect2.fail(typeof failure2 === "function" ? failure2() : failure2)));
         return Effect2.sync(cancel);
       })
     );
@@ -2726,9 +2999,9 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
     });
     const enqueue = (effect, join = false) => Effect2.gen(function* () {
       if (model.closed) return yield* Effect2.fail(lifecycleFailure("invalid_state", false, "The Connection scope is closed"));
-      const deferred = yield* Deferred.make();
+      const deferred = yield* Deferred2.make();
       yield* Queue.offer(queue, { effect, deferred, join });
-      return yield* Deferred.await(deferred);
+      return yield* Deferred2.await(deferred);
     });
     const enqueueBackground = (effect) => {
       void Effect2.runForkWith(context)(enqueue(effect).pipe(Effect2.ignore));
@@ -2741,10 +3014,10 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
     const scheduleRefresh = (delay) => Effect2.gen(function* () {
       yield* stopRefresh();
       if (!active(model)) return;
-      const milliseconds = delay ?? (yield* access.millisecondsUntilRefresh) ?? 0;
+      const milliseconds2 = delay ?? (yield* access.millisecondsUntilRefresh) ?? 0;
       const scope = model.activeScope;
       if (!scope) return;
-      model.refreshFiber = yield* Effect2.forkIn(Effect2.sleep(Math.max(0, milliseconds)).pipe(Effect2.andThen(enqueue(refreshAccess())), Effect2.ignore), scope);
+      model.refreshFiber = yield* Effect2.forkIn(Effect2.sleep(Math.max(0, milliseconds2)).pipe(Effect2.andThen(enqueue(refreshAccess())), Effect2.ignore), scope);
     });
     const refreshAccess = () => Effect2.gen(function* () {
       const scope = model.activeScope;
@@ -2884,7 +3157,13 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       const span = diagnostics.startSpan({ step, state: model.state, epoch: model.epoch });
       return effect.pipe(
         Effect2.tap(() => Effect2.sync(() => span.end({ state: model.state, epoch: model.epoch, outcome: "succeeded" }))),
-        Effect2.tapError((cause) => Effect2.sync(() => span.end({ state: model.state, epoch: model.epoch, outcome: "failed", code: failureFromCause(cause, "internal_error", "Connection step failed").code })))
+        Effect2.tapError(
+          (cause) => Effect2.sync(() => {
+            const media = step === "acquire_initial_media" || step === "create_media_client" || step === "start_media" ? { ...classifyMediaFailure(cause, step === "acquire_initial_media" ? "local_capture" : "peer_connection"), ...grantedMedia } : void 0;
+            if (media) mediaFailure = media;
+            span.end({ state: model.state, epoch: model.epoch, outcome: "failed", code: failureFromCause(cause, "internal_error", "Connection step failed").code, ...media ? { media } : {} });
+          })
+        )
       );
     };
     const confirmSyncEntry = (sync) => {
@@ -2895,6 +3174,10 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       if (model.state === "live") return;
       if (model.state === "leaving" || model.closed) return yield* Effect2.fail(lifecycleFailure("invalid_state", false, "Cannot join an inactive Connection"));
       model.epoch += 1;
+      pendingEpisodeEnd = null;
+      rejectionCheck = null;
+      grantedMedia = { granted_audio: "unknown", granted_video: "unknown" };
+      mediaFailure = void 0;
       model.failure = null;
       model.episodeEndConfirmed = false;
       model.episodeEndReason = void 0;
@@ -2909,6 +3192,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
         if (model.joinCancelled) return yield* Effect2.fail(lifecycleFailure("invalid_state", false, "Join was cancelled by Leave"));
         const captured = yield* trace("acquire_initial_media", acquireInitialMedia(model.initialMedia, model.initialMediaIntent?.() ?? model.intent));
         stream = captured.stream;
+        grantedMedia = grantedMediaFromStream(stream);
         captureWarning = captured.failure;
         if (model.joinCancelled) return yield* Effect2.fail(lifecycleFailure("invalid_state", false, "Join was cancelled by Leave"));
         const grant = yield* trace("access_initialize", reason === "access_retry" ? access.refreshAfterRejection() : access.initialize(reason));
@@ -2923,7 +3207,9 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
                 if (media === model.media) mediaAttempt.expiresAt = platform.clock.now() + MEDIA_RECOVERY_TIMEOUT_MS;
                 return replacement.media;
               }),
-              onFailure: () => enqueueBackground(handleMediaFailure()),
+              onTransportDiagnostic,
+              traceparent: reporter?.traceparent,
+              onFailure: (cause, binding = grant.media.clientPayload.connectionId) => enqueueBackground(handleMediaFailure(media, cause, binding)),
               onScreenEnded: () => enqueueBackground(notifyScreenEnded())
             }),
             catch: (cause) => accessRejected(cause) ? lifecycleFailure("invalid_access", false, "Access was rejected", cause) : lifecycleFailure("media_start_failed", true, "The media layer could not start", cause)
@@ -2933,7 +3219,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
         const sync = yield* trace(
           "create_sync_client",
           Effect2.try({
-            try: () => platform.createSyncClient({ access: grant, token: () => toPromise(access.getSyncToken()), media }),
+            try: () => platform.createSyncClient({ access: grant, token: () => toPromise(access.getSyncToken()), media, onTransportDiagnostic, traceparent: reporter?.traceparent }),
             catch: (cause) => accessRejected(cause) ? lifecycleFailure("invalid_access", false, "Access was rejected", cause) : lifecycleFailure("sync_start_failed", true, "The sync layer could not start", cause)
           })
         );
@@ -2943,7 +3229,11 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
           [
             trace(
               "start_media",
-              model.startInitialMedia ? model.startInitialMedia(media, stream).pipe(Effect2.mapError((cause) => lifecycleFailure("media_start_failed", true, "The media layer could not start", cause))) : foreign7(() => media.start(stream), "media_start_failed", "The media layer could not start")
+              (model.startInitialMedia ? model.startInitialMedia(media, stream) : Effect2.tryPromise({ try: () => media.start(stream), catch: (cause) => cause })).pipe(
+                Effect2.mapError(
+                  (cause) => sfuAccessRejected(cause) ? lifecycleFailure("invalid_access", false, "Media access was rejected. Another tab or device may be using it. Rejoin explicitly to request access again.", cause) : model.startInitialMedia ? lifecycleFailure("media_start_failed", true, "The media layer could not start", cause) : failureFromCause(cause, "media_start_failed", "The media layer could not start")
+                )
+              )
             ),
             trace(
               "start_sync",
@@ -2961,14 +3251,20 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
         Effect2.matchEffect({
           onFailure: (cause) => Effect2.gen(function* () {
             stopStream(stream);
-            const failure2 = failureFromCause(cause, "internal_error", "The Connection could not start");
+            const originalFailure = failureFromCause(cause, "internal_error", "The Connection could not start");
+            const failure2 = yield* resolveMediaRejection(originalFailure);
+            if (failure2.code === "episode_ended" && needsEpisodeCheck(originalFailure)) {
+              span.end({ state: model.state, epoch: model.epoch, outcome: "cancelled", code: "episode_ended" });
+              yield* finishEpisodeEnded();
+              return;
+            }
             model.failure = toFailure(failure2);
             if (model.joinCancelled) {
               span.end({ state: model.state, epoch: model.epoch, outcome: "cancelled", code: "invalid_state" });
               return yield* Effect2.fail(lifecycleFailure("invalid_state", false, "Join was cancelled by Leave"));
             }
             span.end({ state: model.state, epoch: model.epoch, outcome: "failed", code: failure2.code });
-            const retry = !retried && failure2.code === "invalid_access";
+            const retry = !retried && failure2.code === "invalid_access" && !sfuAccessRejected(failure2.cause);
             if (!retry) yield* recordFailure(failure2);
             model.admissionCleanupConfirmed = yield* cancelPendingAdmission();
             yield* stopPorts();
@@ -3113,7 +3409,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
                 }
                 const code = plan.kind === "media" ? "media_recovery_exhausted" : "sync_recovery_exhausted";
                 const transport = model.sync?.getSnapshot().connection.recoveryDiagnostic ?? null;
-                diagnostics.recordRecoveryExhausted({ state: model.state, epoch, code, attempts, transport });
+                diagnostics.recordRecoveryExhausted({ state: model.state, epoch, code, attempts, transport, media: mediaFailure, grantedMedia });
                 if (plan.kind === "sync") {
                   yield* failForSnapshot(lifecycleFailure(code, true, "Connection lost. Rejoin to continue."));
                   return;
@@ -3135,12 +3431,12 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       Effect2.map((now) => ({
         kind,
         deadline: now + boundedInteger(options.recovery?.budgetMs, RECOVERY_BUDGET_MS, 1, 6e4),
-        attempts: boundedInteger(options.recovery?.maxAttempts, MAX_RECOVERY_ATTEMPTS, 1, 10),
-        delays: options.recovery?.backoffMs?.length ? options.recovery.backoffMs : [100, 250, 500]
+        attempts: kind === "sync" ? boundedInteger(options.recovery?.maxAttempts, MAX_RECOVERY_ATTEMPTS, 1, 10) : null,
+        delays: options.recovery?.backoffMs?.length ? options.recovery.backoffMs : kind === "media" ? [1e3, 2e3, 4e3, 6e3] : [100, 250, 500]
       }))
     );
     const attemptRecovery = (plan, mediaAttempt2, syncAttempt, onAttempt) => Effect2.gen(function* () {
-      for (let attempt = 1; attempt <= plan.attempts; attempt += 1) {
+      for (let attempt = 1; plan.attempts === null || attempt <= plan.attempts; attempt += 1) {
         const remaining = plan.deadline - (yield* Clock2.currentTimeMillis);
         if (remaining <= 0) return null;
         onAttempt();
@@ -3151,7 +3447,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
         );
         if (failure2 === null) return attempt;
         if (!failure2.recoverable) return yield* Effect2.fail(failure2);
-        if (attempt < plan.attempts) {
+        if (plan.attempts === null || attempt < plan.attempts) {
           const remaining2 = Math.max(0, plan.deadline - (yield* Clock2.currentTimeMillis));
           yield* Effect2.sleep(Math.min(recoveryDelay(plan, attempt), remaining2));
         }
@@ -3168,10 +3464,13 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
     });
     const recoveryDelay = (plan, attempt) => {
       const delay = plan.delays[Math.min(attempt - 1, plan.delays.length - 1)] ?? 0;
-      return Number.isFinite(delay) ? Math.max(0, delay) : 0;
+      const finiteDelay = Number.isFinite(delay) ? Math.max(0, delay) : 0;
+      const mediaMinimum = [1e3, 2e3, 4e3][attempt - 1] ?? 6e3;
+      return plan.kind === "media" ? Math.min(6e3, Math.max(mediaMinimum, finiteDelay)) : finiteDelay;
     };
     const finishRecovery = (attempt, epoch) => Effect2.gen(function* () {
       if (model.epoch !== epoch || !active(model)) return;
+      mediaFailure = void 0;
       model.recoveryQueued = null;
       model.syncSnapshot = model.sync?.getSnapshot() ?? null;
       model.mediaSnapshot = model.media?.getSnapshot() ?? null;
@@ -3231,7 +3530,20 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       attempt.expiresAt = (yield* Clock2.currentTimeMillis) + MEDIA_RECOVERY_TIMEOUT_MS;
       yield* foreign7(() => media.restart(restartInput), "media_start_failed", "Media transport could not restart");
       yield* waitForMediaLive(media);
-    });
+    }).pipe(
+      Effect2.tapError(
+        (cause) => Effect2.sync(() => {
+          const step = cause.code === "access_unavailable" || cause.code === "invalid_access" ? "access_refresh" : "peer_connection";
+          const snapshotDiagnostic = cause.cause === void 0 && step === "peer_connection" ? model.media?.getSnapshot().failure?.diagnostic : void 0;
+          mediaFailure = { ...snapshotDiagnostic ?? classifyMediaFailure(cause, step), ...grantedMedia };
+        })
+      ),
+      Effect2.tap(
+        () => Effect2.sync(() => {
+          mediaFailure = void 0;
+        })
+      )
+    );
     const syncAttemptExpired = (attempt, sync, now) => {
       if (attempt.client !== sync) {
         attempt.client = sync;
@@ -3273,7 +3585,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
           model.syncBindingCleanup?.();
           model.sync = null;
           const sync2 = yield* Effect2.try({
-            try: () => platform.createSyncClient({ access: grant, token: () => toPromise(access.getSyncToken()), media }),
+            try: () => platform.createSyncClient({ access: grant, token: () => toPromise(access.getSyncToken()), media, onTransportDiagnostic, traceparent: reporter?.traceparent }),
             catch: (cause) => lifecycleFailure("sync_start_failed", true, "The sync layer could not start", cause)
           });
           model.sync = sync2;
@@ -3341,23 +3653,128 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       yield* transition("left");
     });
     const syncNeedsRecovery = (snapshot) => active(model) && (snapshot.connection.phase === "connecting" || snapshot.connection.phase === "recovering" || snapshot.connection.phase === "terminal");
+    const mediaNeedsRecovery = (snapshot) => active(model) && (snapshot.connection.phase === "recovering" || snapshot.connection.phase === "failed" && snapshot.failure?.recoverable === true);
     const recordFailure = (failure2) => Effect2.sync(() => {
-      diagnostics.record({ event: "connection_failed", state: model.state, epoch: model.epoch, code: failure2.code, ...failure2.sync ? { sync: failure2.sync } : {} });
+      diagnostics.record({ event: "connection_failed", state: model.state, epoch: model.epoch, code: failure2.code, ...failure2.sync ? { sync: failure2.sync } : {}, ...mediaFailure ? { media: mediaFailure } : {} });
     });
-    const failForSnapshot = (failure2) => Effect2.gen(function* failForSnapshotEffect() {
+    const finishEpisodeEnded = () => Effect2.gen(function* () {
+      model.episodeEndConfirmed = true;
+      model.syncSnapshot = model.sync?.getSnapshot() ?? model.syncSnapshot;
+      model.episodeEndReason = model.syncSnapshot?.control?.endReason;
+      yield* finishTerminalSnapshot();
+    });
+    const needsEpisodeCheck = (failure2) => failure2.code === "invalid_access" || failure2.cause instanceof CloudflareSFUError && failure2.cause.options.status === 410;
+    const episodeHasEnded = () => {
+      const snapshot = model.sync?.getSnapshot();
+      return model.episodeEndConfirmed || snapshot?.control?.status === "ended" || snapshot?.connection.terminalReason === "episode_ended";
+    };
+    const stopRejectedMedia = () => {
+      model.mediaBindingCleanup?.();
+      model.mediaSnapshot = model.media?.getSnapshot() ?? null;
+    };
+    const waitForPendingEpisodeEnd = Effect2.suspend(() => pendingEpisodeEnd ? Deferred2.await(pendingEpisodeEnd) : Effect2.void);
+    const resolveMediaRejection = (failure2) => {
+      if (!needsEpisodeCheck(failure2)) return Effect2.succeed(failure2);
+      if (failure2.code === "invalid_access") stopRejectedMedia();
+      const epoch = model.epoch;
+      const original = access.currentUnsafe();
+      if (!original) return Effect2.succeed(failure2);
+      return checkMediaRejection(failure2, original, epoch);
+    };
+    const checkMediaRejection = (failure2, original, epoch) => Effect2.gen(function* () {
+      let attempt = 0;
+      let refreshedAfterAuthRejection = false;
+      let rejectedToken = null;
+      while (model.epoch === epoch) {
+        yield* waitForPendingEpisodeEnd;
+        if (episodeHasEnded()) return lifecycleFailure("episode_ended", false, "The Episode has ended");
+        const current = access.currentUnsafe();
+        const grant = sameBindingCredential(current, original);
+        const result = yield* readEpisodeStatus(platform.getEpisodeStatus, grant, rejectedToken);
+        yield* waitForPendingEpisodeEnd;
+        if (episodeHasEnded() || statusIsEnded(result.status)) return lifecycleFailure("episode_ended", false, "The Episode has ended");
+        if (result.status === "active") return failure2;
+        const error2 = result.cause;
+        if (statusCredentialsRejected(error2)) {
+          rejectedToken = grant.media.token;
+          if (!refreshedAfterAuthRejection) {
+            refreshedAfterAuthRejection = true;
+            yield* access.refresh("scheduled_refresh", false).pipe(Effect2.catch(() => Effect2.succeed(null)));
+            continue;
+          }
+        }
+        yield* Effect2.sleep(episodeStatusRetryDelay(attempt++, error2));
+      }
+      return lifecycleFailure("invalid_state", false, "The connection changed");
+    }).pipe(
+      Effect2.timeout(6e4),
+      Effect2.catch(() => Effect2.succeed(episodeHasEnded() ? lifecycleFailure("episode_ended", false, "The Episode has ended") : lifecycleFailure("access_unavailable", true, "Could not confirm Episode status. Rejoin to try again.")))
+    );
+    const commitSnapshotFailure = (failure2) => Effect2.gen(function* () {
+      if (failure2.code === "episode_ended") return yield* finishEpisodeEnded();
       model.failure = toFailure(failure2);
       yield* recordFailure(failure2);
       yield* stopPorts();
       yield* transition("failed");
     });
+    const failForSnapshot = (failure2) => {
+      if (!needsEpisodeCheck(failure2)) return commitSnapshotFailure(failure2);
+      if (failure2.code === "invalid_access") stopRejectedMedia();
+      const scope = model.activeScope;
+      const epoch = model.epoch;
+      const binding = access.currentUnsafe()?.media.clientPayload.connectionId;
+      if (!scope) return Effect2.void;
+      if (rejectionCheck?.epoch === epoch && rejectionCheck.binding === binding) {
+        if (failure2.code === "invalid_access") rejectionCheck.failure = failure2;
+        return publish();
+      }
+      const check = { epoch, binding, failure: failure2 };
+      rejectionCheck = check;
+      const releaseBinding = binding ? Effect2.runSync(access.holdMediaBinding(binding)) : Effect2.void;
+      return Effect2.gen(function* () {
+        if (model.epoch !== epoch || model.activeScope !== scope) return;
+        yield* publish();
+        yield* Effect2.forkIn(
+          resolveMediaRejection(failure2).pipe(
+            Effect2.flatMap(
+              (resolved) => enqueue(
+                Effect2.suspend(() => {
+                  if (model.epoch !== epoch || !active(model)) return Effect2.void;
+                  const finalFailure = resolved === failure2 ? check.failure : resolved;
+                  if (finalFailure === failure2 && failure2.cause instanceof CloudflareSFUError && failure2.cause.options.status === 410) {
+                    rejectionCheck = null;
+                    return recover("media");
+                  }
+                  return commitSnapshotFailure(finalFailure);
+                })
+              )
+            ),
+            Effect2.ensuring(
+              Effect2.gen(function* () {
+                if (rejectionCheck === check) rejectionCheck = null;
+                if (model.activeScope === scope) yield* releaseBinding;
+              })
+            )
+          ),
+          scope
+        );
+      });
+    };
     const handleMediaSnapshot = (media, snapshot) => Effect2.gen(function* () {
       if (media !== model.media || media.getSnapshot() !== snapshot) return;
       if (snapshot === model.mediaSnapshot) return;
+      const phase = mediaDiagnosticPhase(snapshot);
+      if (phase !== mediaDiagnosticPhase(model.mediaSnapshot)) onTransportDiagnostic({ event: "media_state", phase });
       model.mediaSnapshot = snapshot;
-      if (active(model) && (snapshot.connection.phase === "recovering" || snapshot.connection.phase === "failed" && snapshot.failure?.recoverable)) yield* recover("media");
+      if (mediaNeedsRecovery(snapshot)) yield* recover("media");
       yield* publish();
     });
-    const handleMediaFailure = () => model.media ? handleMediaSnapshot(model.media, model.media.getSnapshot()) : Effect2.void;
+    const handleMediaFailure = (media, cause, binding) => {
+      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"));
+      return handleMediaSnapshot(media, media.getSnapshot());
+    };
     const applyAutomaticMediaReplacement = (grant) => Effect2.gen(function* () {
       const media = model.media;
       const scope = model.activeScope;
@@ -3373,7 +3790,12 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
           "media_start_failed",
           "The media client could not apply a replacement access grant"
         ).pipe(
-          (effect) => withinForegroundBudget(effect, MEDIA_RECOVERY_TIMEOUT_MS, lifecycleFailure("media_start_failed", true, "Automatic media replacement did not finish")),
+          (effect) => withinForegroundBudget(effect, MEDIA_RECOVERY_TIMEOUT_MS, lifecycleFailure("media_start_failed", true, "Automatic media replacement did not finish", new CloudflareSFUError("Automatic media replacement deadline expired", "negotiation_timeout"))),
+          Effect2.tapError(
+            (cause) => Effect2.sync(() => {
+              mediaFailure = { ...classifyMediaFailure(cause, "peer_connection"), ...grantedMedia };
+            })
+          ),
           Effect2.match({ onSuccess: () => true, onFailure: () => false }),
           Effect2.flatMap(
             (restarted) => enqueue(
@@ -3407,8 +3829,8 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       const exit = yield* Effect2.exit(Fiber.join(fiber));
       activeJoin = null;
       joinDeferred = null;
-      yield* Deferred.done(work.deferred, exit);
-    }) : Deferred.complete(work.deferred, work.effect).pipe(Effect2.asVoid);
+      yield* Deferred2.done(work.deferred, exit);
+    }) : Deferred2.complete(work.deferred, work.effect).pipe(Effect2.asVoid);
     yield* Effect2.forkScoped(Queue.take(queue).pipe(Effect2.flatMap(process), Effect2.forever));
     const accessReplacementUnsubscribe = yield* access.subscribeAutomaticMediaReplacement((grant) => enqueueBackground(applyAutomaticMediaReplacement(grant)));
     const foregroundUnsubscribe = platform.subscribeForeground?.(() => {
@@ -3418,6 +3840,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
     yield* Effect2.addFinalizer(
       () => Effect2.gen(function* () {
         model.closed = true;
+        reporter?.dispose();
         accessReplacementUnsubscribe();
         foregroundUnsubscribe?.();
         if (activeJoin) yield* Fiber.interrupt(activeJoin);
@@ -3457,15 +3880,33 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       confirmEpisodeEnded: Effect2.sync(() => {
         model.episodeEndConfirmed = true;
       }),
+      runEpisodeEnd: (operation) => Effect2.gen(function* () {
+        const completed = yield* Deferred2.make();
+        const epoch = model.epoch;
+        pendingEpisodeEnd = completed;
+        return yield* operation.pipe(
+          Effect2.tap(
+            () => Effect2.sync(() => {
+              if (model.epoch === epoch) model.episodeEndConfirmed = true;
+            })
+          ),
+          Effect2.ensuring(
+            Effect2.gen(function* () {
+              if (pendingEpisodeEnd === completed) pendingEpisodeEnd = null;
+              yield* Deferred2.succeed(completed, void 0);
+            })
+          )
+        );
+      }),
       join: () => Effect2.suspend(() => {
         if (model.state === "live") return Effect2.void;
-        if (joinDeferred) return Deferred.await(joinDeferred);
+        if (joinDeferred) return Deferred2.await(joinDeferred);
         return Effect2.gen(function* () {
-          const deferred = yield* Deferred.make();
+          const deferred = yield* Deferred2.make();
           model.joinCancelled = false;
           joinDeferred = deferred;
           yield* Queue.offer(queue, { effect: performJoin(), deferred, join: true });
-          return yield* Deferred.await(deferred);
+          return yield* Deferred2.await(deferred);
         });
       }),
       leave: () => Effect2.gen(function* () {
@@ -3491,9 +3932,10 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       ),
       runPortCommand: (operation) => withFreshAccess(operation),
       nowUnsafe: () => clock.currentTimeMillisUnsafe(),
-      scheduleUnsafe: (callback, milliseconds) => platform.clock.setTimeout(callback, milliseconds),
+      scheduleUnsafe: (callback, milliseconds2) => platform.clock.setTimeout(callback, milliseconds2),
       cancelScheduleUnsafe: (handle) => platform.clock.clearTimeout(handle),
-      createId: () => platform.createId?.() ?? `local-${++fallbackIdentifier}`
+      createId: () => platform.createId?.() ?? `local-${++fallbackIdentifier}`,
+      recordTransportDiagnostic: onTransportDiagnostic
     };
   })
 );
@@ -3538,7 +3980,12 @@ function toFailure(value) {
   return Object.freeze({ code: value.code, action: null, recoverable: value.recoverable, message: value.message, ...value.sync ? { sync: value.sync } : {} });
 }
 function accessFailure(value) {
-  return lifecycleFailure(value.code === "access.invalid" ? "invalid_access" : "access_unavailable", value.code === "access.unavailable", value.code === "access.invalid" ? "Access was rejected" : "Could not reach the Space. Check your network and try again.", value.cause);
+  const rejectedMessage = connectionSuperseded(value) ? "Access was rejected. Another tab or device may be using it. Rejoin explicitly to continue." : "Access was rejected";
+  return lifecycleFailure(value.code === "access.invalid" ? "invalid_access" : "access_unavailable", value.code === "access.unavailable", value.code === "access.invalid" ? rejectedMessage : "Could not reach the Space. Check your network and try again.", value.cause);
+}
+function connectionSuperseded(failure2) {
+  const cause = failure2 instanceof ConnectionAccessFailure ? failure2.cause : failure2;
+  return cause instanceof AccessGrantError ? cause.reason === "connection_superseded" : typeof cause === "object" && cause !== null && "code" in cause && cause.code === "participant.connection_superseded";
 }
 function captureFailure(cause) {
   if (cause instanceof ConnectionError && cause.cause === void 0) return lifecycleFailure(cause.code, cause.recoverable, cause.message, cause);
@@ -3594,15 +4041,19 @@ function initialCaptureWarning(failures) {
   return lifecycleFailure(first.failure.code, true, message, first.failure.cause);
 }
 function failureFromCause(cause, code, message) {
+  if (sfuAccessRejected(cause)) return lifecycleFailure("invalid_access", false, "Media access was rejected. Rejoin explicitly to continue.", cause);
   if (cause instanceof ConnectionLifecycleFailure) return cause;
   if (cause instanceof ConnectionAccessFailure) return accessFailure(cause);
-  if (cause instanceof AccessGrantError) return lifecycleFailure("invalid_access", false, "Access was rejected", cause);
+  if (cause instanceof AccessGrantError || connectionSuperseded(cause)) return accessFailure(new ConnectionAccessFailure({ code: "access.invalid", cause }));
   if (cause instanceof ConnectionError) return lifecycleFailure(cause.code, cause.recoverable, cause.message, cause);
   if (cause instanceof DOMException && cause.name === "NotAllowedError") return lifecycleFailure("permission_denied", true, "Media permission was denied", cause);
   return lifecycleFailure(code, true, message, cause);
 }
+function sfuAccessRejected(cause) {
+  return cause instanceof CloudflareSFUError && (cause.options.status === 401 || cause.options.status === 403);
+}
 function accessRejected(cause) {
-  return cause instanceof ConnectionError ? cause.code === "invalid_access" : typeof cause === "object" && cause !== null && "code" in cause && cause.code === "access.invalid";
+  return cause instanceof ConnectionError ? cause.code === "invalid_access" : typeof cause === "object" && cause !== null && "code" in cause && (cause.code === "access.invalid" || cause.code === "participant.connection_superseded");
 }
 function boundedInteger(value, fallback, minimum, maximum) {
   const result = value ?? fallback;
@@ -3617,6 +4068,9 @@ function syncPhase(phase) {
   if (phase === "connecting") return "connecting";
   return "idle";
 }
+function mediaDiagnosticPhase(snapshot) {
+  return snapshot?.connection.peerConnectionState ?? snapshot?.connection.phase;
+}
 function mediaPhase(phase) {
   if (phase === "live") return "healthy";
   if (phase === "recovering") return "recovering";
@@ -3629,6 +4083,7 @@ function syncTerminalFailure(snapshot) {
   const reason = snapshot.connection.terminalReason;
   if (reason === "state_digest_recovery_failed") return lifecycleFailure("state_digest_recovery_failed", false, "The Episode state could not be recovered from an authoritative snapshot");
   if (reason === "episode_ended") return lifecycleFailure("episode_ended", false, "The Episode has ended");
+  if (reason === "stale_participant_generation") return lifecycleFailure("invalid_access", false, "Call access was replaced. Another tab or device may be using it. Rejoin explicitly to request access again.");
   if (reason === "participant_inactive" || reason === "participant_removed" || reason === "stale_participant_generation" || reason === "access_rejected") return lifecycleFailure("invalid_access", false, "Participant access is no longer valid");
   if (reason === "entry_timeout") return lifecycleFailure("sync_start_failed", true, "Call entry was not confirmed in time");
   return lifecycleFailure("sync_start_failed", true, "The Sync transport needs recovery");
@@ -3643,6 +4098,22 @@ function syncStartupFailure(snapshot) {
 function syncAutoRecoverable(snapshot, failure2) {
   return failure2.recoverable && snapshot.connection.terminalReason !== "entry_timeout";
 }
+function statusIsEnded(status) {
+  return status === "ending" || status === "ended";
+}
+function statusCredentialsRejected(error2) {
+  return error2 instanceof EpisodeStatusError && (error2.status === 401 || error2.status === 403);
+}
+function readEpisodeStatus(read, grant, rejectedToken) {
+  if (grant.media.token === rejectedToken) return Effect2.succeed({ status: null, cause: null });
+  return Effect2.tryPromise({
+    try: (signal) => read ? read(grant, signal) : Promise.reject(new Error("Episode status lookup unavailable")),
+    catch: (cause) => cause
+  }).pipe(Effect2.timeout(3e3), Effect2.match({ onSuccess: (status) => ({ status, cause: null }), onFailure: (cause) => ({ status: null, cause }) }));
+}
+function sameBindingCredential(current, original) {
+  return current?.media.clientPayload.connectionId === original.media.clientPayload.connectionId ? current : original;
+}
 
 // src/space-client/errors.ts
 import { Data as Data3 } from "effect";
@@ -3743,7 +4214,7 @@ function connectionErrorCode(code, action) {
 
 // src/space-client/store.ts
 import { Context as Context4, Effect as Effect3, Layer as Layer4, SubscriptionRef as SubscriptionRef2 } from "effect";
-var INTERRUPTED_CONNECTION_PHASES = /* @__PURE__ */ new Set(["unresponsive", "connecting", "recovering"]);
+var INTERRUPTED_CONNECTION_PHASES = /* @__PURE__ */ new Set(["unresponsive", "connecting", "recovering", "stopped"]);
 var empty = (value) => Object.freeze(value);
 var EMPTY = empty({
   connection: empty({ status: "idle", episode: null, lastError: null, episodeEnded: false, removedByHost: false }),
@@ -4406,11 +4877,79 @@ function chatError(message) {
 }
 
 // src/space-client/media-controller.ts
-import { Clock as Clock3, Context as Context6, Deferred as Deferred2, Effect as Effect5, Exit as Exit2, Layer as Layer6, Semaphore } from "effect";
+import { Clock as Clock3, Context as Context6, Deferred as Deferred3, Effect as Effect5, Exit as Exit2, Layer as Layer6, Semaphore } from "effect";
+
+// src/space-client/media-projection-monitor.ts
+var GRACE_MS = 1e4;
+function projectionMatches(observation) {
+  return observation.enabled === observation.projectedEnabled && (!observation.enabled || observation.publicationId === observation.projectedPublicationId);
+}
+var MediaProjectionMonitor = class {
+  #options;
+  #actions = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.#options = options;
+  }
+  observe(source, observation) {
+    let action = this.#actions.get(source);
+    if (action?.revision !== observation.revision) {
+      this.#clear(source);
+      action = { revision: observation.revision, mismatch: null, reported: false, failed: false };
+      this.#actions.set(source, action);
+    }
+    if (action.failed) return;
+    if (projectionMatches(observation)) {
+      if (action.mismatch) this.#options.cancel(action.mismatch.timer);
+      action.mismatch = null;
+      return;
+    }
+    if (action.mismatch) {
+      action.mismatch.observation = observation;
+      if (observation.enabled && this.#options.now() - action.mismatch.startedAt >= GRACE_MS) this.#expire(source, action);
+      return;
+    }
+    const timer = this.#options.schedule(() => this.#expire(source, action), GRACE_MS);
+    action.mismatch = { observation, startedAt: this.#options.now(), timer };
+  }
+  state(source) {
+    const action = this.#actions.get(source);
+    if (action?.failed) return "failed";
+    return action?.mismatch?.observation.enabled ? "requesting" : null;
+  }
+  reset() {
+    for (const source of this.#actions.keys()) this.#clear(source);
+  }
+  #clear(source) {
+    const action = this.#actions.get(source);
+    if (action?.mismatch) this.#options.cancel(action.mismatch.timer);
+    this.#actions.delete(source);
+  }
+  #expire(source, action) {
+    if (this.#actions.get(source) !== action || !action.mismatch) return;
+    const { observation, startedAt } = action.mismatch;
+    action.failed = observation.enabled;
+    if (observation.enabled) this.#options.pause(source, observation.revision);
+    if (!action.reported) {
+      action.reported = true;
+      this.#options.report({
+        event: "media_projection_mismatch",
+        source,
+        publication_state: observation.enabled ? "on" : "off",
+        projection_state: observation.projectedEnabled ? "on" : "off",
+        duration_ms: this.#options.now() - startedAt,
+        attempt: 0,
+        outcome: observation.enabled ? "failed" : "started"
+      });
+    }
+    this.#options.changed();
+  }
+};
+
+// src/space-client/media-controller.ts
 var MEDIA_SOURCES = ["microphone", "camera", "screen"];
 var MEDIA_READY_TIMEOUT_MS = 1e4;
 function sourceWorker(enabled) {
-  return { desired: { enabled, revision: 0, previousEnabled: enabled }, result: { revision: 0, status: "confirmed" }, sentRevision: 0, initialRevision: 0, localEnabled: enabled, pause: null, serverSequence: -1, forcedRevision: null };
+  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 };
 }
 var MediaControllerService = class extends Context6.Service()("@chalk/client/MediaController") {
 };
@@ -4453,6 +4992,7 @@ var MediaControllerRuntime = class {
   #tracks = /* @__PURE__ */ new Map();
   #sources = { microphone: sourceWorker(true), camera: sourceWorker(true), screen: sourceWorker(false) };
   #syncLive = false;
+  #recovering = null;
   #pendingSources = /* @__PURE__ */ new Map();
   #pendingCaptures = /* @__PURE__ */ new Set();
   #readinessChecks = /* @__PURE__ */ new Set();
@@ -4468,6 +5008,8 @@ var MediaControllerRuntime = class {
   #unsubscribeConnection = null;
   #unsubscribeScreenEnded = null;
   #unsubscribePorts = null;
+  #microphoneWatch = null;
+  #projection;
   constructor(connection, store, selection, gates, now, fork) {
     this.#connection = connection;
     this.#store = store;
@@ -4475,6 +5017,16 @@ var MediaControllerRuntime = class {
     this.#gates = gates;
     this.#now = now;
     this.#fork = fork;
+    this.#projection = new MediaProjectionMonitor({
+      now,
+      schedule: connection.scheduleUnsafe,
+      cancel: connection.cancelScheduleUnsafe,
+      changed: () => this.#publish(),
+      report: (event) => connection.recordTransportDiagnostic(event),
+      pause: (source, revision) => {
+        if (this.#ports) this.#pausePublication(this.#ports, source, revision);
+      }
+    });
     this.#unsubscribeConnection = connection.subscribe(() => this.#handleConnectionChange());
     this.#unsubscribeScreenEnded = connection.subscribeScreenEnded(() => this.#handleScreenEnded());
     this.#unsubscribePorts = connection.subscribePorts((ports) => this.#bind(ports));
@@ -4522,7 +5074,7 @@ var MediaControllerRuntime = class {
     }).pipe(Effect5.mapError(normalizeMediaError));
   };
   initialIntent() {
-    return { microphone: this.#sources.microphone.desired.enabled, camera: this.#sources.camera.desired.enabled };
+    return { microphone: this.#hasConsent("microphone"), camera: this.#hasConsent("camera") };
   }
   captureInitial(intent) {
     for (const source of ["microphone", "camera"]) this.#sources[source].initialRevision = this.#sources[source].desired.revision;
@@ -4578,6 +5130,7 @@ var MediaControllerRuntime = class {
     this.#fork(this.#refreshDevices().pipe(Effect5.ignore));
   }
   dispose() {
+    this.#projection.reset();
     for (const check of this.#readinessChecks) check(normalizeMediaError(cancelledCaptureError()));
     this.#cancelCaptures();
     for (const unsubscribe of [this.#unsubscribeMedia, this.#unsubscribeRequests, this.#unsubscribePause, this.#unsubscribeSync]) unsubscribe?.();
@@ -4593,9 +5146,6 @@ var MediaControllerRuntime = class {
     this.#unsubscribePorts = null;
     this.#ports = null;
     this.#resetObservations();
-    this.#screenAudioTrack?.stop();
-    this.#screenAudioTrack = null;
-    for (const track of this.#tracks.values()) track.stop();
     this.#clearTracks();
     this.#clearRequests();
     this.#publish();
@@ -4611,10 +5161,11 @@ var MediaControllerRuntime = class {
         const check = (failure2) => {
           if (failure2) return resume(Effect5.fail(failure2));
           if (this.#sources[source].desired.revision !== revision) return resume(Effect5.void);
-          if (ports && (this.#ports?.sync !== ports.sync || this.#ports.media !== ports.media)) return resume(Effect5.fail(normalizeMediaError(cancelledCaptureError())));
+          if (ports && !this.#canUsePorts(ports)) return resume(Effect5.fail(normalizeMediaError(cancelledCaptureError())));
           const state = this.#connection.getSnapshot().state;
-          if (state === "live" && this.#ports?.sync.getSnapshot().connection.phase === "live" && this.#store.getSnapshot().connection.status === "live") return resume(Effect5.void);
-          if (state !== "joining" && state !== "reconnecting" && state !== "live") resume(Effect5.fail(normalizeMediaError(new V1SyncError("Media enable requires a live call", "not_live"))));
+          const phases = [state, this.#ports?.sync.getSnapshot().connection.phase, this.#store.getSnapshot().connection.status];
+          if (phases.every((phase) => phase === "live")) return resume(Effect5.void);
+          if (!["joining", "reconnecting", "live"].includes(state)) resume(Effect5.fail(normalizeMediaError(new V1SyncError("Media enable requires a live call", "not_live"))));
         };
         this.#readinessChecks.add(check);
         const unsubscribe = this.#connection.subscribe(() => check());
@@ -4644,11 +5195,20 @@ var MediaControllerRuntime = class {
   #pauseTracks(source) {
     const track = this.#track(source);
     if (track) track.enabled = false;
+    for (const publication of this.#ports?.media.getSnapshot().localTracks ?? []) if (publication.source === source) publication.track.enabled = false;
     if (source === "screen" && this.#screenAudioTrack) this.#screenAudioTrack.enabled = false;
   }
+  #retainPause(state, next) {
+    const previous = state.pause;
+    state.pause = previous ? Promise.allSettled([previous, next]).then((results) => {
+      for (const result of results) if (result.status === "rejected") throw result.reason;
+    }) : next;
+    void state.pause.catch(() => void 0);
+  }
   #recordIntent(source, enabled, options) {
     const state = this.#sources[source];
-    const desired = { enabled, revision: state.desired.revision + 1, options, previousEnabled: state.localEnabled };
+    const controlRevision = Math.max(state.serverSequence, this.#ports?.sync.getSnapshot().control?.revision ?? -1);
+    const desired = { enabled, revision: state.desired.revision + 1, controlRevision, options, previousEnabled: state.localEnabled };
     state.desired = desired;
     if (!enabled) {
       state.localEnabled = false;
@@ -4660,12 +5220,7 @@ var MediaControllerRuntime = class {
       const ports = this.#ports;
       if (ports) {
         ports.media.setLocalSourceIntent?.(source, false);
-        const previous = state.pause;
-        const next = this.#beginLocalPause(ports, source);
-        state.pause = previous ? Promise.allSettled([previous, next]).then((results) => {
-          for (const result of results) if (result.status === "rejected") throw result.reason;
-        }) : next;
-        void state.pause.catch(() => void 0);
+        this.#retainPause(state, this.#beginLocalPause(ports, source));
       }
     }
     for (const check of this.#readinessChecks) check();
@@ -4673,6 +5228,7 @@ var MediaControllerRuntime = class {
   }
   #act(source, enabled, options) {
     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(
         Effect5.tapError(
@@ -4757,7 +5313,16 @@ var MediaControllerRuntime = class {
       const state = this.#sources[source];
       if (!intent.enabled && ports.sync.getSnapshot().connection.phase !== "live") return;
       const previous = intent.previousEnabled;
-      if (state.desired.revision === intent.revision) state.result = { revision: intent.revision, status: "failed", cause, cleanup: !intent.enabled || !previous };
+      if (state.desired.revision !== intent.revision) return;
+      state.result = { revision: intent.revision, status: "failed", cause, cleanup: !intent.enabled || !previous };
+      if (state.result.cleanup) {
+        if (intent.enabled && source !== "screen") this.#pausePublication(ports, source, intent.revision);
+        else {
+          state.localEnabled = false;
+          this.#pauseTracks(source);
+          ports.media.setLocalSourceIntent?.(source, false);
+        }
+      }
     });
   }
   #prepareDevice(ports, source, intent) {
@@ -4867,21 +5432,26 @@ var MediaControllerRuntime = class {
       })
     );
   }
-  #assertCurrentIntent(source, revision) {
-    if (this.#sources[source].desired.revision !== revision) throw cancelledCaptureError();
+  #assertCurrentIntent(source, revision, enabling = true) {
+    const state = this.#sources[source];
+    if (state.desired.revision !== revision || enabling && state.forcedRevision === revision) throw cancelledCaptureError();
+  }
+  #hasConsent(source) {
+    const state = this.#sources[source];
+    return state.desired.enabled && state.forcedRevision !== state.desired.revision;
   }
   #resetObservations() {
+    if (this.#connection.getSnapshot().state !== "reconnecting") this.#recovering = null;
     for (const source of MEDIA_SOURCES) {
       const state = this.#sources[source];
       state.result = { revision: state.desired.revision, status: "confirmed" };
       state.pause = null;
       state.serverSequence = -1;
-      state.forcedRevision = null;
     }
   }
   #pauseInitialTracks() {
     for (const source of ["microphone", "camera"]) {
-      const enabled = this.#sources[source].desired.enabled;
+      const enabled = this.#hasConsent(source);
       const track = this.#track(source);
       if (track && !enabled) track.enabled = false;
       this.#sources[source].localEnabled = !!track && enabled;
@@ -4892,15 +5462,14 @@ var MediaControllerRuntime = class {
       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 state = this.#sources[source];
-        track.enabled = state.desired.enabled;
-        if (!state.desired.enabled) {
+        const enabled = this.#hasConsent(source);
+        track.enabled = enabled;
+        if (!enabled) {
           this.#deleteTrack(source);
           if (source === "microphone") track.stop();
         }
-        return state.desired.enabled;
+        return enabled;
       });
-      for (const source of ["microphone", "camera"]) this.#sources[source].sentRevision = revisions[source];
       await media.start(streamFromTracks(tracks));
       for (const source of ["microphone", "camera"]) {
         const state = this.#sources[source];
@@ -4913,11 +5482,10 @@ var MediaControllerRuntime = class {
     const command = this.#mediaAction(
       enabled,
       foreign2(async () => {
-        this.#assertCurrentIntent(source, intent.revision);
+        this.#assertCurrentIntent(source, intent.revision, enabled);
         this.#assertActivePorts(ports, source === "screen" ? "startScreenShare" : source === "camera" ? "setCameraEnabled" : "setMicrophoneEnabled");
-        const state = this.#sources[source];
-        state.sentRevision = intent.revision;
-        await (source === "microphone" ? ports.sync.setMicrophoneEnabled(enabled) : source === "camera" ? ports.sync.setCameraEnabled(enabled) : ports.sync.setScreenShareEnabled(enabled));
+        const send = source === "microphone" ? ports.sync.setMicrophoneEnabled : source === "camera" ? ports.sync.setCameraEnabled : ports.sync.setScreenShareEnabled;
+        await send.call(ports.sync, enabled);
       }).pipe(
         Effect5.andThen(enabled && source !== "screen" ? this.#waitForLive(source, intent.revision, ports) : Effect5.void),
         Effect5.tap(() => Effect5.try({ try: () => this.#assertActivePorts(ports, source === "screen" ? "startScreenShare" : source === "camera" ? "setCameraEnabled" : "setMicrophoneEnabled"), catch: (cause) => cause }))
@@ -4927,10 +5495,19 @@ var MediaControllerRuntime = class {
   }
   #reconcileIntents() {
     const live = this.#connection.getSnapshot().state === "live" && this.#ports?.sync.getSnapshot().connection.phase === "live";
+    if (this.#syncLive && !live) this.#rememberRecoveryIntents();
     const resumed = live && !this.#syncLive;
     this.#syncLive = live;
     if (!resumed) return;
-    for (const source of MEDIA_SOURCES) this.#fork(this.#serialize(source, this.#work(source)).pipe(Effect5.ignore));
+    if (this.#ports) this.#pauseRecoveredIntents(this.#ports, this.#ports.sync.getSnapshot());
+    this.#resumePendingActions();
+  }
+  #resumePendingActions() {
+    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));
+    }
   }
   #clearScreenAudio(media) {
     return foreign2(() => media.clearPreparedLocalTrack("screen_audio")).pipe(
@@ -4943,7 +5520,8 @@ var MediaControllerRuntime = class {
     );
   }
   #beginLocalPause(ports, source) {
-    const pause = Effect5.runPromise(this.#localTarget(ports, source, false));
+    this.#sources[source].pausedPublicationId = ports.media.getSnapshot().localTracks.find((item) => item.source === source)?.publicationId ?? null;
+    const pause = ports.media.closeForcedLocalPublication ? Promise.resolve().then(() => ports.media.closeForcedLocalPublication(source)) : Effect5.runPromise(this.#localTarget(ports, source, false));
     void pause.catch(() => void 0);
     return pause;
   }
@@ -5012,18 +5590,53 @@ var MediaControllerRuntime = class {
   #setTrack(source, track) {
     if (source !== "camera") {
       this.#tracks.set(source, track);
+      if (source === "microphone") this.#watchMicrophone(track);
       return;
     }
     const state = this.#camera;
     if (!("owner" in state)) throw cancelledCaptureError();
     if (state.status === "live" && state.track !== track) throw cancelledCaptureError();
-    const onEnded = () => {
-      if (this.#camera.status === "live" && this.#camera.track === track) this.#transitionCamera({ status: "ended" });
-    };
+    const onEnded = () => this.#handleCameraEnded(track);
     this.#transitionCamera({ status: "live", owner: state.owner, track, publication: this.#ports?.media ?? "initial", onEnded });
   }
+  #handleCameraEnded(track) {
+    const state = this.#camera;
+    if (state.status !== "live" || state.track !== track) return;
+    if (this.#ports && state.publication === this.#ports.media) this.#pausePublication(this.#ports, "camera", this.#sources.camera.desired.revision);
+    this.#transitionCamera({ status: "ended" });
+  }
+  #watchMicrophone(track) {
+    if (this.#microphoneWatch?.track === track) return;
+    this.#microphoneWatch?.unsubscribe();
+    this.#microphoneWatch = null;
+    if (!track) return;
+    const changed = () => {
+      if (this.#microphoneWatch?.track !== track) return;
+      if (track.muted || track.readyState === "ended") {
+        track.enabled = false;
+        const state = this.#sources.microphone;
+        if (this.#ports) this.#pausePublication(this.#ports, "microphone", state.desired.revision);
+        else {
+          state.forcedRevision = state.desired.revision;
+          state.localEnabled = false;
+        }
+      }
+      this.#publish();
+    };
+    for (const event of ["mute", "unmute", "ended"]) track.addEventListener(event, changed);
+    this.#microphoneWatch = {
+      track,
+      unsubscribe: () => {
+        for (const event of ["mute", "unmute", "ended"]) track.removeEventListener(event, changed);
+      }
+    };
+    if (track.muted || track.readyState === "ended") changed();
+  }
   #deleteTrack(source) {
     if (source !== "camera") {
+      if (source === "microphone") {
+        this.#watchMicrophone(null);
+      }
       this.#tracks.delete(source);
       return;
     }
@@ -5034,6 +5647,7 @@ var MediaControllerRuntime = class {
     } else this.#transitionCamera({ status: "ended" });
   }
   #clearTracks() {
+    this.#watchMicrophone(null);
     this.#tracks.clear();
     this.#transitionCamera({ status: "idle" });
   }
@@ -5076,11 +5690,11 @@ var MediaControllerRuntime = class {
   #beginCameraCapture(acquire) {
     const abort = new AbortController();
     const owner = {
-      result: Deferred2.makeUnsafe(),
+      result: Deferred3.makeUnsafe(),
       references: 0,
       cancel: () => {
         abort.abort();
-        Deferred2.doneUnsafe(owner.result, Effect5.fail(cancelledCaptureError()));
+        Deferred3.doneUnsafe(owner.result, Effect5.fail(cancelledCaptureError()));
       }
     };
     this.#transitionCamera({ status: "capturing", owner });
@@ -5094,9 +5708,7 @@ var MediaControllerRuntime = class {
                 track.stop();
                 throw cancelledCaptureError();
               }
-              const onEnded = () => {
-                if (this.#camera.status === "live" && this.#camera.owner === owner) this.#transitionCamera({ status: "ended" });
-              };
+              const onEnded = () => this.#handleCameraEnded(track);
               this.#transitionCamera({ status: "live", owner, track, publication: state.status === "live" ? state.publication : null, onEnded });
               if (track.readyState !== "live") {
                 this.#transitionCamera({ status: "ended" });
@@ -5106,7 +5718,7 @@ var MediaControllerRuntime = class {
             catch: (cause) => cause
           })
         ),
-        Effect5.onExit((exit) => Deferred2.done(owner.result, exit)),
+        Effect5.onExit((exit) => Deferred3.done(owner.result, exit)),
         Effect5.ignore
       )
     );
@@ -5122,7 +5734,7 @@ var MediaControllerRuntime = class {
       const current = this.#camera;
       if (owner.references === 0 && "owner" in current && current.owner === owner && (current.status !== "live" || current.publication === null)) this.#transitionCamera({ status: "ended" });
     };
-    return Deferred2.await(owner.result).pipe(
+    return Deferred3.await(owner.result).pipe(
       Effect5.flatMap((track) => track.readyState === "live" ? Effect5.succeed({ track, release }) : Effect5.fail(cancelledCaptureError())),
       Effect5.onExit(
         (exit) => Effect5.sync(() => {
@@ -5152,9 +5764,11 @@ var MediaControllerRuntime = class {
     return Effect5.suspend(() => {
       let cancelled = false;
       let captured = null;
+      const cancellation = Deferred3.makeUnsafe();
       const cancel = () => {
         cancelled = true;
         stopStream(captured);
+        Deferred3.doneUnsafe(cancellation, Effect5.fail(cancelledCaptureError()));
       };
       this.#pendingCaptures.add(cancel);
       signal?.addEventListener("abort", cancel, { once: true });
@@ -5163,7 +5777,7 @@ var MediaControllerRuntime = class {
         if (cancelled) throw cancelledCaptureError();
         const stream = await operation();
         captured = stream;
-        if (cancelled) {
+        if (cancelled || this.#ports?.media.getSnapshot().connection.phase === "stopped") {
           stopStream(stream);
           throw cancelledCaptureError();
         }
@@ -5171,6 +5785,7 @@ var MediaControllerRuntime = class {
       }).pipe(
         Effect5.mapError(onCaptureError),
         Effect5.flatMap(use),
+        Effect5.raceFirst(Deferred3.await(cancellation)),
         Effect5.tap(() => cancelled ? Effect5.fail(cancelledCaptureError()) : Effect5.void),
         Effect5.onExit(
           (exit) => Effect5.sync(() => {
@@ -5186,6 +5801,9 @@ var MediaControllerRuntime = class {
     this.#transitionCamera({ status: "ended" });
     for (const cancel of this.#pendingCaptures) cancel();
     this.#pendingCaptures.clear();
+    this.#screenAudioTrack?.stop();
+    this.#screenAudioTrack = null;
+    for (const track of this.#tracks.values()) track.stop();
   }
   #captureSource(source, signal) {
     return this.#captureStream(
@@ -5242,42 +5860,46 @@ var MediaControllerRuntime = class {
     const failure2 = isPermissionDenied(input.cause) || captureWasUnavailable ? captureError(input.cause, input.action, input.permissionMessage) : input.cause;
     return rollback.pipe(Effect5.andThen(Effect5.sync(() => this.#publish())), Effect5.andThen(Effect5.fail(failure2)));
   }
+  #canUsePorts(ports) {
+    return this.#ports?.sync === ports.sync && this.#ports.media === ports.media && ports.media.getSnapshot().connection.phase !== "stopped";
+  }
   #assertActivePorts(ports, action) {
-    if (this.#connection.getSnapshot().state === "live" && this.#ports?.sync === ports.sync && this.#ports.media === ports.media) return;
+    if (this.#connection.getSnapshot().state === "live" && this.#canUsePorts(ports)) return;
     throw new ConnectionError({ code: "invalid_state", action, recoverable: false, message: `${action} belongs to an inactive connection` });
   }
   #pausePublication(ports, source, revision) {
     const state = this.#sources[source];
-    if (state.desired.revision !== revision || ports.sync.getSnapshot().control?.status === "ended") return;
+    if (state.desired.revision !== revision || state.forcedRevision === revision || ports.sync.getSnapshot().control?.status === "ended") return;
     state.forcedRevision = revision;
     state.localEnabled = false;
     this.#pauseTracks(source);
     ports.media.setLocalSourceIntent?.(source, false);
-    if (ports.media.closeForcedLocalPublication) this.#fork(foreign2(() => ports.media.closeForcedLocalPublication(source)).pipe(Effect5.ignore));
+    this.#retainPause(state, this.#beginLocalPause(ports, source));
     this.#publish();
   }
   #bind(ports) {
+    if (ports?.media.getSnapshot().connection.phase === "stopped") this.#cancelCaptures();
     if (ports && this.#ports?.sync === ports.sync && this.#ports.media === ports.media) return;
+    this.#rememberRecoveryIntents();
     for (const unsubscribe of [this.#unsubscribeMedia, this.#unsubscribeRequests, this.#unsubscribePause, this.#unsubscribeSync]) unsubscribe?.();
     this.#unsubscribeMedia = null;
     this.#unsubscribeRequests = null;
     this.#unsubscribePause = null;
     this.#unsubscribeSync = null;
     this.#ports = ports;
+    this.#projection.reset();
     this.#syncLive = false;
     this.#bindCamera(ports);
     if (!ports) {
       this.#resetObservations();
       this.#cancelCaptures();
-      this.#screenAudioTrack?.stop();
-      this.#screenAudioTrack = null;
-      for (const track of this.#tracks.values()) track.stop();
       this.#clearTracks();
       this.#clearRequests();
       this.#publish();
       return;
     }
     this.#unsubscribeMedia = ports.media.subscribe(() => {
+      if (ports.media.getSnapshot().connection.phase === "stopped") this.#cancelCaptures();
       this.#applyRemoteMediaState(ports, ports.sync.getSnapshot());
       this.#publish();
     });
@@ -5292,41 +5914,27 @@ var MediaControllerRuntime = class {
       const state = this.#sources[pause.source];
       if (pause.revision <= state.serverSequence) return;
       state.serverSequence = pause.revision;
-      this.#pausePublication(ports, pause.source, state.sentRevision);
+      if (pause.revision > state.desired.controlRevision) this.#pausePublication(ports, pause.source, state.desired.revision);
     }) ?? null;
   }
-  #rememberPublications(snapshot) {
-    const publications = /* @__PURE__ */ new Map();
-    const own = (snapshot.media?.items ?? []).filter((item) => item.participantId === snapshot.participantId && item.enabled && item.publicationId !== null);
-    for (const item of own) {
-      if (item.source === "screen_audio" || item.publicationId === null) continue;
-      const state = this.#sources[item.source];
-      if (state.localEnabled && state.sentRevision === state.desired.revision) publications.set(item.source, { revision: state.sentRevision, publicationId: item.publicationId });
-    }
-    return publications;
+  #rememberRecoveryIntents() {
+    if (!this.#ports) return;
+    this.#recovering ??= new Map(MEDIA_SOURCES.filter((source) => this.#sources[source].desired.enabled).map((source) => [source, this.#sources[source].desired.revision]));
   }
-  #pauseLostPublications(ports, snapshot, publications) {
-    for (const [source, previous] of publications) {
+  #pauseRecoveredIntents(ports, snapshot) {
+    const recovering = this.#recovering;
+    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 || !current.enabled && (current.publicationId === previous.publicationId || current.publicationId === null)) this.#pausePublication(ports, source, previous.revision);
+      if (!current?.enabled) this.#pausePublication(ports, source, revision);
     }
   }
   #subscribeSync(ports) {
-    let recovering = /* @__PURE__ */ new Map();
-    let lastLive = ports.sync.getSnapshot();
-    let wasLive = lastLive.connection.phase === "live";
     return ports.sync.subscribe((snapshot) => {
-      const live = snapshot.connection.phase === "live";
-      if (wasLive && !live) recovering = this.#rememberPublications(lastLive);
-      if (live && !wasLive) {
-        this.#pauseLostPublications(ports, snapshot, recovering);
-        recovering.clear();
-      }
-      if (live) lastLive = snapshot;
-      wasLive = live;
       this.#removeRequestsFromMissingParticipants(snapshot);
       this.#applyRemoteMediaState(ports, snapshot);
       this.#reconcileIntents();
+      this.#publish();
     });
   }
   #bindCamera(ports) {
@@ -5400,14 +6008,64 @@ var MediaControllerRuntime = class {
     if (!track || this.#track("screen") !== track) return;
     this.#fork(this.#stopScreen().pipe(Effect5.ignore));
   }
+  #observeProjections() {
+    const ports = this.#ports;
+    this.#watchMicrophone(ports?.media.getSnapshot().localTracks.find((item) => item.source === "microphone")?.track ?? this.#track("microphone") ?? null);
+    if (!ports) {
+      this.#projection.reset();
+      return;
+    }
+    this.#enforcePause(ports, "microphone");
+    this.#enforcePause(ports, "camera");
+    if (!this.#syncLive) {
+      this.#projection.reset();
+      return;
+    }
+    this.#observeProjection(ports, "microphone");
+    this.#observeProjection(ports, "camera");
+  }
+  #enforcePause(ports, source) {
+    const publication = ports.media.getSnapshot().localTracks.find((item) => item.source === source);
+    const state = this.#sources[source];
+    if (!this.#hasConsent(source) && publication?.enabled && state.pausedPublicationId !== publication.publicationId) {
+      this.#pauseTracks(source);
+      ports.media.setLocalSourceIntent?.(source, false);
+      this.#retainPause(state, this.#beginLocalPause(ports, source));
+    }
+  }
+  #observeProjection(ports, source) {
+    const sync = ports.sync.getSnapshot();
+    const state = this.#sources[source];
+    const publication = ports.media.getSnapshot().localTracks.find((item) => item.source === source);
+    const projection = sync.media?.items.find((item) => item.participantId === sync.participantId && item.source === source) ?? { enabled: false, publicationId: null };
+    this.#projection.observe(source, {
+      revision: state.desired.revision,
+      publicationId: publication?.publicationId ?? null,
+      enabled: livePublication(publication),
+      projectedEnabled: projection.enabled,
+      projectedPublicationId: projection.publicationId
+    });
+  }
+  #confirmedLocal(source) {
+    const snapshot = this.#ports?.media.getSnapshot();
+    if (snapshot?.connection.phase === "stopped") return { source, state: "unavailable", track: null };
+    const publication = snapshot?.localTracks.find((item) => item.source === source);
+    const sync = this.#ports?.sync.getSnapshot();
+    const projected = sync?.media?.items.some((item) => item.participantId === sync.participantId && item.source === source && item.enabled && item.publicationId === publication?.publicationId) ?? false;
+    const confirmed = this.#syncLive && livePublication(publication) && projected;
+    const pending = this.#pendingSources.has(source) || this.#connection.getSnapshot().state === "joining";
+    const track = publication?.track ?? this.#track(source) ?? null;
+    return { source, track, state: confirmedLocalMediaState(track, this.#hasConsent(source), pending, confirmed, this.#syncLive, this.#projection.state(source)) };
+  }
   #publish() {
     const current = this.#store.getSnapshot();
     const snapshot = this.#ports?.media.getSnapshot();
     const state = this.#connection.getSnapshot().state;
+    this.#observeProjections();
     const local = Object.freeze({
-      microphone: localMedia("microphone", this.#localTracks(), snapshot, this.#sources.microphone.localEnabled, state, this.#pendingSources.has("microphone") && this.#sources.microphone.desired.enabled),
-      camera: localMedia("camera", this.#localTracks(), snapshot, this.#sources.camera.localEnabled, state, this.#pendingSources.has("camera") && this.#sources.camera.desired.enabled),
-      screen: localMedia("screen", this.#localTracks(), snapshot, false, state, this.#pendingSources.has("screen") && this.#sources.screen.desired.enabled)
+      microphone: this.#confirmedLocal("microphone"),
+      camera: this.#confirmedLocal("camera"),
+      screen: screenLocalMedia(this.#track("screen") ?? null, snapshot, state, this.#pendingSources.has("screen") && this.#sources.screen.desired.enabled)
     });
     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({
@@ -5424,6 +6082,18 @@ var MediaControllerRuntime = class {
     if (!sameMediaSlice(current.media, media)) this.#store.updateMedia(media);
   }
 };
+function liveTrack(track) {
+  return track.enabled && track.readyState === "live" && !track.muted;
+}
+function livePublication(publication) {
+  return !!publication?.enabled && liveTrack(publication.track);
+}
+function confirmedLocalMediaState(track, desired, pending, confirmed, live, convergence) {
+  if (!desired) return convergence === "failed" ? "failed" : "disabled";
+  if (convergence) return convergence;
+  if (!live && track && liveTrack(track)) return "requesting";
+  return confirmed ? "enabled" : pending ? "requesting" : "disabled";
+}
 function cancelledCaptureError() {
   return new ConnectionError({ code: "invalid_state", action: null, recoverable: false, message: "Media capture was cancelled before its result could be used" });
 }
@@ -5432,57 +6102,35 @@ function foreign2(operation) {
 }
 function selectInitialTracks(stream, intent) {
   const tracks = stream.getTracks();
-  const microphone = initialTrackFor(tracks, intent.microphone, "audio");
-  const camera = initialTrackFor(tracks, intent.camera, "video");
-  const selected = new Set(initialTracks(microphone, camera));
-  for (const track of tracks) if (!selected.has(track)) track.stop();
-  if (missingInitialTrack(intent, microphone, camera)) {
-    for (const track of selected) track.stop();
+  const selected = /* @__PURE__ */ new Map();
+  for (const [source, kind] of [
+    ["microphone", "audio"],
+    ["camera", "video"]
+  ]) {
+    if (!intent[source]) continue;
+    const track = tracks.find((track2) => track2.kind === kind);
+    if (track) selected.set(source, track);
+  }
+  const retained = new Set(selected.values());
+  for (const track of tracks) if (!retained.has(track)) track.stop();
+  if (selected.size !== Number(intent.microphone) + Number(intent.camera)) {
+    for (const track of retained) track.stop();
     throw new TypeError("Media capture did not return every requested track");
   }
-  return new Map(initialTrackEntries(microphone, camera));
-}
-function initialTrackFor(tracks, enabled, kind) {
-  if (!enabled) return void 0;
-  return tracks.find((track) => track.kind === kind);
-}
-function initialTracks(microphone, camera) {
-  return [microphone, camera].filter((track) => track !== void 0);
-}
-function missingInitialTrack(intent, microphone, camera) {
-  return intent.microphone && !microphone || intent.camera && !camera;
-}
-function initialTrackEntries(microphone, camera) {
-  const entries = [];
-  if (microphone) entries.push(["microphone", microphone]);
-  if (camera) entries.push(["camera", camera]);
-  return entries;
+  return selected;
 }
-function localMedia(source, tracks, snapshot, intended, connectionState, pending) {
-  const track = tracks.get(source) ?? null;
-  const publication = snapshot?.localTracks.find((candidate) => candidate.source === source);
-  if (pending) return Object.freeze({ source, state: "requesting", track });
-  if (locallyMuted(intended, track, publication)) return Object.freeze({ source, state: "disabled", track });
-  if (publication?.enabled) return Object.freeze({ source, state: "enabled", track });
-  if (publication && connectionState === "live") return Object.freeze({ source, state: "disabled", track });
-  return Object.freeze({ source, state: localMediaState(source, track, intended, connectionState), track });
+function screenLocalMedia(track, snapshot, connectionState, pending) {
+  if (snapshot?.connection.phase === "stopped") return Object.freeze({ source: "screen", state: "unavailable", track: null });
+  const publication = snapshot?.localTracks.find((candidate) => candidate.source === "screen");
+  return Object.freeze({ source: "screen", state: pending ? "requesting" : screenLocalMediaState(track, publication?.enabled, connectionState), track });
 }
-function locallyMuted(intended, track, publication) {
-  return !intended && track?.enabled === false && publication?.enabled === false;
-}
-function localMediaState(source, track, intended, connectionState) {
-  if (!mediaIsDesired(source, track, intended)) return inactiveLocalMediaState(connectionState, track);
-  if (connectionState === "joining" || track) return "requesting";
-  return activeLocalMediaState(connectionState);
-}
-function mediaIsDesired(source, track, intended) {
-  return source === "screen" ? track !== null : intended;
-}
-function inactiveLocalMediaState(connectionState, track) {
-  return connectionState === "live" || connectionState === "reconnecting" || track ? "disabled" : "unavailable";
-}
-function activeLocalMediaState(connectionState) {
-  return connectionState === "failed" || connectionState === "live" || connectionState === "reconnecting" ? "failed" : "unavailable";
+function screenLocalMediaState(track, enabled, connectionState) {
+  if (enabled === false) {
+    if (track?.enabled === false || connectionState === "live") return "disabled";
+  }
+  if (enabled) return "enabled";
+  if (track) return "requesting";
+  return connectionState === "live" || connectionState === "reconnecting" ? "disabled" : "unavailable";
 }
 function sameMediaSlice(left, right) {
   if (left.selection !== right.selection || !sameDevices(left.devices, right.devices)) return false;
@@ -6489,7 +7137,7 @@ var SpaceClientCore = class {
     return this.#connection.leave().pipe(Effect12.mapError(normalizeClientError));
   }
   endEpisode() {
-    return this.#connection.runCommand(({ sync }) => foreign6(() => sync.endEpisode()).pipe(Effect12.tap(() => this.#connection.confirmEpisodeEnded))).pipe(Effect12.tap(() => this.#connection.leave())).pipe(Effect12.asVoid, Effect12.mapError(normalizeClientError));
+    return this.#connection.runCommand(({ sync }) => this.#connection.runEpisodeEnd(foreign6(() => sync.endEpisode()))).pipe(Effect12.tap(() => this.#connection.leave())).pipe(Effect12.asVoid, Effect12.mapError(normalizeClientError));
   }
   extendEpisode(minutes) {
     return this.#connection.runCommand(({ sync }) => foreign6(() => sync.extendEpisode(minutes))).pipe(Effect12.asVoid, Effect12.mapError(normalizeClientError));
@@ -6565,7 +7213,14 @@ function foreign6(operation) {
 }
 async function fetchAccessGrant2(input) {
   if (input.platform.connectionAccess) return input.platform.connectionAccess(input.request);
-  return input.options.getAccess({ space: input.options.space.trim(), reason: accessReason(input.request?.reason), replaceMediaConnection: input.request?.replaceMediaConnection ?? false, signal: input.request?.signal });
+  return input.options.getAccess({
+    space: input.options.space.trim(),
+    reason: accessReason(input.request?.reason),
+    replaceMediaConnection: input.request?.replaceMediaConnection ?? false,
+    expectedMediaConnectionId: input.request?.expectedMediaConnectionId,
+    currentMediaToken: input.request?.replaceMediaConnection ? input.request.currentMediaToken : void 0,
+    signal: input.request?.signal
+  });
 }
 function accessReason(reason) {
   if (reason === void 0 || reason === "join") return "join";