@q9labsai/chalk-client 4.1.16 → 4.1.17

package/dist/{chunk-BD7FRQ67.js → chunk-AUQTQOLR.js}

@@ -1,33 +1,33 @@
-import {
-  CloudflareRTKClient,
-  CloudflareSFUClient,
-  createCloudflareSFUHTTPTransport,
-  describeMediaCaptureError
-} from "./chunk-O7WTAXAY.js";
 import {
   AccessGrantError,
   requireParsedAccessGrant,
   validEpisodeDiagnosticCredential
-} from "./chunk-M3S7HNQF.js";
-import {
-  normalizeTelemetryAttributes
-} from "./chunk-EWTITNJ3.js";
+} from "./chunk-ZRMGKMX4.js";
 import {
-  createTraceContext,
-  journeyHeaders,
-  parseTraceparent
-} from "./chunk-HW5TTZL2.js";
+  CloudflareRTKClient,
+  CloudflareSFUClient,
+  createCloudflareSFUHTTPTransport,
+  describeMediaCaptureError
+} from "./chunk-2DZUHV6I.js";
 import {
   ChatAttachmentMimeTypeSchema,
   V1SyncError,
   createBrowserSyncLifecycle,
   createBrowserWebSocketFactory,
   createV1SyncClient
-} from "./chunk-OKIL2ELF.js";
+} from "./chunk-CZUJNAUI.js";
 import {
   recordInitialConnection,
   recordReconnect
 } from "./chunk-RCDXIDCN.js";
+import {
+  normalizeTelemetryAttributes
+} from "./chunk-EWTITNJ3.js";
+import {
+  createTraceContext,
+  journeyHeaders,
+  parseTraceparent
+} from "./chunk-HW5TTZL2.js";
 
 // src/access/manager.ts
 import { Clock, Context, Data, Effect, Layer, SynchronizedRef } from "effect";
@@ -154,6 +154,20 @@ var ConnectionPlatformService = class extends Context2.Service()("@chalk/client/
 var makeConnectionPlatformLayer = (dependencies) => Layer2.succeed(ConnectionPlatformService, dependencies);
 var makeFakeConnectionPlatformLayer = makeConnectionPlatformLayer;
 
+// src/whiteboard/types.ts
+var ChalkWhiteboardV1Error = class extends Error {
+  operation;
+  code;
+  recoverable;
+  constructor(failure3, options) {
+    super(failure3.message, options);
+    this.name = "ChalkWhiteboardV1Error";
+    this.operation = failure3.operation;
+    this.code = failure3.code;
+    this.recoverable = failure3.recoverable;
+  }
+};
+
 // src/collaboration/types.ts
 var CHALK_CHAT_ATTACHMENT_LIMITS = {
   maximumPerMessage: 5,
@@ -301,20 +315,6 @@ function isAllowedMimeType(value) {
   return typeof value === "string" && CHALK_CHAT_ATTACHMENT_MIME_TYPES.includes(value);
 }
 
-// src/whiteboard/types.ts
-var ChalkWhiteboardV1Error = class extends Error {
-  operation;
-  code;
-  recoverable;
-  constructor(failure3, options) {
-    super(failure3.message, options);
-    this.name = "ChalkWhiteboardV1Error";
-    this.operation = failure3.operation;
-    this.code = failure3.code;
-    this.recoverable = failure3.recoverable;
-  }
-};
-
 // src/whiteboard/file-http-transport.ts
 function createChalkWhiteboardV1FileHttpTransport(options) {
   const fetchImplementation = options.fetch ?? globalThis.fetch;
@@ -1304,6 +1304,8 @@ var ChalkWhiteboardV1Client = class {
     void this.#requestSnapshot().catch(() => void 0);
   }
   #requestSnapshot() {
+    const active2 = this.#snapshots.values().next().value;
+    if (active2) return active2.promise;
     const requestId = this.#nextId();
     const frame = { type: "request_snapshot", request_id: requestId };
     encodeWhiteboardV1ClientFrame(frame);
@@ -1311,7 +1313,7 @@ var ChalkWhiteboardV1Client = class {
     const promise = new Promise((resolve, reject) => {
       deferred = { resolve, reject, settled: false };
     });
-    this.#snapshots.set(requestId, { requestId, deferred, pages: /* @__PURE__ */ new Map() });
+    this.#snapshots.set(requestId, { requestId, deferred, promise, pages: /* @__PURE__ */ new Map() });
     this.#send(frame);
     return promise;
   }
@@ -1725,11 +1727,25 @@ function createChalkWhiteboardV1Client(options) {
   });
 }
 
+// src/connection/types.ts
+var ConnectionError = class extends Error {
+  code;
+  action;
+  recoverable;
+  constructor(failure3, options) {
+    super(failure3.message, options);
+    this.name = "ConnectionError";
+    this.code = failure3.code;
+    this.action = failure3.action;
+    this.recoverable = failure3.recoverable;
+  }
+};
+
 // src/connection/media-devices.ts
 function createBrowserMediaDevices(mediaDevices = globalThis.navigator?.mediaDevices) {
   return {
     async getUserMedia(constraints) {
-      if (!mediaDevices?.getUserMedia) throw new DOMException("Browser media capture is unavailable", "NotSupportedError");
+      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);
     },
     async getDisplayMedia(constraints) {
@@ -1911,6 +1927,26 @@ function whiteboardURL(syncURL) {
   return url.toString();
 }
 
+// src/foreground-deadline.ts
+function scheduleForegroundDeadline(clock, milliseconds, expired) {
+  let timer;
+  let cancelled = false;
+  const arm = () => {
+    const started = clock.now();
+    timer = clock.setTimeout(() => {
+      if (cancelled) return;
+      const elapsed = clock.now() - started;
+      if (typeof document !== "undefined" && document.visibilityState === "hidden" || elapsed > milliseconds + 2e3 || elapsed < 0) arm();
+      else expired();
+    }, milliseconds);
+  };
+  arm();
+  return () => {
+    cancelled = true;
+    clock.clearTimeout(timer);
+  };
+}
+
 // 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";
 
@@ -1967,26 +2003,15 @@ var ConnectionDiagnostics = class {
   }
 };
 
-// src/connection/types.ts
-var ConnectionError = class extends Error {
-  code;
-  action;
-  recoverable;
-  constructor(failure3, options) {
-    super(failure3.message, options);
-    this.name = "ConnectionError";
-    this.code = failure3.code;
-    this.action = failure3.action;
-    this.recoverable = failure3.recoverable;
-  }
-};
-
 // src/connection/lifecycle.ts
+var MEDIA_RECOVERY_TIMEOUT_MS = 6e4;
 var START_TIMEOUT_MS = 1e4;
 var LEAVE_TIMEOUT_MS = 5e3;
 var RECOVERY_BUDGET_MS = 1e4;
 var MAX_RECOVERY_ATTEMPTS = 3;
 var REFRESH_RETRY_MS = 5e3;
+var RECONNECT_GRACE_MS = 250;
+var BACKGROUND_RETRY_MAX_MS = 6e4;
 var ConnectionLifecycleFailure = class extends Data2.TaggedError("ConnectionLifecycleFailure") {
 };
 var ConnectionLifecycleService = class extends Context3.Service()("@chalk/client/ConnectionLifecycle") {
@@ -1997,7 +2022,7 @@ var makeConnectionLifecycleLayer = (options) => {
   const access = makeConnectionAccessLayer(
     (request) => Effect2.tryPromise({
       try: (signal) => Promise.resolve(options.access(request ? { ...request, signal } : void 0)),
-      catch: (cause) => new ConnectionAccessFailure({ code: "access.unavailable", cause })
+      catch: (cause) => cause instanceof ConnectionAccessFailure ? cause : new ConnectionAccessFailure({ code: accessRejected(cause) ? "access.invalid" : "access.unavailable", cause })
     }),
     options.accessRefreshWindowMs
   );
@@ -2032,6 +2057,8 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
     let joinDeferred = null;
     let activeJoin = null;
     let fallbackIdentifier = 0;
+    let emittedPorts = null;
+    let foregroundRecoveryDeadline = 0;
     const model = {
       state: "idle",
       sync: null,
@@ -2044,21 +2071,51 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
         try: () => intent.microphone || intent.camera ? platform.mediaDevices.getUserMedia({ audio: intent.microphone, video: intent.camera }) : Promise.resolve(streamFromTracks([])),
         catch: (cause) => cause
       }),
+      initialMediaIntent: null,
       intent: { microphone: options.initialMicrophoneEnabled ?? true, camera: options.initialCameraEnabled ?? true },
       episodeEndConfirmed: false,
       activeScope: null,
       syncBindingCleanup: null,
       mediaBindingCleanup: null,
       refreshFiber: null,
+      refreshFailures: 0,
+      refreshInFlight: false,
       recoveryQueued: null,
       joinCancelled: false,
       closed: false,
       epoch: 0
     };
+    const mediaAttempt = { expiresAt: null };
     const foreign7 = (operation, code = "internal_error", message = "A browser transport operation failed") => Effect2.tryPromise({ try: operation, catch: (cause) => lifecycleFailure(code, true, message, cause) });
+    const withinForegroundBudget = (effect, milliseconds, failure3) => Effect2.raceFirst(
+      effect,
+      Effect2.callback((resume) => {
+        const cancel = scheduleForegroundDeadline(platform.clock, milliseconds, () => resume(Effect2.fail(failure3)));
+        return Effect2.sync(cancel);
+      })
+    );
     const toPromise = (effect) => Effect2.runPromiseWith(context)(effect);
-    const publish = () => Effect2.sync(() => snapshotFor(model, access.currentUnsafe())).pipe(
-      Effect2.tap((snapshot) => SubscriptionRef.set(snapshotRef, snapshot)),
+    const publish = () => Effect2.sync(() => ({ previous: SubscriptionRef.getUnsafe(snapshotRef), snapshot: snapshotFor(model, access.currentUnsafe()) })).pipe(
+      Effect2.tap(({ snapshot }) => SubscriptionRef.set(snapshotRef, snapshot)),
+      Effect2.tap(
+        ({ previous, snapshot }) => Effect2.sync(() => {
+          const ports = portsFor(model);
+          if (![
+            ports?.sync === emittedPorts?.sync,
+            ports?.media === emittedPorts?.media,
+            ["healthy", "unresponsive"].includes(previous.connection.sync) === ["healthy", "unresponsive"].includes(snapshot.connection.sync),
+            previous.connection.media === "healthy" === (snapshot.connection.media === "healthy")
+          ].every(Boolean)) {
+            emittedPorts = ports;
+            for (const listener of portListeners) {
+              try {
+                listener(ports);
+              } catch {
+              }
+            }
+          }
+        })
+      ),
       Effect2.asVoid,
       Effect2.tap(
         () => Effect2.sync(() => {
@@ -2071,15 +2128,6 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
         })
       )
     );
-    const emitPorts = () => Effect2.sync(() => {
-      const ports = portsFor(model);
-      for (const listener of portListeners) {
-        try {
-          listener(ports);
-        } catch {
-        }
-      }
-    });
     const transition = (state) => Effect2.gen(function* () {
       if (model.state === state) return;
       model.state = state;
@@ -2109,28 +2157,51 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       model.refreshFiber = yield* Effect2.forkIn(Effect2.sleep(Math.max(0, milliseconds)).pipe(Effect2.andThen(enqueue(refreshAccess())), Effect2.ignore), scope);
     });
     const refreshAccess = () => Effect2.gen(function* () {
-      if (!active(model)) return;
+      const scope = model.activeScope;
+      if (!active(model) || !scope || model.refreshInFlight) return;
       const epoch = model.epoch;
-      const result = yield* Effect2.exit(access.ensureFresh("scheduled_refresh"));
-      if (result._tag === "Failure") {
-        diagnostics.record({ event: "access_refresh_failed", state: model.state, epoch, code: "access_unavailable" });
-        yield* scheduleRefresh(REFRESH_RETRY_MS);
-        return;
-      }
-      diagnostics.record({ event: "access_refreshed", state: model.state, epoch });
-      yield* publish();
-      yield* scheduleRefresh();
+      model.refreshInFlight = true;
+      yield* Effect2.forkIn(
+        access.ensureFresh("scheduled_refresh").pipe(
+          Effect2.match({ onSuccess: () => null, onFailure: (cause) => cause }),
+          Effect2.flatMap(
+            (failure3) => enqueue(
+              Effect2.gen(function* () {
+                if (model.epoch !== epoch || !active(model)) return;
+                model.refreshInFlight = false;
+                if (failure3) {
+                  diagnostics.record({ event: "access_refresh_failed", state: model.state, epoch, code: failure3.code === "access.invalid" ? "invalid_access" : "access_unavailable" });
+                  if (failure3.code === "access.invalid") return yield* failForSnapshot(accessFailure(failure3));
+                  model.refreshFailures = Math.min(model.refreshFailures + 1, 5);
+                  yield* scheduleRefresh(Math.min(BACKGROUND_RETRY_MAX_MS, REFRESH_RETRY_MS * 2 ** (model.refreshFailures - 1)));
+                  return;
+                }
+                model.refreshFailures = 0;
+                diagnostics.record({ event: "access_refreshed", state: model.state, epoch });
+                yield* publish();
+                yield* scheduleRefresh();
+              })
+            )
+          ),
+          Effect2.ignore
+        ),
+        scope
+      );
     });
     const stopPorts = () => Effect2.gen(function* () {
       yield* stopRefresh();
       const scope = model.activeScope;
       model.activeScope = null;
+      model.refreshFailures = 0;
+      model.refreshInFlight = false;
+      mediaAttempt.expiresAt = null;
       model.sync = null;
       model.media = null;
       model.syncSnapshot = null;
       model.syncNoticeUnresponsive = false;
       model.mediaSnapshot = null;
-      yield* emitPorts();
+      model.recoveryQueued = null;
+      yield* publish();
       if (scope) yield* Scope.close(scope, Exit.void);
       yield* access.clear;
       yield* publish();
@@ -2193,19 +2264,16 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       yield* handleMediaSnapshot(media, media.getSnapshot());
     });
     const waitForSyncLive = (sync, timeoutMs) => Effect2.callback((resume) => {
-      if (sync.getSnapshot().connection.phase === "live") {
-        resume(Effect2.void);
-        return;
-      }
-      const unsubscribe = sync.subscribe((snapshot) => {
-        if (snapshot.connection.phase === "live") resume(Effect2.void);
-        else if (snapshot.connection.phase === "terminal" || snapshot.connection.phase === "stopped") resume(Effect2.fail(lifecycleFailure("sync_start_failed", true, "Sync stopped before becoming live")));
-      });
+      const observe = (snapshot) => {
+        if (episodeEnded(snapshot)) resume(Effect2.fail(lifecycleFailure("episode_ended", false, "The Episode has ended")));
+        else if (snapshot.connection.phase === "live") resume(Effect2.void);
+        else if (snapshot.connection.phase === "terminal") resume(Effect2.fail(syncTerminalFailure(snapshot)));
+        else if (snapshot.connection.phase === "stopped") resume(Effect2.fail(lifecycleFailure("sync_start_failed", true, "Sync stopped before becoming live")));
+      };
+      const unsubscribe = sync.subscribe(observe);
+      observe(sync.getSnapshot());
       return Effect2.sync(unsubscribe);
-    }).pipe(
-      Effect2.timeout(timeoutMs),
-      Effect2.catchTag("TimeoutError", () => Effect2.fail(lifecycleFailure("sync_start_failed", true, "Sync did not become live before the startup deadline")))
-    );
+    }).pipe((effect) => withinForegroundBudget(effect, timeoutMs, lifecycleFailure("sync_start_failed", true, "Sync did not become live before the startup deadline")));
     const trace = (step, effect) => {
       const span = diagnostics.startSpan({ step, state: model.state, epoch: model.epoch });
       return traceRecovery(step, effect, recordInitialConnection).pipe(
@@ -2224,9 +2292,12 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       const scope = yield* Scope.make("sequential");
       model.activeScope = scope;
       let stream = null;
+      let captureWarning = null;
       yield* Effect2.gen(function* () {
         if (model.joinCancelled) return yield* Effect2.fail(lifecycleFailure("invalid_state", false, "Join was cancelled by Leave"));
-        stream = yield* trace("acquire_initial_media", model.initialMedia(model.intent).pipe(Effect2.mapError((cause) => captureFailure(cause))));
+        const captured = yield* trace("acquire_initial_media", acquireInitialMedia(model.initialMedia, model.initialMediaIntent?.() ?? model.intent));
+        stream = captured.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", access.initialize(reason));
         const media = yield* trace(
@@ -2235,7 +2306,10 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
             try: () => platform.createMediaClient({
               access: grant,
               credential: () => toPromise(access.getMediaToken()),
-              replaceMediaConnection: () => toPromise(access.refresh("media_recovery", true)).then((replacement) => replacement.media),
+              replaceMediaConnection: () => toPromise(access.refresh("media_recovery", true)).then((replacement) => {
+                if (media === model.media) mediaAttempt.expiresAt = platform.clock.now() + MEDIA_RECOVERY_TIMEOUT_MS;
+                return replacement.media;
+              }),
               recordReconnect: options.recordReconnect,
               telemetry: options.telemetry,
               ...options.recordRtcSummary ? { recordRtcSummary: options.recordRtcSummary } : {},
@@ -2275,17 +2349,20 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
               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: failure3.code });
+            const retry = !retried && failure3.code === "invalid_access";
+            if (!retry) yield* recordFailure(failure3);
             yield* stopPorts();
-            if (!retried && failure3.code === "invalid_access") return yield* performJoin("access_retry", true);
+            if (retry) return yield* performJoin("access_retry", true);
             yield* transition("failed");
-            span.end({ state: model.state, epoch: model.epoch, outcome: "failed", code: failure3.code });
             return yield* Effect2.fail(failure3);
           }),
           onSuccess: () => Effect2.gen(function* () {
             model.syncSnapshot = model.sync?.getSnapshot() ?? null;
             model.mediaSnapshot = model.media?.getSnapshot() ?? null;
+            model.failure = captureWarning ? toFailure(captureWarning) : null;
             yield* transition("live");
-            yield* emitPorts();
+            if (model.mediaSnapshot?.connection.phase !== "live") yield* recover("media");
             yield* scheduleRefresh();
             span.end({ state: model.state, epoch: model.epoch, outcome: "succeeded" });
           })
@@ -2308,26 +2385,36 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       const leave = foreign7(() => sync.leave()).pipe(Effect2.timeout(LEAVE_TIMEOUT_MS));
       return (yield* Effect2.exit(leave))._tag === "Success";
     });
+    const publishFreshAccess = () => enqueue(
+      Effect2.gen(function* () {
+        if (!active(model)) return;
+        diagnostics.record({ event: "access_refreshed", state: model.state, epoch: model.epoch });
+        yield* publish();
+        yield* scheduleRefresh();
+      })
+    );
+    const requireOpen = Effect2.suspend(() => model.closed ? Effect2.fail(lifecycleFailure("invalid_state", false, "The Connection scope is closed")) : Effect2.void);
     const withFreshAccess = (operation) => Effect2.gen(function* () {
+      yield* requireOpen;
       if (yield* access.requiresRefresh) {
+        yield* requireOpen;
         yield* access.ensureFresh("scheduled_refresh").pipe(Effect2.mapError(accessFailure));
-        diagnostics.record({ event: "access_refreshed", state: model.state, epoch: model.epoch });
-        yield* scheduleRefresh();
+        yield* publishFreshAccess();
       }
-      return yield* operation().pipe(
+      const run = requireOpen.pipe(
+        Effect2.andThen(Effect2.suspend(operation)),
+        Effect2.flatMap((value) => requireOpen.pipe(Effect2.as(value)))
+      );
+      return yield* run.pipe(
         Effect2.matchEffect({
           onSuccess: Effect2.succeed,
           onFailure: (cause) => {
             if (!accessRejected(cause)) return Effect2.fail(cause);
-            return access.refreshAfterRejection().pipe(
-              Effect2.mapError(accessFailure),
-              Effect2.tap(
-                () => Effect2.sync(() => {
-                  diagnostics.record({ event: "access_refreshed", state: model.state, epoch: model.epoch });
-                })
-              ),
-              Effect2.andThen(scheduleRefresh()),
-              Effect2.andThen(operation())
+            return requireOpen.pipe(
+              Effect2.andThen(access.refreshAfterRejection()),
+              Effect2.mapError((failure3) => failure3 instanceof ConnectionAccessFailure ? accessFailure(failure3) : failure3),
+              Effect2.andThen(publishFreshAccess()),
+              Effect2.andThen(run)
             );
           }
         })
@@ -2346,15 +2433,67 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
         )
       );
     });
-    const recover = (kind) => Effect2.gen(function* recoverEffect() {
-      if (!active(model)) return;
-      if (model.recoveryQueued === kind) return;
+    const recover = (kind) => Effect2.gen(function* () {
+      const scope = model.activeScope;
+      if (!active(model) || !scope) return;
+      if (model.recoveryQueued !== null) {
+        model.recoveryQueued = kind;
+        yield* publish();
+        return;
+      }
       model.recoveryQueued = kind;
-      yield* transition("reconnecting");
-      const plan = yield* recoveryPlan(kind);
-      const attempt = yield* attemptRecovery(plan);
-      if (attempt !== null) return yield* finishRecovery(attempt);
-      yield* failRecovery(plan);
+      const phase = kind === "sync" ? model.sync?.getSnapshot().connection.phase : model.media?.getSnapshot().connection.phase;
+      if (phase === "terminal" || phase === "failed") yield* transition("reconnecting");
+      const epoch = model.epoch;
+      yield* Effect2.forkIn(
+        Effect2.gen(function* () {
+          yield* Effect2.sleep(RECONNECT_GRACE_MS);
+          const phase2 = kind === "sync" ? model.sync?.getSnapshot().connection.phase : model.media?.getSnapshot().connection.phase;
+          if (phase2 === "live") {
+            enqueueBackground(finishRecovery(0, epoch));
+            return;
+          }
+          yield* enqueue(
+            Effect2.gen(function* () {
+              if (model.epoch === epoch && active(model)) yield* transition("reconnecting");
+            })
+          );
+          let cycle = 0;
+          const syncAttempt = { client: null, expiresAt: null, started: true };
+          while (model.epoch === epoch && active(model)) {
+            const plan = yield* recoveryPlan(model.recoveryQueued ?? kind);
+            const outcome = yield* attemptRecovery(plan, mediaAttempt, syncAttempt).pipe(
+              Effect2.match({
+                onSuccess: (attempt) => ({ attempt, failure: null }),
+                onFailure: (failure3) => ({ attempt: null, failure: failure3 })
+              })
+            );
+            if (outcome.failure) {
+              const failure3 = outcome.failure;
+              enqueueBackground(Effect2.suspend(() => model.epoch === epoch && active(model) ? failForSnapshot(failure3) : Effect2.void));
+              return;
+            }
+            if (outcome.attempt !== null) {
+              enqueueBackground(finishRecovery(outcome.attempt, epoch));
+              return;
+            }
+            yield* enqueue(
+              Effect2.gen(function* () {
+                if (model.epoch !== epoch || !active(model)) return;
+                const code = plan.kind === "media" ? "media_recovery_exhausted" : "sync_recovery_exhausted";
+                model.failure = toFailure(lifecycleFailure(code, true, "Connection interrupted. Reconnecting in the background."));
+                diagnostics.record({ event: "recovery_exhausted", state: model.state, epoch, code });
+                yield* publish();
+              })
+            );
+            if (model.recoveryQueued !== plan.kind) continue;
+            const delay = Math.min(BACKGROUND_RETRY_MAX_MS, 250 * 2 ** cycle);
+            cycle = Math.min(cycle + 1, 8);
+            yield* Effect2.race(Effect2.sleep(delay * (0.5 + Math.random() * 0.5)), waitForTransportChange(plan.kind));
+          }
+        }),
+        scope
+      );
     });
     const recoveryPlan = (kind) => Clock2.currentTimeMillis.pipe(
       Effect2.map((now) => ({
@@ -2364,80 +2503,216 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
         delays: options.recovery?.backoffMs?.length ? options.recovery.backoffMs : [100, 250, 500]
       }))
     );
-    const attemptRecovery = (plan) => Effect2.gen(function* attemptRecoveryEffect() {
+    const attemptRecovery = (plan, mediaAttempt2, syncAttempt) => Effect2.gen(function* () {
       for (let attempt = 1; attempt <= plan.attempts; attempt += 1) {
         const remaining = plan.deadline - (yield* Clock2.currentTimeMillis);
         if (remaining <= 0) return null;
         recordReconnect(options.recordReconnect, "attempt", { recovery_kind: plan.kind, attempt });
         diagnostics.record({ event: "recovery_attempt", state: model.state, epoch: model.epoch, attempt });
-        const outcome = yield* Effect2.exit(recoveryOperation(plan.kind).pipe(Effect2.timeout(remaining)));
-        if (outcome._tag === "Success") return attempt;
-        if (attempt < plan.attempts) yield* traceRecovery("lifecycle_backoff", Effect2.sleep(recoveryDelay(plan, attempt)));
+        const failure3 = yield* recoveryOperation(mediaAttempt2, syncAttempt).pipe(
+          Effect2.timeout(remaining),
+          Effect2.catchTag("TimeoutError", () => Effect2.fail(lifecycleFailure("sync_start_failed", true, "Connection recovery is still waiting for the transport"))),
+          Effect2.match({ onSuccess: () => null, onFailure: (cause) => cause })
+        );
+        if (failure3 === null) return attempt;
+        if (!failure3.recoverable) return yield* Effect2.fail(failure3);
+        if (attempt < plan.attempts) {
+          const remaining2 = Math.max(0, plan.deadline - (yield* Clock2.currentTimeMillis));
+          yield* traceRecovery("lifecycle_backoff", Effect2.sleep(Math.min(recoveryDelay(plan, attempt), remaining2)));
+        }
       }
       return null;
     });
-    const recoveryOperation = (kind) => kind === "media" ? recoverMedia() : recoverSync();
-    const recoveryDelay = (plan, attempt) => Math.max(0, plan.delays[Math.min(attempt - 1, plan.delays.length - 1)] ?? 0);
-    const finishRecovery = (attempt) => Effect2.gen(function* finishRecoveryEffect() {
+    const recoveryOperation = (mediaAttempt2, syncAttempt) => Effect2.gen(function* () {
+      const results = yield* Effect2.all(
+        [recoverSync(syncAttempt), recoverMedia(mediaAttempt2)].map((effect) => effect.pipe(Effect2.matchEffect({ onSuccess: () => Effect2.succeed(null), onFailure: (failure4) => failure4.recoverable ? Effect2.succeed(failure4) : Effect2.fail(failure4) }))),
+        { concurrency: "unbounded" }
+      );
+      const failure3 = results.find((failure4) => failure4 !== null);
+      if (failure3) return yield* Effect2.fail(failure3);
+    });
+    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 finishRecovery = (attempt, epoch) => Effect2.gen(function* () {
+      if (model.epoch !== epoch || !active(model)) return;
       model.recoveryQueued = null;
-      diagnostics.record({ event: "recovery_succeeded", state: model.state, epoch: model.epoch, attempt });
+      model.syncSnapshot = model.sync?.getSnapshot() ?? null;
+      model.mediaSnapshot = model.media?.getSnapshot() ?? null;
+      model.failure = null;
+      if (model.syncSnapshot?.connection.phase !== "live") return yield* recover("sync");
+      if (model.mediaSnapshot?.connection.phase !== "live") return yield* recover("media");
+      mediaAttempt.expiresAt = null;
+      diagnostics.record({ event: "recovery_succeeded", state: model.state, epoch, attempt });
       yield* transition("live");
+      yield* publish();
       yield* scheduleRefresh();
     });
-    const failRecovery = (plan) => Effect2.gen(function* failRecoveryEffect() {
-      const code = plan.kind === "media" ? "media_recovery_exhausted" : "sync_recovery_exhausted";
-      model.recoveryQueued = null;
-      model.failure = toFailure(lifecycleFailure(code, false, `${plan.kind} recovery exhausted its retry budget`));
-      diagnostics.record({ event: "recovery_exhausted", state: model.state, epoch: model.epoch, code });
-      yield* stopPorts();
-      yield* transition("failed");
+    const waitForTransportChange = (kind) => Effect2.callback((resume) => {
+      const sync = model.sync;
+      const media = model.media;
+      const syncPhase2 = sync?.getSnapshot().connection.phase;
+      const mediaPhase2 = media?.getSnapshot().connection.phase;
+      const observe = () => {
+        if (model.recoveryQueued !== kind || model.sync !== sync || model.media !== media || model.sync?.getSnapshot().connection.phase !== syncPhase2 || model.media?.getSnapshot().connection.phase !== mediaPhase2 || syncPhase2 === "live" && mediaPhase2 === "live") resume(Effect2.void);
+      };
+      listeners.add(observe);
+      const unsubscribeSync = sync?.subscribe(observe);
+      const unsubscribeMedia = media?.subscribe(observe);
+      observe();
+      return Effect2.sync(() => {
+        listeners.delete(observe);
+        unsubscribeSync?.();
+        unsubscribeMedia?.();
+      });
+    });
+    const waitForMediaLive = (media) => Effect2.callback((resume) => {
+      const observe = () => {
+        const snapshot = media.getSnapshot();
+        if (snapshot.connection.phase === "live") resume(Effect2.void);
+        else if (snapshot.connection.phase === "failed") resume(Effect2.fail(lifecycleFailure("media_start_failed", snapshot.failure?.recoverable ?? true, "Media transport needs recovery")));
+      };
+      const unsubscribe = media.subscribe(observe);
+      observe();
+      return Effect2.sync(unsubscribe);
     });
-    const recoverMedia = () => Effect2.gen(function* () {
+    const recoverMedia = (attempt) => Effect2.gen(function* () {
       const media = model.media;
-      const sync = model.sync;
-      if (!media || !sync) return yield* Effect2.fail(lifecycleFailure("invalid_state", false, "Media recovery requires active ports"));
+      if (!media) return yield* Effect2.fail(lifecycleFailure("invalid_state", false, "Media recovery requires active ports"));
+      if (media.getSnapshot().connection.phase === "live") {
+        attempt.expiresAt = null;
+        return;
+      }
+      if (media.getSnapshot().connection.phase === "recovering") {
+        const now = yield* Clock2.currentTimeMillis;
+        attempt.expiresAt ??= now + MEDIA_RECOVERY_TIMEOUT_MS;
+        attempt.expiresAt = Math.max(attempt.expiresAt, foregroundRecoveryDeadline);
+        if (typeof document !== "undefined" && document.visibilityState === "hidden") attempt.expiresAt = now + MEDIA_RECOVERY_TIMEOUT_MS;
+        if (now < attempt.expiresAt) return yield* waitForMediaLive(media);
+      }
       recordReconnect(options.recordReconnect, "media_decision", { strategy: "full_rebuild" });
       const grant = yield* traceRecovery("access_refresh", access.refresh("media_recovery", true).pipe(Effect2.mapError(accessFailure)));
       const restartInput = grant.media.provider === "cloudflare_sfu" ? grant.media.clientPayload : grant.media;
+      attempt.expiresAt = (yield* Clock2.currentTimeMillis) + MEDIA_RECOVERY_TIMEOUT_MS;
       yield* traceRecovery(
         "media_rebuild",
-        foreign7(() => media.restart(restartInput))
+        foreign7(() => media.restart(restartInput), "media_start_failed", "Media transport could not restart")
       );
-      model.mediaSnapshot = media.getSnapshot();
+      yield* waitForMediaLive(media);
+    });
+    const syncAttemptExpired = (attempt, sync, now) => {
+      if (attempt.client !== sync) {
+        attempt.client = sync;
+        attempt.expiresAt = now + MEDIA_RECOVERY_TIMEOUT_MS;
+        attempt.started = true;
+      }
+      attempt.expiresAt = Math.max(attempt.expiresAt ?? 0, foregroundRecoveryDeadline);
+      if (typeof document !== "undefined" && document.visibilityState === "hidden") attempt.expiresAt = now + MEDIA_RECOVERY_TIMEOUT_MS;
+      return now >= attempt.expiresAt && sync.getSnapshot().connection.phase !== "live";
+    };
+    const syncNeedsReplacement = (snapshot) => {
+      if (snapshot.connection.phase === "idle" || snapshot.connection.phase === "stopped") return Effect2.succeed(true);
+      if (snapshot.connection.phase !== "terminal") return Effect2.succeed(false);
+      const failure3 = syncTerminalFailure(snapshot);
+      return failure3.recoverable ? Effect2.succeed(true) : Effect2.fail(failure3);
+    };
+    const recoverSync = (attempt) => Effect2.gen(function* () {
+      const sync = model.sync;
+      if (!sync) return yield* restartSync(attempt);
+      const snapshot = sync.getSnapshot();
+      const now = yield* Clock2.currentTimeMillis;
+      if (syncAttemptExpired(attempt, sync, now)) {
+        if (!attempt.started || !sync.restartTransport) return yield* restartSync(attempt);
+        sync.restartTransport();
+        attempt.expiresAt = now + MEDIA_RECOVERY_TIMEOUT_MS;
+      }
+      if ((attempt.started || snapshot.connection.phase !== "idle") && (yield* syncNeedsReplacement(snapshot))) return yield* restartSync(attempt);
       yield* waitForSyncLive(sync, boundedInteger(options.recovery?.budgetMs, RECOVERY_BUDGET_MS, 1, 6e4));
     });
-    const recoverSync = () => Effect2.gen(function* () {
-      const media = model.media;
-      const scope = model.activeScope;
-      const grant = access.currentUnsafe();
-      if (!media || !scope || !grant) return yield* Effect2.fail(lifecycleFailure("invalid_state", false, "Sync recovery requires active ports"));
+    const restartSync = (attempt) => Effect2.gen(function* () {
+      const epoch = model.epoch;
       yield* access.getSyncToken("sync_recovery").pipe(Effect2.mapError(accessFailure));
-      model.syncBindingCleanup?.();
-      model.sync = null;
-      const sync = yield* Effect2.try({
-        try: () => platform.createSyncClient({ access: grant, token: () => toPromise(access.getSyncToken()), media, telemetry: options.telemetry, recordReconnect: options.recordReconnect }),
-        catch: (cause) => lifecycleFailure("sync_start_failed", true, "The sync layer could not start", cause)
-      });
-      model.sync = sync;
-      yield* bindSync(scope, sync);
-      yield* foreign7(() => sync.start());
+      const sync = yield* enqueue(
+        Effect2.gen(function* () {
+          const media = model.media;
+          const scope = model.activeScope;
+          const grant = access.currentUnsafe();
+          if (model.epoch !== epoch || !active(model) || !media || !scope || !grant) return yield* Effect2.fail(lifecycleFailure("invalid_state", false, "Sync recovery requires active ports"));
+          model.syncBindingCleanup?.();
+          model.sync = null;
+          const sync2 = yield* Effect2.try({
+            try: () => platform.createSyncClient({ access: grant, token: () => toPromise(access.getSyncToken()), media, telemetry: options.telemetry, recordReconnect: options.recordReconnect }),
+            catch: (cause) => lifecycleFailure("sync_start_failed", true, "The sync layer could not start", cause)
+          });
+          model.sync = sync2;
+          yield* bindSync(scope, sync2);
+          return sync2;
+        })
+      );
+      attempt.client = sync;
+      attempt.started = false;
+      attempt.expiresAt = (yield* Clock2.currentTimeMillis) + MEDIA_RECOVERY_TIMEOUT_MS;
+      yield* foreign7(
+        () => sync.start().then(() => {
+          if (sync !== model.sync || model.epoch !== epoch) sync.stop();
+          else if (attempt.client === sync) attempt.started = true;
+        })
+      ).pipe(
+        Effect2.tapError(
+          () => enqueue(
+            Effect2.gen(function* () {
+              if (sync !== model.sync) return;
+              model.syncBindingCleanup?.();
+              model.sync = null;
+              model.syncSnapshot = null;
+              yield* publish();
+            })
+          )
+        )
+      );
       yield* waitForSyncLive(sync, boundedInteger(options.recovery?.budgetMs, RECOVERY_BUDGET_MS, 1, 6e4));
-      yield* emitPorts();
     });
     const handleSyncSnapshot = (sync, snapshot) => Effect2.gen(function* handleSyncSnapshotEffect() {
       if (!isCurrentSyncSnapshot(sync, snapshot)) return;
       model.syncSnapshot = snapshot;
       if (syncSubjectMismatched(access.currentUnsafe()?.subject ?? null, snapshot)) return yield* failForSnapshot(lifecycleFailure("invalid_access", false, "Sync authenticated a different participant subject"));
-      if (episodeEnded(snapshot)) return yield* failForSnapshot(lifecycleFailure("episode_ended", false, "The Episode has ended"));
+      if (yield* settleTerminalSnapshot(snapshot)) return;
       if (syncNeedsRecovery(snapshot)) yield* recover("sync");
       yield* publish();
     });
+    const settleTerminalSnapshot = (snapshot) => Effect2.gen(function* () {
+      const ended = episodeEnded(snapshot);
+      if (ended || snapshot.connection.terminalReason === "participant_inactive") {
+        if (ended) model.episodeEndConfirmed = true;
+        yield* finishTerminalSnapshot();
+        return true;
+      }
+      if (snapshot.connection.phase !== "terminal") return false;
+      const failure3 = syncTerminalFailure(snapshot);
+      if (failure3.recoverable) return false;
+      yield* failForSnapshot(failure3);
+      return true;
+    });
     const isCurrentSyncSnapshot = (sync, snapshot) => sync === model.sync && snapshot !== model.syncSnapshot;
     const syncSubjectMismatched = (subject, snapshot) => subject !== null && snapshot.participantId !== null && (subject.participantId !== snapshot.participantId || subject.participantGeneration !== snapshot.participantGeneration);
-    const episodeEnded = (snapshot) => snapshot.control?.status === "ended" || snapshot.optimisticControl?.status === "ended";
-    const syncNeedsRecovery = (snapshot) => active(model) && snapshot.connection.phase === "terminal";
+    const episodeEnded = (snapshot) => snapshot.control?.status === "ended" || snapshot.connection.terminalReason === "episode_ended";
+    const finishTerminalSnapshot = () => Effect2.gen(function* () {
+      model.failure = null;
+      yield* transition("leaving");
+      yield* stopPorts();
+      yield* transition("left");
+    });
+    const syncNeedsRecovery = (snapshot) => active(model) && (snapshot.connection.phase === "connecting" || snapshot.connection.phase === "recovering" || snapshot.connection.phase === "terminal");
+    const recordFailure = (failure3) => Effect2.sync(() => {
+      const reason = model.sync?.getSnapshot().connection.terminalReason;
+      const terminalReason = reason === "participant_inactive" || reason === "stale_participant_generation" || reason === "episode_ended" ? reason : failure3.code;
+      diagnostics.record({ event: "connection_failed", state: model.state, epoch: model.epoch, code: failure3.code });
+      recordReconnect(options.recordReconnect, "terminal_failure", { code: failure3.code, terminal_reason: terminalReason }, "failed");
+    });
     const failForSnapshot = (failure3) => Effect2.gen(function* failForSnapshotEffect() {
       model.failure = toFailure(failure3);
+      yield* recordFailure(failure3);
       yield* stopPorts();
       yield* transition("failed");
     });
@@ -2445,21 +2720,43 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       if (media !== model.media || media.getSnapshot() !== snapshot) return;
       if (snapshot === model.mediaSnapshot) return;
       model.mediaSnapshot = snapshot;
-      if (active(model) && snapshot.connection.phase === "failed" && snapshot.failure?.recoverable) yield* recover("media");
+      if (active(model) && (snapshot.connection.phase === "recovering" || snapshot.connection.phase === "failed" && snapshot.failure?.recoverable)) yield* recover("media");
       yield* publish();
     });
     const handleMediaFailure = () => model.media ? handleMediaSnapshot(model.media, model.media.getSnapshot()) : Effect2.void;
     const applyAutomaticMediaReplacement = (grant) => Effect2.gen(function* () {
       const media = model.media;
-      if (!media || !active(model)) return;
+      const scope = model.activeScope;
+      const epoch = model.epoch;
+      if (!media || !scope || !active(model)) return;
       const restartInput = grant.media.provider === "cloudflare_sfu" ? grant.media.clientPayload : grant.media;
-      const restarted = yield* Effect2.exit(foreign7(() => media.restart(restartInput), "media_start_failed", "The media client could not apply a replacement access grant"));
-      if (restarted._tag === "Failure") {
-        yield* recover("media");
-        return;
-      }
-      model.mediaSnapshot = media.getSnapshot();
-      yield* publish();
+      mediaAttempt.expiresAt = (yield* Clock2.currentTimeMillis) + MEDIA_RECOVERY_TIMEOUT_MS;
+      yield* Effect2.forkIn(
+        foreign7(
+          () => media.restart(restartInput).then(() => {
+            if (media !== model.media || model.epoch !== epoch) media.stop();
+          }),
+          "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")),
+          Effect2.match({ onSuccess: () => true, onFailure: () => false }),
+          Effect2.flatMap(
+            (restarted) => enqueue(
+              Effect2.gen(function* () {
+                if (model.epoch !== epoch || media !== model.media || !active(model)) return;
+                if (!restarted) {
+                  yield* recover("media");
+                  return;
+                }
+                model.mediaSnapshot = media.getSnapshot();
+                yield* publish();
+              })
+            )
+          )
+        ),
+        scope
+      );
     });
     const notifyScreenEnded = () => Effect2.sync(() => {
       if (!active(model)) return;
@@ -2480,7 +2777,10 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
     }) : Deferred.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?.(() => enqueueBackground(refreshAccess())) ?? null;
+    const foregroundUnsubscribe = platform.subscribeForeground?.(() => {
+      foregroundRecoveryDeadline = platform.clock.now() + MEDIA_RECOVERY_TIMEOUT_MS;
+      enqueueBackground(refreshAccess());
+    }) ?? null;
     yield* Effect2.addFinalizer(
       () => Effect2.gen(function* () {
         model.closed = true;
@@ -2509,8 +2809,9 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       },
       getDiagnostics: () => diagnostics.snapshot(),
       getJoinTrace: () => diagnostics.joinTrace(),
-      setInitialMedia: (provider) => Effect2.sync(() => {
+      setInitialMedia: (provider, intent) => Effect2.sync(() => {
         model.initialMedia = provider;
+        model.initialMediaIntent = intent ?? null;
       }),
       configureJoin: (intent) => Effect2.sync(() => {
         if (model.state !== "idle" && model.state !== "left" && model.state !== "failed") throw lifecycleFailure("invalid_state", false, `Cannot configure Join while ${model.state}`);
@@ -2540,13 +2841,20 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       runCommand: (operation) => enqueue(
         Effect2.gen(function* () {
           const ports = portsFor(model);
-          if (model.state !== "live" || !ports) return yield* Effect2.fail(lifecycleFailure("invalid_state", false, `Cannot run a command while ${model.state}`));
-          const value = yield* withFreshAccess(() => operation(ports));
-          if (model.state !== "live") return yield* Effect2.fail(lifecycleFailure("invalid_state", false, "The command belongs to an inactive Connection"));
-          return value;
+          if (!active(model) || !ports || ports.sync.getSnapshot().connection.phase !== "live") return yield* Effect2.fail(lifecycleFailure("invalid_state", true, "Connection interrupted. Try again when reconnected."));
+          return ports;
         })
+      ).pipe(
+        Effect2.flatMap(
+          (ports) => withFreshAccess(
+            () => Effect2.suspend(() => {
+              if (!active(model) || ports.sync !== model.sync) return Effect2.fail(lifecycleFailure("invalid_state", true, "Connection interrupted. Try again when reconnected."));
+              return operation(ports).pipe(Effect2.flatMap((value) => active(model) && ports.sync === model.sync ? Effect2.succeed(value) : Effect2.fail(lifecycleFailure("invalid_state", true, "The command belongs to an inactive Connection"))));
+            })
+          )
+        )
       ),
-      runPortCommand: (operation) => enqueue(withFreshAccess(operation)),
+      runPortCommand: (operation) => withFreshAccess(operation),
       nowUnsafe: () => clock.currentTimeMillisUnsafe(),
       scheduleUnsafe: (callback, milliseconds) => platform.clock.setTimeout(callback, milliseconds),
       cancelScheduleUnsafe: (handle) => platform.clock.clearTimeout(handle),
@@ -2564,7 +2872,8 @@ function snapshotFor(model, access) {
     subject: subjectFor(access),
     episode: episodeFor(access, control),
     connection: Object.freeze({ sync: model.syncSnapshot?.connection.phase === "live" && model.syncNoticeUnresponsive ? "unresponsive" : syncPhase(model.syncSnapshot?.connection.phase), media: mediaPhase(model.mediaSnapshot?.connection.phase) }),
-    failure: model.failure ? Object.freeze({ ...model.failure }) : null
+    failure: model.failure ? Object.freeze({ ...model.failure }) : null,
+    episodeEnded: model.episodeEndConfirmed
   });
 }
 function subjectFor(access) {
@@ -2583,7 +2892,7 @@ function portsFor(model) {
   return model.sync && model.media ? { sync: model.sync, media: model.media } : null;
 }
 function active(model) {
-  return model.state === "live" || model.state === "reconnecting";
+  return !model.closed && (model.state === "live" || model.state === "reconnecting");
 }
 function lifecycleFailure(code, recoverable, message, cause) {
   return new ConnectionLifecycleFailure({ code, recoverable, message, ...cause === void 0 ? {} : { cause } });
@@ -2592,11 +2901,60 @@ function toFailure(value) {
   return Object.freeze({ code: value.code, action: null, recoverable: value.recoverable, message: value.message });
 }
 function accessFailure(value) {
-  return lifecycleFailure(value.code === "access.invalid" ? "invalid_access" : "access_unavailable", value.code === "access.unavailable", "Access was rejected", value.cause);
+  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);
 }
 function captureFailure(cause) {
-  if (cause instanceof DOMException && cause.name === "NotAllowedError") return lifecycleFailure("permission_denied", true, "Media permission was denied", cause);
-  return lifecycleFailure("unsupported_environment", false, "Browser media capture is unavailable", cause);
+  if (cause instanceof ConnectionError && cause.cause === void 0) return lifecycleFailure(cause.code, cause.recoverable, cause.message, cause);
+  const failure3 = describeMediaCaptureError(cause instanceof ConnectionError ? cause.cause : cause);
+  if (failure3.code === "unsupported_environment") return lifecycleFailure("media_capture_failed", true, "Media capture failed. Try again or enter with devices off.", cause);
+  return lifecycleFailure(failure3.code, failure3.recoverable, failure3.message, cause);
+}
+function acquireInitialMedia(provider, intent) {
+  return provider(intent).pipe(
+    Effect2.map((stream) => ({ stream, failure: null })),
+    Effect2.catch((cause) => {
+      const initialFailure = captureFailure(cause);
+      if (!initialFailure.recoverable) return Effect2.fail(initialFailure);
+      const tracks = /* @__PURE__ */ new Set();
+      return Effect2.gen(function* () {
+        const failures = [];
+        for (const source of ["microphone", "camera"]) {
+          if (!intent[source]) continue;
+          if (!intent.microphone || !intent.camera) {
+            failures.push({ source, failure: initialFailure });
+            continue;
+          }
+          yield* provider({ microphone: source === "microphone", camera: source === "camera" }).pipe(
+            Effect2.tap(
+              (stream) => Effect2.sync(() => {
+                for (const track of stream.getTracks()) tracks.add(track);
+              })
+            ),
+            Effect2.catch(
+              (cause2) => Effect2.sync(() => {
+                failures.push({ source, failure: captureFailure(cause2) });
+              })
+            )
+          );
+        }
+        if (tracks.size === 0) yield* provider({ microphone: false, camera: false }).pipe(Effect2.mapError(captureFailure));
+        return { stream: streamFromTracks([...tracks]), failure: initialCaptureWarning(failures) };
+      }).pipe(
+        Effect2.onInterrupt(
+          () => Effect2.sync(() => {
+            for (const track of tracks) track.stop();
+          })
+        )
+      );
+    })
+  );
+}
+function initialCaptureWarning(failures) {
+  const first = failures[0];
+  if (!first) return null;
+  const names = failures.length === 2 ? "Microphone and camera" : first.source === "microphone" ? "Microphone" : "Camera";
+  const message = failures.length === 2 && first.failure.code !== failures[1]?.failure.code ? failures.map(({ source, failure: failure3 }) => `${source === "microphone" ? "Microphone" : "Camera"}: ${failure3.message}`).join(" ") : `${names}: ${first.failure.message}`;
+  return lifecycleFailure(first.failure.code, true, message, first.failure.cause);
 }
 function failureFromCause(cause, code, message) {
   if (cause instanceof ConnectionLifecycleFailure) return cause;
@@ -2630,6 +2988,12 @@ function mediaPhase(phase) {
   if (phase === "connecting") return "connecting";
   return "idle";
 }
+function syncTerminalFailure(snapshot) {
+  const reason = snapshot.connection.terminalReason;
+  if (reason === "episode_ended") return lifecycleFailure("episode_ended", false, "The Episode has ended");
+  if (reason === "participant_inactive" || reason === "stale_participant_generation") return lifecycleFailure("invalid_access", false, "Participant access is no longer valid");
+  return lifecycleFailure("sync_start_failed", true, "The Sync transport needs recovery");
+}
 
 // src/space-client/errors.ts
 import { Data as Data3 } from "effect";
@@ -2742,10 +3106,10 @@ var SpaceStore = class _SpaceStore {
   };
   updateConnection(snapshot) {
     const current = this.getSnapshot().connection;
-    const error2 = snapshot.failure ? empty({ code: mapCode(snapshot.failure.code), recoverable: snapshot.failure.recoverable, message: snapshot.failure.message }) : null;
+    const error2 = snapshot.failure ? empty({ code: publicCode(snapshot.failure.code), recoverable: snapshot.failure.recoverable, message: snapshot.failure.message }) : null;
     const status = snapshot.state === "live" && (INTERRUPTED_CONNECTION_PHASES.has(snapshot.connection.sync) || INTERRUPTED_CONNECTION_PHASES.has(snapshot.connection.media)) ? "reconnecting" : snapshot.state;
     if (current.status === status && sameEpisode(current.episode, snapshot.episode) && sameError(current.lastError, error2)) return;
-    this.#replace("connection", empty({ status, episode: snapshot.episode, lastError: error2 }));
+    this.#replace("connection", empty({ status, episode: snapshot.episode, lastError: sameError(current.lastError, error2) ? current.lastError : error2 }));
   }
   updateSelf(value) {
     this.#replace("self", value);
@@ -2793,7 +3157,16 @@ var SpaceStoreService = class extends Context4.Service()("@chalk/client/SpaceSto
 var makeSpaceStoreLayer = Layer4.effect(SpaceStoreService, SpaceStore.make());
 var makeFakeSpaceStoreLayer = (store = new SpaceStore()) => Layer4.succeed(SpaceStoreService, store);
 function mapCode(code) {
-  return { invalid_access: "access.invalid", episode_ended: "episode.ended", invalid_payload: "chat.payload_invalid", permission_denied: "media.permission_denied", unsupported_environment: "environment.unsupported", rate_limited: "command.rate_limited", command_rejected: "command.rejected" }[code] ?? "client.internal_error";
+  return {
+    invalid_access: "access.invalid",
+    access_unavailable: "access.unavailable",
+    episode_ended: "episode.ended",
+    invalid_payload: "chat.payload_invalid",
+    permission_denied: "media.permission_denied",
+    unsupported_environment: "environment.unsupported",
+    rate_limited: "command.rate_limited",
+    command_rejected: "command.rejected"
+  }[code] ?? "client.internal_error";
 }
 function sameEpisode(left, right) {
   if (left === right) return true;
@@ -2805,6 +3178,20 @@ function sameError(left, right) {
   if (!left || !right) return false;
   return left.code === right.code && left.recoverable === right.recoverable && left.message === right.message;
 }
+function publicCode(code) {
+  switch (code) {
+    case "device_not_found":
+      return "media.device_not_found";
+    case "device_busy":
+      return "media.device_busy";
+    case "device_constraint_invalid":
+      return "media.device_constraint_invalid";
+    case "media_capture_failed":
+      return "media.capture_failed";
+    default:
+      return mapCode(code);
+  }
+}
 
 // src/feedback/types.ts
 var FEEDBACK_EVIDENCE_SCHEMA_VERSION = "FeedbackEvidence/v1";
@@ -3834,6 +4221,7 @@ var ChatControllerRuntime = class {
   #offline;
   #catchUpRunning = false;
   #catchUpRequested = false;
+  #contiguousSequence = null;
   #hasOlder = false;
   #historyTruncated = false;
   #initialCatchUpComplete = true;
@@ -4027,7 +4415,8 @@ var ChatControllerRuntime = class {
     this.#ports = ports;
     if (!ports) return this.#reset();
     this.#status = "ready";
-    this.#initialCatchUpComplete = ports.sync.getCollaborationExtensionState().chatHeadSequence === null;
+    if (this.#contiguousSequence === null && ports.sync.getCollaborationExtensionState().chatHeadSequence === null) this.#contiguousSequence = "0";
+    this.#initialCatchUpComplete = this.#contiguousSequence !== null;
     this.#unsubscribeEvents = ports.sync.subscribeCollaboration((event) => {
       if (event.type === "chat_message") this.#observeMessage(chatMessageFor(event.message), this.#initialCatchUpComplete);
       else if (event.type === "chat_read_receipt") this.#mergeReceipt(chatReceiptFor(event.receipt));
@@ -4039,7 +4428,12 @@ var ChatControllerRuntime = class {
   }
   #scheduleCatchUp() {
     const ports = this.#ports;
-    if (!ports || ports.sync.getSnapshot().connection.phase !== "live" || !catchUpRequest(this.#messages.at(-1)?.sequence ?? null, ports)) return;
+    const floor = ports?.sync.getCollaborationExtensionState().retainedFloorSequence;
+    if (this.#contiguousSequence === "0" && floor) {
+      this.#contiguousSequence = String(BigInt(floor) - 1n);
+      this.#advanceContiguousSequence();
+    }
+    if (!ports || ports.sync.getSnapshot().connection.phase !== "live" || !catchUpRequest(this.#contiguousSequence, this.#messages.at(-1)?.sequence ?? null, ports)) return;
     if (this.#catchUpRunning) {
       this.#catchUpRequested = true;
       return;
@@ -4059,7 +4453,6 @@ var ChatControllerRuntime = class {
         Effect4.ensuring(
           Effect4.sync(() => {
             this.#catchUpRunning = false;
-            this.#initialCatchUpComplete = true;
             if (this.#catchUpRequested) {
               this.#catchUpRequested = false;
               this.#scheduleCatchUp();
@@ -4072,17 +4465,19 @@ var ChatControllerRuntime = class {
   #catchUp(ports) {
     return Effect4.suspend(() => {
       if (this.#ports !== ports || ports.sync.getSnapshot().connection.phase !== "live") return Effect4.void;
-      const request = catchUpRequest(this.#messages.at(-1)?.sequence ?? null, ports);
+      const request = catchUpRequest(this.#contiguousSequence, this.#messages.at(-1)?.sequence ?? null, ports);
       if (!request) return Effect4.void;
       return foreign(() => ports.sync.readChatPage(request.input)).pipe(
         Effect4.flatMap((result) => {
           if (this.#ports !== ports) return Effect4.void;
           if (result.status === "cursor_reset") return Effect4.sync(() => this.#applyCursorReset(result.retainedFloorSequence)).pipe(Effect4.andThen(this.#reloadAfterCursorReset(ports)));
           if (request.kind === "initial") {
+            this.#completeInitialPage(ports);
             this.#hasOlder = result.hasOlder;
             this.#publish();
           }
-          return result.hasOlder ? this.#catchUp(ports) : Effect4.void;
+          const progressed = request.kind === "initial" || this.#contiguousSequence !== request.input.afterSequence;
+          return progressed ? this.#catchUp(ports) : Effect4.void;
         })
       );
     });
@@ -4092,11 +4487,12 @@ var ChatControllerRuntime = class {
       Effect4.tap(
         (result) => Effect4.sync(() => {
           if (this.#ports !== ports || result.status === "cursor_reset") return;
+          this.#completeInitialPage(ports);
           this.#hasOlder = result.hasOlder;
           this.#publish();
         })
       ),
-      Effect4.asVoid
+      Effect4.andThen(this.#catchUp(ports))
     );
   }
   #applyPage(result) {
@@ -4112,8 +4508,32 @@ var ChatControllerRuntime = class {
     this.#hasOlder = false;
     this.#historyTruncated = true;
     this.#retainedFloorSequence = retainedFloorSequence;
+    this.#messages = Object.freeze(this.#messages.filter((message) => compareChatSequence(message.sequence, retainedFloorSequence) >= 0));
+    this.#contiguousSequence = null;
+    this.#initialCatchUpComplete = false;
     this.#publish();
   }
+  #completeInitialPage(ports) {
+    const floor = this.#messages[0]?.sequence ?? ports.sync.getCollaborationExtensionState().retainedFloorSequence;
+    this.#contiguousSequence = floor === null ? "0" : String(BigInt(floor) - 1n);
+    this.#advanceContiguousSequence();
+    this.#initialCatchUpComplete = true;
+  }
+  #advanceContiguousSequence(message) {
+    if (this.#contiguousSequence === null) return;
+    let sequence = BigInt(this.#contiguousSequence);
+    if (message) {
+      if (BigInt(message.sequence) !== sequence + 1n) return;
+      sequence += 1n;
+    }
+    for (const message2 of this.#messages) {
+      const candidate = BigInt(message2.sequence);
+      if (candidate <= sequence) continue;
+      if (candidate !== sequence + 1n) break;
+      sequence = candidate;
+    }
+    this.#contiguousSequence = String(sequence);
+  }
   #observeMessage(message, countUnread) {
     const existing = this.#messages.find((candidate) => candidate.messageId === message.messageId || candidate.sequence === message.sequence);
     const next = this.#messagesWith(message, existing);
@@ -4121,11 +4541,13 @@ var ChatControllerRuntime = class {
     const unread = this.#unreadCountFor(message, existing, countUnread);
     if (this.#messageStateMatches(next, pendingSends, unread)) return existing ?? message;
     this.#messages = next;
+    this.#advanceContiguousSequence(message);
     this.#pendingSends = Object.freeze(pendingSends);
     this.#unreadCount = unread;
     this.#status = "ready";
     this.#lastError = null;
     this.#publish();
+    if (!this.#catchUpRunning && countUnread) this.#scheduleCatchUp();
     return message;
   }
   #messagesWith(message, existing) {
@@ -4170,6 +4592,7 @@ var ChatControllerRuntime = class {
   }
   #reset() {
     this.#catchUpRequested = false;
+    this.#contiguousSequence = null;
     this.#hasOlder = false;
     this.#historyTruncated = false;
     this.#initialCatchUpComplete = true;
@@ -4213,11 +4636,11 @@ function validateUpload(file, bytes, clientAttachmentId) {
 function bytesFor(file) {
   return "fileName" in file ? Effect4.succeed(file.bytes) : foreign(() => file.arrayBuffer());
 }
-function catchUpRequest(latestSequence, ports) {
+function catchUpRequest(contiguousSequence, latestSequence, ports) {
   const extension = ports.sync.getCollaborationExtensionState();
-  const head = extension.chatHeadSequence;
-  if (!extension.negotiated || head === null || latestSequence !== null && compareChatSequence(latestSequence, head) >= 0) return null;
-  return latestSequence === null ? { kind: "initial", input: { limit: MAX_CHAT_PAGE_SIZE } } : { kind: "newer", input: { afterSequence: latestSequence, limit: MAX_CHAT_PAGE_SIZE } };
+  const head = latestSequence !== null && (extension.chatHeadSequence === null || compareChatSequence(latestSequence, extension.chatHeadSequence) > 0) ? latestSequence : extension.chatHeadSequence;
+  if (!extension.negotiated || head === null || contiguousSequence !== null && compareChatSequence(contiguousSequence, head) >= 0) return null;
+  return contiguousSequence === null ? { kind: "initial", input: { limit: MAX_CHAT_PAGE_SIZE } } : { kind: "newer", input: { afterSequence: contiguousSequence, limit: MAX_CHAT_PAGE_SIZE } };
 }
 function chatError(message) {
   return new SpaceClientError({ code: "chat.payload_invalid", recoverable: false, message });
@@ -4249,7 +4672,10 @@ var makeMediaController = (connection, store, selection, diagnostics) => Effect5
     fork,
     diagnostics
   );
-  yield* connection.setInitialMedia((intent) => controller.captureInitial(intent));
+  yield* connection.setInitialMedia(
+    (intent) => controller.captureInitial(intent),
+    () => controller.initialIntent()
+  );
   yield* Effect5.addFinalizer(() => Effect5.sync(() => controller.dispose()));
   controller.refreshDevicesInBackground();
   return controller;
@@ -4344,14 +4770,22 @@ var MediaControllerRuntime = class {
       Effect5.tapError(() => Effect5.sync(() => operation?.fail("decline_failed")))
     );
   };
-  captureInitial(_intent) {
-    if (!this.#intent.microphone && !this.#intent.camera) return Effect5.succeed(streamFromTracks([]));
-    return foreign2(() => this.#selection.getUserMedia({ audio: this.#intent.microphone, video: this.#intent.camera })).pipe(
+  initialIntent() {
+    return { ...this.#intent };
+  }
+  captureInitial(intent) {
+    if (!intent.microphone && !intent.camera) {
+      this.#intent = { microphone: this.#tracks.has("microphone"), camera: this.#tracks.has("camera") };
+      this.#publish();
+      return Effect5.succeed(streamFromTracks([...this.#tracks.values()]));
+    }
+    return foreign2(() => this.#selection.getUserMedia({ audio: intent.microphone, video: intent.camera })).pipe(
       Effect5.flatMap(
-        (stream) => Effect5.try({ try: () => selectInitialTracks(stream, this.#intent), catch: (cause) => cause }).pipe(
+        (stream) => Effect5.try({ try: () => selectInitialTracks(stream, intent), catch: (cause) => cause }).pipe(
           Effect5.tap(
             (tracks) => Effect5.sync(() => {
               for (const [source, track] of tracks) this.#tracks.set(source, track);
+              this.#intent = { microphone: this.#tracks.has("microphone"), camera: this.#tracks.has("camera") };
               this.#publish();
             })
           ),
@@ -4744,7 +5178,7 @@ var MediaControllerRuntime = class {
     }
   }
   #applyForcedMediaState(ports, snapshot) {
-    if (!snapshot.media || !snapshot.participantId) return;
+    if (!canApplyForcedMediaState(snapshot)) return;
     for (const source of MEDIA_SOURCES) {
       const projected = snapshot.media.items.find((item) => item.participantId === snapshot.participantId && item.source === source);
       if (projected?.publicationId) {
@@ -4953,6 +5387,9 @@ function isAccessInvalid2(cause) {
 function isSyncRejection(cause) {
   return isAccessInvalid2(cause) || cause instanceof V1SyncError && cause.code === "terminal_failure";
 }
+function canApplyForcedMediaState(snapshot) {
+  return !!snapshot.media && !!snapshot.participantId && snapshot.control?.status !== "ended" && snapshot.connection.phase !== "terminal";
+}
 
 // src/space-client/offline-actions.ts
 import { Context as Context7, Effect as Effect6, Layer as Layer7 } from "effect";
@@ -6563,7 +7000,7 @@ var makeSpaceClientCoreLayer = (options, platform = {}) => {
     now: baseDependencies.clock.now,
     setTimeout: baseDependencies.clock.setTimeout,
     clearTimeout: baseDependencies.clock.clearTimeout,
-    release: { id: "chalk-client@4.1.16" }
+    release: { id: "chalk-client@4.1.17" }
   });
   const diagnosticSyncClients = /* @__PURE__ */ new Set();
   const dependencies = {
@@ -6645,6 +7082,7 @@ var SpaceClientCore = class {
   #episodeDiagnosticTracks = /* @__PURE__ */ new Map();
   #handlers = { participantJoined: /* @__PURE__ */ new Set(), participantLeft: /* @__PURE__ */ new Set(), episodeEnded: /* @__PURE__ */ new Set(), screenShareStarted: /* @__PURE__ */ new Set(), screenShareStopped: /* @__PURE__ */ new Set(), error: /* @__PURE__ */ new Set() };
   #disposed = false;
+  #episodeEnded = false;
   #previous;
   #unsubscribeConnection = null;
   #unsubscribeStore = null;
@@ -6678,7 +7116,12 @@ var SpaceClientCore = class {
     this.#previous = this.#store.getSnapshot();
     this.#unsubscribeStore = this.#store.subscribe(() => this.#publishStore());
     this.#unsubscribeConnection = connection.subscribe(() => {
-      this.#store.updateConnection(connection.getSnapshot());
+      const snapshot = connection.getSnapshot();
+      const episode = snapshot.episode ?? this.#store.getSnapshot().connection.episode;
+      this.#store.updateConnection(snapshot);
+      const newlyEnded = snapshot.episodeEnded && !this.#episodeEnded;
+      this.#episodeEnded = snapshot.episodeEnded ?? false;
+      if (newlyEnded) this.#emit("episodeEnded", { episode });
       this.#publishConnectionDiagnostics();
     });
     this.#publishConnectionDiagnostics();
@@ -6708,6 +7151,7 @@ var SpaceClientCore = class {
           this.#syncConnectOperation?.fail("connect_failed");
         })
       ),
+      Effect12.catchTag("ConnectionLifecycleFailure", (failure3) => Effect12.fail(failure3.code === "episode_ended" ? new SpaceClientError({ code: "episode.ended", recoverable: failure3.recoverable, message: failure3.message }) : failure3)),
       Effect12.mapError(normalizeClientError)
     );
   }
@@ -6720,11 +7164,10 @@ var SpaceClientCore = class {
     );
   }
   endEpisode() {
-    return trackedEffect(
-      this.#episodeDiagnostics,
-      "episode.end.authorized",
-      this.#connection.runCommand(({ sync }) => foreign6(() => sync.endEpisode()).pipe(Effect12.tap(() => this.#connection.confirmEpisodeEnded)))
-    ).pipe(Effect12.asVoid, Effect12.mapError(normalizeClientError));
+    return trackedEffect(this.#episodeDiagnostics, "episode.end.authorized", 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)
+    );
   }
   extendEpisode(minutes) {
     return trackedEffect(
@@ -6812,7 +7255,6 @@ var SpaceClientCore = class {
   }
   #emitChanges(previous, next) {
     this.#emitParticipantChanges(previous, next);
-    this.#emitEpisodeEnd(previous, next);
     this.#emitScreenShareChanges(previous, next);
     this.#emitErrorChange(previous, next);
   }
@@ -6822,9 +7264,6 @@ var SpaceClientCore = class {
     for (const participant of after.values()) if (!before.has(participant.participantId)) this.#emit("participantJoined", { participant });
     for (const participant of before.values()) if (!after.has(participant.participantId)) this.#emit("participantLeft", { participant });
   }
-  #emitEpisodeEnd(previous, next) {
-    if (previous.connection.lastError?.code !== "episode.ended" && next.connection.lastError?.code === "episode.ended") this.#emit("episodeEnded", { episode: previous.connection.episode ?? next.connection.episode });
-  }
   #emitScreenShareChanges(previous, next) {
     const previousShares = screenShares(previous);
     const nextShares = screenShares(next);
@@ -6886,7 +7325,7 @@ function diagnosticAccessOperation(request) {
 }
 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), signal: input.request?.signal });
+  return input.options.getAccess({ space: input.options.space.trim(), reason: accessReason(input.request?.reason), replaceMediaConnection: input.request?.replaceMediaConnection ?? false, signal: input.request?.signal });
 }
 function accessReason(reason) {
   if (reason === void 0 || reason === "join") return "join";
@@ -6999,11 +7438,11 @@ export {
   ConnectionPlatformService,
   makeConnectionPlatformLayer,
   makeFakeConnectionPlatformLayer,
+  ChalkWhiteboardV1Error,
   CHALK_CHAT_ATTACHMENT_LIMITS,
   CHALK_CHAT_ATTACHMENT_MIME_TYPES,
   ChalkChatFileError,
   createChalkChatFileHttpTransport,
-  ChalkWhiteboardV1Error,
   createChalkWhiteboardV1FileHttpTransport,
   encodeWhiteboardV1ClientFrame,
   decodeWhiteboardV1ServerFrame,