@q9labsai/chalk-client 4.1.15 → 4.1.17

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

@@ -1,26 +1,38 @@
+import {
+  AccessGrantError,
+  requireParsedAccessGrant,
+  validEpisodeDiagnosticCredential
+} from "./chunk-ZRMGKMX4.js";
 import {
   CloudflareRTKClient,
   CloudflareSFUClient,
-  createCloudflareSFUHTTPTransport
-} from "./chunk-PQNSA7ZN.js";
+  createCloudflareSFUHTTPTransport,
+  describeMediaCaptureError
+} from "./chunk-2DZUHV6I.js";
 import {
+  ChatAttachmentMimeTypeSchema,
+  V1SyncError,
   createBrowserSyncLifecycle,
   createBrowserWebSocketFactory,
   createV1SyncClient
-} from "./chunk-PWUU6T3R.js";
+} from "./chunk-CZUJNAUI.js";
 import {
-  AccessGrantError,
-  requireParsedAccessGrant,
-  validEpisodeDiagnosticCredential
-} from "./chunk-LSDDADCN.js";
+  recordInitialConnection,
+  recordReconnect
+} from "./chunk-RCDXIDCN.js";
+import {
+  normalizeTelemetryAttributes
+} from "./chunk-EWTITNJ3.js";
 import {
   createTraceContext,
+  journeyHeaders,
   parseTraceparent
-} from "./chunk-NKOKY2AE.js";
+} from "./chunk-HW5TTZL2.js";
 
 // src/access/manager.ts
 import { Clock, Context, Data, 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 ConnectionAccessService = class extends Context.Service()("@chalk/client/ConnectionAccess") {
@@ -34,7 +46,7 @@ var makeConnectionAccessLayer = (provider, refreshWindowMs = DEFAULT_REFRESH_WIN
       Effect.tap((result) => Effect.sync(() => notifyAutomaticMediaReplacement(automaticMediaReplacementListeners, result))),
       Effect.map((result) => result.access)
     );
-    const initialize = (reason = "join") => fetch(reason, false, false).pipe(Effect.catchTag("ConnectionAccessFailure", (failure2) => failure2.code === "access.invalid" && SynchronizedRef.getUnsafe(state).access === null ? fetch(reason, false, true) : Effect.fail(failure2)));
+    const initialize = (reason = "join") => fetch(reason, false, false).pipe(Effect.catchTag("ConnectionAccessFailure", (failure3) => failure3.code === "access.invalid" && SynchronizedRef.getUnsafe(state).access === null ? fetch(reason, false, true) : Effect.fail(failure3)));
     const millisecondsUntilRefresh = Effect.gen(function* () {
       const access = yield* SynchronizedRef.get(state);
       if (!access.access) return null;
@@ -70,7 +82,10 @@ function fetchAccessGrant(provider, input) {
     }
     const mediaExpired = currentAccess !== null && expiresAt(currentAccess.media.expiresAt) <= now;
     const shouldReplaceMediaConnection = input.replaceMediaConnection || mediaExpired;
-    const next = yield* provider(connectionAccessRequest(input, shouldReplaceMediaConnection));
+    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),
       catch: (cause) => new ConnectionAccessFailure({ code: "access.invalid", cause })
@@ -139,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,
@@ -168,12 +197,12 @@ var ChalkChatFileError = class extends Error {
   operation;
   code;
   recoverable;
-  constructor(failure2, options) {
-    super(failure2.message, options);
+  constructor(failure3, options) {
+    super(failure3.message, options);
     this.name = "ChalkChatFileError";
-    this.operation = failure2.operation;
-    this.code = failure2.code;
-    this.recoverable = failure2.recoverable;
+    this.operation = failure3.operation;
+    this.code = failure3.code;
+    this.recoverable = failure3.recoverable;
   }
 };
 
@@ -286,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(failure2, options) {
-    super(failure2.message, options);
-    this.name = "ChalkWhiteboardV1Error";
-    this.operation = failure2.operation;
-    this.code = failure2.code;
-    this.recoverable = failure2.recoverable;
-  }
-};
-
 // src/whiteboard/file-http-transport.ts
 function createChalkWhiteboardV1FileHttpTransport(options) {
   const fetchImplementation = options.fetch ?? globalThis.fetch;
@@ -1028,7 +1043,7 @@ var ChalkWhiteboardV1Client = class {
     return () => this.#summaryListeners.delete(listener);
   }
   submitUpdate(input) {
-    this.#assertLive("submit_update");
+    if (!this.#started || !this.#sceneId) this.#assertLive("submit_update");
     if (!this.#canDraw || !this.#capabilities.includes("drawWhiteboard")) {
       throw error(failure("submit_update", "permission_denied", false, "Whiteboard draw permission is required."));
     }
@@ -1042,7 +1057,7 @@ var ChalkWhiteboardV1Client = class {
     });
   }
   sendCursor(input) {
-    if (this.#phase !== "live" || !this.#canDraw) return;
+    if (this.#phase !== "live" || this.#summaryStatus !== "ready" || this.#snapshots.size > 0 || !this.#canDraw) return;
     const now = this.#now();
     if (now - this.#lastCursorAt < 1e3 / WhiteboardV1ProtocolLimits.cursorRatePerSecond) return;
     const frame = { type: "cursor", x: input.x, y: input.y };
@@ -1289,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);
@@ -1296,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;
   }
@@ -1328,6 +1345,7 @@ var ChalkWhiteboardV1Client = class {
     this.#sceneId = frame.scene_id;
     this.#revision = frame.revision;
     this.#publishSummary("ready", null);
+    this.#flushQueuedOperations();
     this.#emit({
       type: "snapshot",
       sceneId: frame.scene_id,
@@ -1375,7 +1393,10 @@ var ChalkWhiteboardV1Client = class {
       deferred = { resolve, reject, settled: false };
     });
     this.#operations.set(frame.operation_id, { pending, deferred, retries: 0 });
-    this.#sendOperation(frame);
+    if (this.#phase === "live" && this.#snapshots.size === 0) {
+      if (this.#waitingForOperations) this.#awaitingOperationIds.add(frame.operation_id);
+      this.#sendOperation(frame);
+    }
     return promise;
   }
   #commit(frame) {
@@ -1423,6 +1444,13 @@ var ChalkWhiteboardV1Client = class {
       rejectDeferred(this.#initialSnapshot, snapshotError);
       this.#initialSnapshot = null;
     }
+    if (frame.recoverable) this.#flushQueuedOperations();
+  }
+  #flushQueuedOperations() {
+    if (this.#phase !== "live" || this.#snapshots.size > 0) return;
+    for (const entry of this.#operations.values()) {
+      if (!this.#awaitingOperationIds.has(entry.pending.operationId)) this.#sendOperation(entry.pending.frame);
+    }
   }
   #scheduleOperationRetry(operationId, entry) {
     if (this.#operationRetryTimers.has(operationId)) return;
@@ -1462,8 +1490,6 @@ var ChalkWhiteboardV1Client = class {
     this.#phase = "connecting";
     this.#waitingForOperations = false;
     this.#participantId = null;
-    this.#capabilities = [];
-    this.#canDraw = false;
     this.#rejectSnapshots(failure("request_snapshot", "unavailable", true, "Whiteboard connection interrupted."));
     this.#publishSummary("recovering", failure("start_scene_subscription", "unavailable", true, "Whiteboard connection interrupted."));
   }
@@ -1701,15 +1727,29 @@ 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 TypeError("Browser media capture is unavailable");
+      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) {
-      if (!mediaDevices?.getDisplayMedia) throw new TypeError("Browser display capture is unavailable");
+      if (!mediaDevices?.getDisplayMedia) throw new DOMException("Browser display capture is unavailable", "NotSupportedError");
       return mediaDevices.getDisplayMedia(constraints);
     },
     async enumerateDevices() {
@@ -1802,12 +1842,14 @@ function createMediaClient(apiBaseURL, input) {
     } : void 0,
     transport: createCloudflareSFUHTTPTransport({
       apiBaseURL,
+      telemetry: input.telemetry,
       credential: input.credential,
       tenantId: subject.tenantId,
       spaceId: subject.spaceId,
       episodeId: subject.episodeId,
       participantId: subject.participantId
     }),
+    recordReconnect: input.recordReconnect,
     onError: input.onFailure,
     ...input.recordRtcSummary ? { onRtcSummary: input.recordRtcSummary } : {},
     onScreenEnded: input.onScreenEnded
@@ -1832,8 +1874,12 @@ function createSFUConnectionMediaClient(client) {
 function bindConnectionMediaClient(client, restart) {
   return {
     setLocalPublicationTarget: client.setLocalPublicationTarget.bind(client),
+    ...client.setLocalSourceIntent ? { setLocalSourceIntent: client.setLocalSourceIntent.bind(client) } : {},
+    ...client.closeForcedLocalPublication ? { closeForcedLocalPublication: client.closeForcedLocalPublication.bind(client) } : {},
     observeLocalPublications: client.observeLocalPublications.bind(client),
     observeRemotePublications: client.observeRemotePublications.bind(client),
+    ...client.remotePublicationsChanged ? { remotePublicationsChanged: client.remotePublicationsChanged.bind(client) } : {},
+    ...client.remotePublicationResumed ? { remotePublicationResumed: client.remotePublicationResumed.bind(client) } : {},
     start: client.start.bind(client),
     stop: client.stop.bind(client),
     restart,
@@ -1849,6 +1895,7 @@ function createSyncClient(syncURL, input) {
     token: input.token,
     mediaPlane: input.media,
     telemetry: input.telemetry,
+    recordReconnect: input.recordReconnect,
     persistenceScope: `${input.access.subject.tenantId}:${input.access.subject.episodeId}:${input.access.subject.participantId}`
   });
 }
@@ -1880,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";
 
@@ -1936,26 +2003,15 @@ var ConnectionDiagnostics = class {
   }
 };
 
-// src/connection/types.ts
-var ConnectionError = class extends Error {
-  code;
-  action;
-  recoverable;
-  constructor(failure2, options) {
-    super(failure2.message, options);
-    this.name = "ConnectionError";
-    this.code = failure2.code;
-    this.action = failure2.action;
-    this.recoverable = failure2.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") {
@@ -1965,8 +2021,8 @@ var makeConnectionLifecycleLayer = (options) => {
   const platform = { ...defaults, ...options.dependencies };
   const access = makeConnectionAccessLayer(
     (request) => Effect2.tryPromise({
-      try: () => Promise.resolve(options.access(request)),
-      catch: (cause) => new ConnectionAccessFailure({ code: "access.unavailable", cause })
+      try: (signal) => Promise.resolve(options.access(request ? { ...request, signal } : void 0)),
+      catch: (cause) => cause instanceof ConnectionAccessFailure ? cause : new ConnectionAccessFailure({ code: accessRejected(cause) ? "access.invalid" : "access.unavailable", cause })
     }),
     options.accessRefreshWindowMs
   );
@@ -2001,32 +2057,65 @@ 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,
       media: null,
       syncSnapshot: null,
+      syncNoticeUnresponsive: false,
       mediaSnapshot: null,
       failure: null,
       initialMedia: (intent) => Effect2.tryPromise({
         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 foreign6 = (operation, code = "internal_error", message = "A browser transport operation failed") => Effect2.tryPromise({ try: operation, catch: (cause) => lifecycleFailure(code, true, message, cause) });
+    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(() => {
@@ -2039,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;
@@ -2077,36 +2157,68 @@ 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();
     });
     const bindSync = (scope, sync) => Effect2.gen(function* () {
       model.syncBindingCleanup?.();
+      model.syncNoticeUnresponsive = false;
       let latestSnapshot = null;
       let snapshotQueued = false;
       const unsubscribe = sync.subscribe((snapshot) => {
+        if (sync === model.sync && snapshot.connection.phase === "live") {
+          const notice = snapshot.connection.noticeUnresponsive === true;
+          if (notice !== model.syncNoticeUnresponsive) {
+            model.syncNoticeUnresponsive = notice;
+            void Effect2.runForkWith(context)(publish());
+          }
+        }
         latestSnapshot = snapshot;
         if (snapshotQueued) return;
         snapshotQueued = true;
@@ -2152,22 +2264,19 @@ 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 effect.pipe(
+      return traceRecovery(step, effect, recordInitialConnection).pipe(
         Effect2.tap(() => Effect2.sync(() => span.end({ state: model.state, epoch: model.epoch, outcome: "succeeded" }))),
         Effect2.tapError(() => Effect2.sync(() => span.end({ state: model.state, epoch: model.epoch, outcome: "failed" })))
       );
@@ -2183,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(
@@ -2194,7 +2306,12 @@ 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 } : {},
               onFailure: () => enqueueBackground(handleMediaFailure()),
               onScreenEnded: () => enqueueBackground(notifyScreenEnded())
@@ -2206,7 +2323,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, telemetry: options.telemetry }),
+            try: () => platform.createSyncClient({ access: grant, token: () => toPromise(access.getSyncToken()), media, telemetry: options.telemetry, recordReconnect: options.recordReconnect }),
             catch: (cause) => accessRejected(cause) ? lifecycleFailure("invalid_access", false, "Access was rejected", cause) : lifecycleFailure("sync_start_failed", true, "The sync layer could not start", cause)
           })
         );
@@ -2216,9 +2333,9 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
           [
             trace(
               "start_media",
-              foreign6(() => media.start(stream), "media_start_failed", "The media layer could not start")
+              foreign7(() => media.start(stream), "media_start_failed", "The media layer could not start")
             ),
-            trace("start_sync", foreign6(() => sync.start(), "sync_start_failed", "The sync layer could not start").pipe(Effect2.andThen(trace("wait_for_sync_live", waitForSyncLive(sync, boundedInteger(options.syncStartupTimeoutMs, START_TIMEOUT_MS, 1, 6e4))))))
+            trace("start_sync", foreign7(() => sync.start(), "sync_start_failed", "The sync layer could not start").pipe(Effect2.andThen(trace("wait_for_sync_live", waitForSyncLive(sync, boundedInteger(options.syncStartupTimeoutMs, START_TIMEOUT_MS, 1, 6e4))))))
           ],
           { concurrency: "unbounded", discard: true }
         );
@@ -2226,23 +2343,26 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
         Effect2.matchEffect({
           onFailure: (cause) => Effect2.gen(function* () {
             stopStream(stream);
-            const failure2 = failureFromCause(cause, "sync_start_failed", "The Connection could not start");
-            model.failure = toFailure(failure2);
+            const failure3 = failureFromCause(cause, "sync_start_failed", "The Connection could not start");
+            model.failure = toFailure(failure3);
             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: failure3.code });
+            const retry = !retried && failure3.code === "invalid_access";
+            if (!retry) yield* recordFailure(failure3);
             yield* stopPorts();
-            if (!retried && failure2.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: failure2.code });
-            return yield* Effect2.fail(failure2);
+            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" });
           })
@@ -2262,43 +2382,118 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
     const leaveIsConfirmed = () => Effect2.gen(function* leaveIsConfirmedEffect() {
       const sync = model.sync;
       if (!sync || model.episodeEndConfirmed || access.currentUnsafe() === null) return true;
-      const leave = foreign6(() => sync.leave()).pipe(Effect2.timeout(LEAVE_TIMEOUT_MS));
+      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)
             );
           }
         })
       );
     });
-    const recover = (kind) => Effect2.gen(function* recoverEffect() {
-      if (!active(model)) return;
-      if (model.recoveryQueued === kind) return;
+    const traceRecovery = (step, operation, recordStep = recordReconnect) => Effect2.gen(function* () {
+      const started = yield* Clock2.currentTimeMillis;
+      recordStep(options.recordReconnect, step, { boundary: "start" });
+      return yield* operation.pipe(
+        Effect2.onExit(
+          (exit) => Clock2.currentTimeMillis.pipe(
+            Effect2.map((now) => {
+              recordStep(options.recordReconnect, step, { boundary: "end", duration_ms: Math.max(0, now - started) }, exit._tag === "Success" ? "succeeded" : "failed");
+            })
+          )
+        )
+      );
+    });
+    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) => ({
@@ -2308,75 +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* 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 recoverMedia = () => Effect2.gen(function* () {
+    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 = (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"));
-      const grant = yield* access.refresh("media_recovery", true).pipe(Effect2.mapError(accessFailure));
+      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;
-      yield* foreign6(() => media.restart(restartInput));
-      model.mediaSnapshot = media.getSnapshot();
+      attempt.expiresAt = (yield* Clock2.currentTimeMillis) + MEDIA_RECOVERY_TIMEOUT_MS;
+      yield* traceRecovery(
+        "media_rebuild",
+        foreign7(() => media.restart(restartInput), "media_start_failed", "Media transport could not restart")
+      );
+      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 }),
-        catch: (cause) => lifecycleFailure("sync_start_failed", true, "The sync layer could not start", cause)
-      });
-      model.sync = sync;
-      yield* bindSync(scope, sync);
-      yield* foreign6(() => 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" || snapshot.connection.phase === "recovering");
-    const failForSnapshot = (failure2) => Effect2.gen(function* failForSnapshotEffect() {
-      model.failure = toFailure(failure2);
+    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");
     });
@@ -2384,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(foreign6(() => 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;
@@ -2419,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;
@@ -2448,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}`);
@@ -2479,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),
@@ -2502,8 +2871,9 @@ function snapshotFor(model, access) {
     state: model.state,
     subject: subjectFor(access),
     episode: episodeFor(access, control),
-    connection: Object.freeze({ sync: syncPhase(model.syncSnapshot?.connection.phase), media: mediaPhase(model.mediaSnapshot?.connection.phase) }),
-    failure: model.failure ? Object.freeze({ ...model.failure }) : null
+    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,
+    episodeEnded: model.episodeEndConfirmed
   });
 }
 function subjectFor(access) {
@@ -2522,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 } });
@@ -2531,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;
@@ -2569,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";
@@ -2578,6 +3003,10 @@ var CONNECTION_ERROR_CODE_MAP = {
   invalid_access: "access.invalid",
   access_unavailable: "access.unavailable",
   permission_denied: "media.permission_denied",
+  device_not_found: "media.device_not_found",
+  device_busy: "media.device_busy",
+  device_constraint_invalid: "media.device_constraint_invalid",
+  media_capture_failed: "media.capture_failed",
   sync_start_failed: "connection.sync_start_failed",
   media_start_failed: "connection.media_start_failed",
   join_cleanup_unconfirmed: "connection.join_cleanup_unconfirmed",
@@ -2610,6 +3039,9 @@ function normalizeClientError(cause, fallback = "client.internal_error") {
       message: cause.message
     });
   }
+  if (cause instanceof V1SyncError && ["signaling_timeout", "negotiation_timeout", "media_timeout"].includes(cause.code)) {
+    return new SpaceClientError({ code: "media.timeout", recoverable: true, message: "Media did not respond in time. Try again." });
+  }
   if (isAccessInvalid(cause)) {
     return new SpaceClientError({ code: "access.invalid", recoverable: true, message: "The access grant was rejected" });
   }
@@ -2633,6 +3065,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 empty = (value) => Object.freeze(value);
 var EMPTY = empty({
   connection: empty({ status: "idle", episode: null, lastError: null }),
@@ -2648,6 +3081,8 @@ var EMPTY = empty({
   }),
   chat: empty({ status: "idle", messages: empty([]), pendingSends: empty([]), readReceipts: empty([]), unreadCount: 0, pagination: empty({ cursor: null, hasOlder: false, historyTruncated: false }), lastError: null }),
   reactions: empty({ active: empty([]) }),
+  recording: empty({ current: null }),
+  offline: empty({ pending: empty([]), decisionNeeded: false, policy: "send" }),
   whiteboard: empty({ open: false, engine: empty({ status: "unsubscribed", sceneId: null, revision: null, presenting: false, error: null }) })
 });
 var SpaceStore = class _SpaceStore {
@@ -2671,9 +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;
-    if (current.status === snapshot.state && sameEpisode(current.episode, snapshot.episode) && sameError(current.lastError, error2)) return;
-    this.#replace("connection", empty({ status: snapshot.state, episode: snapshot.episode, lastError: error2 }));
+    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: sameError(current.lastError, error2) ? current.lastError : error2 }));
   }
   updateSelf(value) {
     this.#replace("self", value);
@@ -2690,6 +3126,12 @@ var SpaceStore = class _SpaceStore {
   updateReactions(value) {
     this.#replace("reactions", value);
   }
+  updateRecording(value) {
+    this.#replace("recording", value);
+  }
+  updateOffline(value) {
+    this.#replace("offline", value);
+  }
   updateWhiteboard(value) {
     this.#replace("whiteboard", value);
   }
@@ -2715,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;
@@ -2727,49 +3178,995 @@ 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/space-client/core.ts
-import { Clock as Clock5, Context as Context11, Duration as Duration2, Effect as Effect10, Layer as Layer11 } from "effect";
-
-// src/space-client/controller-effects.ts
-import { Context as Context10, Effect as Effect9, Layer as Layer10 } from "effect";
-import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
-
-// src/space-client/chat-controller.ts
-import { Context as Context5, Effect as Effect4, Layer as Layer5 } from "effect";
+// src/feedback/types.ts
+var FEEDBACK_EVIDENCE_SCHEMA_VERSION = "FeedbackEvidence/v1";
+var FEEDBACK_REQUEST_SCHEMA_VERSION = "FeedbackReportRequest/v1";
+var FEEDBACK_RECEIPT_SCHEMA_VERSION = "FeedbackReportReceipt/v1";
+var FEEDBACK_SCREENSHOT_SCHEMA_VERSION = "FeedbackScreenshot/v1";
+var FEEDBACK_LOCAL_STATE_REGISTRY_VERSION = "FeedbackLocalState/v1";
+var FEEDBACK_COOKIE_REGISTRY_VERSION = "FeedbackCookies/v1";
+var FEEDBACK_MAX_MESSAGE_BYTES = 8e3;
+var FEEDBACK_MAX_EVIDENCE_BYTES = 128 * 1024;
+var FEEDBACK_MAX_REQUEST_BYTES = 1 << 20;
+var FEEDBACK_MAX_SCREENSHOT_BYTES = 450 * 1024;
+var FEEDBACK_MAX_SCREENSHOT_WIDTH = 1920;
+var FEEDBACK_MAX_SCREENSHOT_HEIGHT = 1080;
+var FEEDBACK_MAX_TELEMETRY_EVENTS = 50;
+var FEEDBACK_MAX_DIAGNOSTIC_EVENTS = 50;
+var FEEDBACK_MAX_LOCAL_STATE_ENTRIES = 32;
+var FEEDBACK_MAX_COOKIE_ENTRIES = 16;
 
-// src/space-client/chat-controller-helpers.ts
-import { sha256 } from "@noble/hashes/sha2.js";
-var MAX_CHAT_PAGE_SIZE = 100;
-var MAX_LOADED_CHAT_MESSAGES = 500;
-var MAX_CHAT_TEXT_BYTES = 16384;
-var MAX_CHAT_TEXT_SCALARS = 4e3;
+// src/feedback/validation.ts
+import { isDiagnosticReference, parseDiagnosticEventDraft, redactDiagnosticAttributes } from "@q9labsai/diagnostics-contracts";
 var encoder3 = new TextEncoder();
-var allowedMimeTypes = new Set(CHALK_CHAT_ATTACHMENT_MIME_TYPES);
-function validateChatMessage(input) {
-  const attachments = input.attachments ?? [];
-  if (input.text.length === 0 && attachments.length === 0) return "A chat message requires text or an attachment";
-  if (Array.from(input.text).length > MAX_CHAT_TEXT_SCALARS || encoder3.encode(input.text).byteLength > MAX_CHAT_TEXT_BYTES) return `Chat text must not exceed ${MAX_CHAT_TEXT_SCALARS} characters or ${MAX_CHAT_TEXT_BYTES} bytes`;
-  if (attachments.length > CHALK_CHAT_ATTACHMENT_LIMITS.maximumPerMessage) return `A chat message supports at most ${CHALK_CHAT_ATTACHMENT_LIMITS.maximumPerMessage} attachments`;
-  if (new Set(attachments.map((attachment) => attachment.attachmentId)).size !== attachments.length) return "Chat attachment IDs must be unique";
-  return attachments.map(validateChatAttachment).find((value) => value !== null) ?? null;
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
+var TRACE_ID_PATTERN = /^(?=.*[1-9a-f])[0-9a-f]{32}$/u;
+var SPAN_ID_PATTERN = /^(?=.*[1-9a-f])[0-9a-f]{16}$/u;
+var TRACEPARENT_PATTERN = /^00-[0-9a-f]{32}-[0-9a-f]{16}-[0-9a-f]{2}$/iu;
+var SAFE_TOKEN_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:@+/=-]{0,127}$/u;
+var DASHBOARD_ACTION_PATTERN = /^[a-z][a-z0-9_-]{0,63}$/u;
+var UNSAFE_VALUE_PATTERN = /(?:https?:\/\/|wss?:\/\/|bearer\s+[a-z0-9._~+\/-]+|-----begin|candidate:|v=0\r?\n|\b(?:\d{1,3}\.){3}\d{1,3}\b|[\w.+-]+@[\w.-]+\.[a-z]{2,})/iu;
+var TELEMETRY_KEYS = ["version", "event_id", "journey_id", "sequence", "occurred_at", "name", "phase", "state", "origin_kind", "first_observed_layer", "upstream_visibility", "parent_event_id", "trace_id", "span_id", "traceparent", "tracestate", "attributes"];
+var TELEMETRY_NAMES = ["journey.started", "journey.phase", "journey.terminal", "journey.linked", "http.request", "sync.frame", "rtc.summary", "diagnostic.timeline"];
+var TELEMETRY_PHASES = ["root", "authentication", "signaling", "media", "recovery", "terminal"];
+var TELEMETRY_STATES = ["started", "in_progress", "succeeded", "failed", "cancelled", "observed"];
+var TELEMETRY_ORIGINS = ["client", "diagnostic", "http", "rtc", "sync"];
+var TELEMETRY_VISIBILITY = ["local", "propagated"];
+var FeedbackValidationError = class extends Error {
+  issues;
+  constructor(message, issues = [{ path: "$", message }]) {
+    super(message);
+    this.name = "FeedbackValidationError";
+    this.issues = issues;
+  }
+};
+function validateFeedbackReportRequest(input) {
+  const issues = [];
+  if (typeof input !== "object" || input === null || Array.isArray(input)) return failure2("$", "expected a feedback request object");
+  checkKeys(input, ["schema_version", "category", "message", "source", "evidence", "screenshot"], issues, "$", false);
+  if (property(input, "schema_version") !== FEEDBACK_REQUEST_SCHEMA_VERSION) issues.push({ path: "$.schema_version", message: "unsupported feedback request schema" });
+  const fields = validateFeedbackRequestFields(input, issues);
+  validateFeedbackScreenshotConsistency(fields, issues);
+  if (!fields.category || !fields.source || !fields.message || !fields.evidence || !fields.screenshot_valid || issues.length > 0) return { ok: false, issues };
+  const request = {
+    schema_version: FEEDBACK_REQUEST_SCHEMA_VERSION,
+    category: fields.category,
+    message: fields.message,
+    source: fields.source,
+    evidence: fields.evidence,
+    ...fields.screenshot ? { screenshot: fields.screenshot } : {}
+  };
+  return validateFeedbackRequestSize(request, issues);
+}
+function validateFeedbackRequestFields(input, issues) {
+  const category = enumValue(property(input, "category"), ["bug", "feature_request", "other"], "$.category", issues);
+  const source = enumValue(property(input, "source"), ["embedded", "chalk_web", "chalk_mobile", "dashboard"], "$.source", issues);
+  const message = validateMessage(property(input, "message"), issues);
+  const evidenceResult = validateFeedbackEvidence(property(input, "evidence"));
+  appendIssues(issues, evidenceResult);
+  const screenshotResult = validateRequestScreenshot(property(input, "screenshot"));
+  appendIssues(issues, screenshotResult);
+  return {
+    category,
+    source,
+    message,
+    evidence: evidenceResult.ok ? evidenceResult.value : void 0,
+    screenshot: screenshotResult.ok ? screenshotResult.value : void 0,
+    screenshot_valid: screenshotResult.ok
+  };
 }
-function validateChatUpload(file, bytes, clientAttachmentId) {
-  const fileName = "fileName" in file ? file.fileName : file.name;
-  const mimeType = "mimeType" in file ? file.mimeType : file.type;
-  const error2 = validateChatAttachment({ attachmentId: clientAttachmentId, fileName, mimeType, byteLength: bytes.byteLength });
-  return error2 ?? { fileName, mimeType };
+function validateRequestScreenshot(input) {
+  return input === void 0 ? { ok: true, value: void 0 } : validateFeedbackScreenshot(input);
+}
+function validateFeedbackScreenshotConsistency(fields, issues) {
+  if (!fields.evidence) return;
+  if (!fields.screenshot && requiresScreenshot(fields.evidence)) {
+    issues.push({ path: "$.screenshot", message: "a captured screenshot payload is required" });
+    return;
+  }
+  if (!fields.screenshot) return;
+  if (!requiresScreenshot(fields.evidence)) issues.push({ path: "$.evidence.screenshot.state", message: "screenshot state must indicate a capture" });
+  if (fields.evidence.screenshot.captured_at !== fields.screenshot.captured_at) issues.push({ path: "$.screenshot.captured_at", message: "screenshot timestamps must match" });
+}
+function requiresScreenshot(evidence) {
+  return evidence.screenshot.state === "captured" || evidence.screenshot.state === "partial";
+}
+function validateFeedbackRequestSize(request, issues) {
+  if (encodedByteLength(request) > FEEDBACK_MAX_REQUEST_BYTES) issues.push({ path: "$", message: "feedback request exceeds 1 MiB" });
+  return issues.length === 0 ? { ok: true, value: request } : { ok: false, issues };
+}
+function appendIssues(issues, result) {
+  if (!result.ok) issues.push(...result.issues);
+}
+function parseFeedbackReportRequest(input) {
+  const result = validateFeedbackReportRequest(input);
+  if (result.ok) return result.value;
+  throw new FeedbackValidationError("Invalid feedback request", result.issues);
+}
+function validateFeedbackEvidence(input) {
+  const issues = [];
+  if (typeof input !== "object" || input === null || Array.isArray(input)) return failure2("$", "expected a feedback evidence object");
+  checkKeys(input, ["schema_version", "collected_at", "app", "sdk", "platform", "connection", "scope", "correlations", "diagnostics", "local_state", "cookies", "screenshot"], issues, "$", false);
+  if (property(input, "schema_version") !== FEEDBACK_EVIDENCE_SCHEMA_VERSION) issues.push({ path: "$.schema_version", message: "unsupported feedback evidence schema" });
+  const app = validateApp(property(input, "app"), issues);
+  const sdk = validateSDK(property(input, "sdk"), issues);
+  const platform = validatePlatform(property(input, "platform"), issues);
+  const connection = validateConnection(property(input, "connection"), issues);
+  const scope = validateScope(property(input, "scope"), issues);
+  const correlations = validateCorrelations(property(input, "correlations"), issues);
+  const diagnostics = validateDiagnostics(property(input, "diagnostics"), issues);
+  const localState = validateLocalState(property(input, "local_state"), issues);
+  const cookies = validateCookies(property(input, "cookies"), issues);
+  const screenshot = validateScreenshotState(property(input, "screenshot"), issues);
+  if (!sdk || !platform || !correlations || !diagnostics || !localState || !cookies || !screenshot || issues.length > 0) return { ok: false, issues };
+  const collectedAt = checkDateTimeValue(property(input, "collected_at"), "$.collected_at", issues);
+  if (!collectedAt) return { ok: false, issues };
+  const evidence = {
+    schema_version: FEEDBACK_EVIDENCE_SCHEMA_VERSION,
+    collected_at: collectedAt,
+    ...app ? { app } : {},
+    sdk,
+    platform,
+    ...connection ? { connection } : {},
+    ...scope ? { scope } : {},
+    correlations,
+    diagnostics,
+    local_state: localState,
+    cookies,
+    screenshot
+  };
+  if (encodedByteLength(evidence) > FEEDBACK_MAX_EVIDENCE_BYTES) return failure2("$", "feedback evidence exceeds 128 KiB");
+  return { ok: true, value: evidence };
+}
+function parseFeedbackEvidence(input) {
+  const result = validateFeedbackEvidence(input);
+  if (result.ok) return result.value;
+  throw new FeedbackValidationError("Invalid feedback evidence", result.issues);
+}
+function validateFeedbackScreenshot(input) {
+  const issues = [];
+  if (typeof input !== "object" || input === null || Array.isArray(input)) return failure2("$", "expected a screenshot object");
+  checkKeys(input, ["schema_version", "mime_type", "width", "height", "captured_at", "data_base64"], issues, "$", false);
+  if (property(input, "schema_version") !== FEEDBACK_SCREENSHOT_SCHEMA_VERSION) issues.push({ path: "$.schema_version", message: "unsupported screenshot schema" });
+  const mimeType = enumValue(property(input, "mime_type"), ["image/jpeg", "image/png", "image/webp"], "$.mime_type", issues);
+  const width = boundedInteger2(property(input, "width"), 1, FEEDBACK_MAX_SCREENSHOT_WIDTH, "$.width", issues);
+  const height = boundedInteger2(property(input, "height"), 1, FEEDBACK_MAX_SCREENSHOT_HEIGHT, "$.height", issues);
+  const capturedAt = property(input, "captured_at");
+  checkDateTime(capturedAt, "$.captured_at", issues);
+  const dataInput = property(input, "data_base64");
+  const data = typeof dataInput === "string" ? dataInput : void 0;
+  if (!data || !validBase64(data)) issues.push({ path: "$.data_base64", message: "screenshot data must be base64" });
+  else if (base64ByteLength(data) > FEEDBACK_MAX_SCREENSHOT_BYTES) issues.push({ path: "$.data_base64", message: "screenshot exceeds 450 KiB" });
+  if (!mimeType || width === void 0 || height === void 0 || typeof capturedAt !== "string" || !data || issues.length > 0) return { ok: false, issues };
+  return { ok: true, value: { schema_version: FEEDBACK_SCREENSHOT_SCHEMA_VERSION, mime_type: mimeType, width, height, captured_at: capturedAt, data_base64: data } };
+}
+function parseFeedbackScreenshot(input) {
+  const result = validateFeedbackScreenshot(input);
+  if (result.ok) return result.value;
+  throw new FeedbackValidationError("Invalid feedback screenshot", result.issues);
+}
+function assertFeedbackReceipt(input) {
+  const issues = [];
+  if (typeof input !== "object" || input === null || Array.isArray(input)) throw new FeedbackValidationError("Invalid feedback receipt");
+  checkKeys(input, ["schema_version", "id", "submitted_at"], issues, "$", false);
+  const schemaVersion = property(input, "schema_version");
+  const id = property(input, "id");
+  const submittedAt = property(input, "submitted_at");
+  if (schemaVersion !== FEEDBACK_RECEIPT_SCHEMA_VERSION) issues.push({ path: "$.schema_version", message: "unsupported receipt schema" });
+  if (!isUUID(id)) issues.push({ path: "$.id", message: "receipt ID is not a valid ID" });
+  checkDateTime(submittedAt, "$.submitted_at", issues);
+  if (issues.length > 0 || typeof id !== "string" || typeof submittedAt !== "string") throw new FeedbackValidationError("Invalid feedback receipt", issues);
+  return { schema_version: FEEDBACK_RECEIPT_SCHEMA_VERSION, id, submitted_at: submittedAt };
+}
+function assertFeedbackMessage(message) {
+  const issues = [];
+  const normalized = validateMessage(message, issues);
+  if (!normalized) throw new FeedbackValidationError("Invalid feedback message", issues);
+  return normalized;
+}
+function validateMessage(value, issues) {
+  if (typeof value !== "string") {
+    issues.push({ path: "$.message", message: "message must be a string" });
+    return void 0;
+  }
+  const message = value.trim();
+  if (invalidMessageLength(message)) issues.push({ path: "$.message", message: "message must be between 1 and 8,000 UTF-8 bytes" });
+  if (hasForbiddenMessageControl(message)) issues.push({ path: "$.message", message: "message contains a forbidden control character" });
+  return hasMessageIssue(issues) ? void 0 : message;
+}
+function invalidMessageLength(message) {
+  const bytes = encoder3.encode(message).byteLength;
+  return bytes < 1 || bytes > FEEDBACK_MAX_MESSAGE_BYTES;
+}
+function hasForbiddenMessageControl(message) {
+  for (const character of message) if (isForbiddenMessageControl(character)) return true;
+  return false;
+}
+function isForbiddenMessageControl(character) {
+  return isControl(character) && character !== "\n" && character !== "\r" && character !== "	";
+}
+function hasMessageIssue(issues) {
+  return issues.some((issue) => issue.path === "$.message");
+}
+function validateApp(input, issues) {
+  if (input === void 0) return void 0;
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    issues.push({ path: "$.app", message: "app must be an object" });
+    return void 0;
+  }
+  checkKeys(input, ["name", "version", "build"], issues, "$.app", false);
+  const name = metadata(property(input, "name"), "$.app.name", issues, true);
+  const version = metadata(property(input, "version"), "$.app.version", issues, false);
+  const build = metadata(property(input, "build"), "$.app.build", issues, false);
+  return name ? { name, ...version ? { version } : {}, ...build ? { build } : {} } : void 0;
+}
+function validateSDK(input, issues) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    issues.push({ path: "$.sdk", message: "sdk must be an object" });
+    return void 0;
+  }
+  checkKeys(input, ["client", "react", "react_native"], issues, "$.sdk", false);
+  const client = metadata(property(input, "client"), "$.sdk.client", issues, true);
+  const react = metadata(property(input, "react"), "$.sdk.react", issues, false);
+  const reactNative = metadata(property(input, "react_native"), "$.sdk.react_native", issues, false);
+  return client ? { client, ...react ? { react } : {}, ...reactNative ? { react_native: reactNative } : {} } : void 0;
+}
+function validatePlatform(input, issues) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    issues.push({ path: "$.platform", message: "platform must be an object" });
+    return void 0;
+  }
+  checkKeys(input, ["kind", "os_name", "os_version", "browser_name", "browser_version", "device_class", "device_model"], issues, "$.platform", false);
+  const kind = enumValue(property(input, "kind"), ["web", "ios", "android", "macos"], "$.platform.kind", issues);
+  const deviceClassInput = property(input, "device_class");
+  const deviceClass = deviceClassInput === void 0 ? void 0 : enumValue(deviceClassInput, ["phone", "tablet", "desktop"], "$.platform.device_class", issues);
+  const values = {
+    os_name: metadata(property(input, "os_name"), "$.platform.os_name", issues, false),
+    os_version: metadata(property(input, "os_version"), "$.platform.os_version", issues, false),
+    browser_name: metadata(property(input, "browser_name"), "$.platform.browser_name", issues, false),
+    browser_version: metadata(property(input, "browser_version"), "$.platform.browser_version", issues, false),
+    device_model: metadata(property(input, "device_model"), "$.platform.device_model", issues, false)
+  };
+  if (!kind) return void 0;
+  return buildFeedbackPlatform(kind, values, deviceClass);
 }
-function chatDigest(bytes) {
-  return Array.from(sha256(new Uint8Array(bytes)), (byte) => byte.toString(16).padStart(2, "0")).join("");
+function buildFeedbackPlatform(kind, values, deviceClass) {
+  return {
+    kind,
+    ...values.os_name ? { os_name: values.os_name } : {},
+    ...values.os_version ? { os_version: values.os_version } : {},
+    ...values.browser_name ? { browser_name: values.browser_name } : {},
+    ...values.browser_version ? { browser_version: values.browser_version } : {},
+    ...deviceClass ? { device_class: deviceClass } : {},
+    ...values.device_model ? { device_model: values.device_model } : {}
+  };
 }
-function chatMessageFor(message) {
-  return Object.freeze({ ...message, attachments: Object.freeze([...message.attachments]) });
+function validateConnection(input, issues) {
+  if (input === void 0) return void 0;
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    issues.push({ path: "$.connection", message: "connection must be an object" });
+    return void 0;
+  }
+  checkKeys(input, ["state", "error_code"], issues, "$.connection", false);
+  const state = safeToken(property(input, "state"), "$.connection.state", issues, true);
+  const errorCode = safeToken(property(input, "error_code"), "$.connection.error_code", issues, false);
+  return state ? { state, ...errorCode ? { error_code: errorCode } : {} } : void 0;
 }
-function chatReceiptFor(receipt) {
-  return Object.freeze({ ...receipt });
+function validateScope(input, issues) {
+  if (input === void 0) return void 0;
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    issues.push({ path: "$.scope", message: "scope must be an object" });
+    return void 0;
+  }
+  checkKeys(input, ["space_id", "episode_id", "participant_id"], issues, "$.scope", false);
+  return buildFeedbackScope(optionalUUID(property(input, "space_id"), "$.scope.space_id", issues), optionalUUID(property(input, "episode_id"), "$.scope.episode_id", issues), optionalUUID(property(input, "participant_id"), "$.scope.participant_id", issues));
 }
-function mergeChatMessage(messages, existing, incoming) {
+function buildFeedbackScope(space, episode, participant) {
+  if (!space && !episode && !participant) return {};
+  return {
+    ...space ? { space_id: space } : {},
+    ...episode ? { episode_id: episode } : {},
+    ...participant ? { participant_id: participant } : {}
+  };
+}
+function validateCorrelations(input, issues) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    issues.push({ path: "$.correlations", message: "correlations must be an object" });
+    return void 0;
+  }
+  checkKeys(input, ["journey_id", "root_journey_id", "trace_id", "span_id", "request_id", "command_id", "diagnostic_reference"], issues, "$.correlations", false);
+  const journey = optionalUUID(property(input, "journey_id"), "$.correlations.journey_id", issues);
+  const root = optionalUUID(property(input, "root_journey_id"), "$.correlations.root_journey_id", issues);
+  const trace = optionalHex(property(input, "trace_id"), TRACE_ID_PATTERN, "$.correlations.trace_id", issues);
+  const span = optionalHex(property(input, "span_id"), SPAN_ID_PATTERN, "$.correlations.span_id", issues);
+  const request = optionalUUID(property(input, "request_id"), "$.correlations.request_id", issues);
+  const command = optionalUUID(property(input, "command_id"), "$.correlations.command_id", issues);
+  const diagnostic = validateDiagnosticReference(property(input, "diagnostic_reference"), issues);
+  return buildFeedbackCorrelations(journey, root, trace, span, request, command, diagnostic);
+}
+function validateDiagnosticReference(input, issues) {
+  if (input === void 0) return void 0;
+  if (typeof input !== "string" || !isDiagnosticReference(input)) {
+    issues.push({ path: "$.correlations.diagnostic_reference", message: "diagnostic reference is malformed" });
+    return void 0;
+  }
+  return input;
+}
+function buildFeedbackCorrelations(journey, root, trace, span, request, command, diagnostic) {
+  return {
+    ...journey ? { journey_id: journey } : {},
+    ...root ? { root_journey_id: root } : {},
+    ...trace ? { trace_id: trace } : {},
+    ...span ? { span_id: span } : {},
+    ...request ? { request_id: request } : {},
+    ...command ? { command_id: command } : {},
+    ...diagnostic ? { diagnostic_reference: diagnostic } : {}
+  };
+}
+function validateDiagnostics(input, issues) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    issues.push({ path: "$.diagnostics", message: "diagnostics must be an object" });
+    return void 0;
+  }
+  checkKeys(input, ["availability", "dropped_count", "telemetry_events", "diagnostic_events"], issues, "$.diagnostics", false);
+  const availability = enumValue(property(input, "availability"), ["available", "disabled", "disposed", "unavailable"], "$.diagnostics.availability", issues);
+  const dropped = boundedInteger2(property(input, "dropped_count"), 0, Number.MAX_SAFE_INTEGER, "$.diagnostics.dropped_count", issues);
+  const telemetry = validateTelemetryEvents(property(input, "telemetry_events"), issues);
+  const diagnostic = validateDiagnosticEvents(property(input, "diagnostic_events"), issues);
+  if (!availability || dropped === void 0 || !telemetry || !diagnostic) return void 0;
+  return { availability, dropped_count: dropped, telemetry_events: telemetry, diagnostic_events: diagnostic };
+}
+function validateTelemetryEvents(input, issues) {
+  if (!Array.isArray(input)) {
+    issues.push({ path: "$.diagnostics.telemetry_events", message: "telemetry_events must be an array" });
+    return void 0;
+  }
+  if (input.length > FEEDBACK_MAX_TELEMETRY_EVENTS) issues.push({ path: "$.diagnostics.telemetry_events", message: "too many telemetry events" });
+  const events = [];
+  input.slice(0, FEEDBACK_MAX_TELEMETRY_EVENTS).forEach((event, index) => {
+    const parsed = sanitizeTelemetryEvent(event, `$.diagnostics.telemetry_events[${index}]`, issues);
+    if (parsed) events.push(parsed);
+  });
+  return events;
+}
+function validateDiagnosticEvents(input, issues) {
+  if (!Array.isArray(input)) {
+    issues.push({ path: "$.diagnostics.diagnostic_events", message: "diagnostic_events must be an array" });
+    return void 0;
+  }
+  if (input.length > FEEDBACK_MAX_DIAGNOSTIC_EVENTS) issues.push({ path: "$.diagnostics.diagnostic_events", message: "too many diagnostic events" });
+  const events = [];
+  input.slice(0, FEEDBACK_MAX_DIAGNOSTIC_EVENTS).forEach((event, index) => {
+    if (typeof event !== "object" || event === null || Array.isArray(event)) {
+      issues.push({ path: `$.diagnostics.diagnostic_events[${index}]`, message: "diagnostic event must be an object" });
+      return;
+    }
+    const attributes = redactDiagnosticAttributes(property(event, "attributes")).attributes;
+    const sanitized = { ...event, ...Object.keys(attributes).length > 0 ? { attributes } : {} };
+    try {
+      events.push(parseDiagnosticEventDraft(sanitized));
+    } catch {
+      issues.push({ path: `$.diagnostics.diagnostic_events[${index}]`, message: "diagnostic event failed the diagnostics contract" });
+    }
+  });
+  return events;
+}
+function sanitizeTelemetryEvent(input, path, issues) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    issues.push({ path, message: "telemetry event must be an object" });
+    return void 0;
+  }
+  checkKeys(input, TELEMETRY_KEYS, issues, path, false);
+  const identity = validateTelemetryEventIdentity(input, path, issues);
+  const shape = validateTelemetryEventShape(input, path, issues);
+  if (!identity || !shape) return void 0;
+  const optional = validateTelemetryEventOptionalFields(input, path, issues);
+  return buildSanitizedTelemetryEvent(identity, shape, optional);
+}
+function buildSanitizedTelemetryEvent(identity, shape, optional) {
+  const event = {
+    version: 1,
+    event_id: identity.eventId,
+    journey_id: identity.journeyId,
+    sequence: identity.sequence,
+    occurred_at: identity.occurredAt,
+    name: shape.name,
+    phase: shape.phase,
+    state: shape.state,
+    origin_kind: shape.origin,
+    first_observed_layer: shape.firstObserved,
+    upstream_visibility: shape.visibility,
+    ...optional.parentEvent ? { parent_event_id: optional.parentEvent } : {},
+    ...optional.traceId ? { trace_id: optional.traceId } : {},
+    ...optional.spanId ? { span_id: optional.spanId } : {},
+    ...optional.traceparent ? { traceparent: optional.traceparent } : {},
+    ...optional.tracestate ? { tracestate: optional.tracestate } : {},
+    ...optional.attributes ? { attributes: optional.attributes } : {}
+  };
+  return isSanitizedTelemetryEvent(event) ? event : void 0;
+}
+function validateTelemetryEventIdentity(input, path, issues) {
+  const version = property(input, "version") === 1;
+  if (!version) issues.push({ path: `${path}.version`, message: "unsupported telemetry version" });
+  const eventId = requiredUUID(property(input, "event_id"), `${path}.event_id`, issues);
+  const journeyId = requiredUUID(property(input, "journey_id"), `${path}.journey_id`, issues);
+  const sequence = boundedInteger2(property(input, "sequence"), 0, Number.MAX_SAFE_INTEGER, `${path}.sequence`, issues);
+  const occurredAt = checkDateTimeValue(property(input, "occurred_at"), `${path}.occurred_at`, issues);
+  if (!version || !eventId || !journeyId || sequence === void 0 || !occurredAt) return void 0;
+  return { eventId, journeyId, sequence, occurredAt };
+}
+function validateTelemetryEventShape(input, path, issues) {
+  const name = enumValue(property(input, "name"), TELEMETRY_NAMES, `${path}.name`, issues);
+  const phase = enumValue(property(input, "phase"), TELEMETRY_PHASES, `${path}.phase`, issues);
+  const state = enumValue(property(input, "state"), TELEMETRY_STATES, `${path}.state`, issues);
+  const origin = enumValue(property(input, "origin_kind"), TELEMETRY_ORIGINS, `${path}.origin_kind`, issues);
+  const firstObserved = enumValue(property(input, "first_observed_layer"), TELEMETRY_ORIGINS, `${path}.first_observed_layer`, issues);
+  const visibility = enumValue(property(input, "upstream_visibility"), TELEMETRY_VISIBILITY, `${path}.upstream_visibility`, issues);
+  if (!name || !phase || !state || !origin || !firstObserved || !visibility) return void 0;
+  return { name, phase, state, origin, firstObserved, visibility };
+}
+function validateTelemetryEventOptionalFields(input, path, issues) {
+  return {
+    parentEvent: optionalUUID(property(input, "parent_event_id"), `${path}.parent_event_id`, issues),
+    traceId: optionalHex(property(input, "trace_id"), TRACE_ID_PATTERN, `${path}.trace_id`, issues),
+    spanId: optionalHex(property(input, "span_id"), SPAN_ID_PATTERN, `${path}.span_id`, issues),
+    traceparent: optionalTraceparent(property(input, "traceparent"), `${path}.traceparent`, issues),
+    tracestate: optionalSafeText(property(input, "tracestate"), `${path}.tracestate`, 512, issues),
+    attributes: sanitizeTelemetryAttributes(property(input, "attributes"), `${path}.attributes`, issues)
+  };
+}
+function isSanitizedTelemetryEvent(value) {
+  switch (value.name) {
+    case "sync.frame":
+      return value.origin_kind === "sync";
+    case "http.request":
+      return value.origin_kind === "http";
+    case "rtc.summary":
+      return value.origin_kind === "rtc";
+    case "diagnostic.timeline":
+      return value.origin_kind === "diagnostic";
+    case "journey.started":
+      return isJourneyStartedEvent(value);
+    case "journey.phase":
+      return isJourneyPhaseEvent(value);
+    case "journey.terminal":
+      return isJourneyTerminalEvent(value);
+    case "journey.linked":
+      return isJourneyLinkedEvent(value);
+  }
+}
+function isJourneyStartedEvent(value) {
+  return value.origin_kind === "client" && value.phase === "root" && value.state === "started";
+}
+function isJourneyPhaseEvent(value) {
+  return value.origin_kind === "client" && value.phase !== "root" && value.phase !== "terminal" && (value.state === "in_progress" || value.state === "observed");
+}
+function isJourneyTerminalEvent(value) {
+  return value.origin_kind === "client" && value.phase === "terminal" && (value.state === "succeeded" || value.state === "failed" || value.state === "cancelled");
+}
+function isJourneyLinkedEvent(value) {
+  return value.origin_kind === "client" && value.phase === "root" && value.state === "observed" && typeof value.parent_event_id === "string";
+}
+function sanitizeTelemetryAttributes(input, path, issues) {
+  if (input === void 0) return void 0;
+  if (!isTelemetryAttributeObject(input)) {
+    issues.push({ path, message: "telemetry attributes are not safe" });
+    return void 0;
+  }
+  const redacted = redactDiagnosticAttributes(input).attributes;
+  const normalized = normalizeTelemetryAttributes(redacted);
+  if (!normalized) return void 0;
+  for (const [key, value] of Object.entries(normalized)) if (typeof value === "string" && (value.length > 256 || isControlText(value) || UNSAFE_VALUE_PATTERN.test(value))) issues.push({ path: `${path}.${key}`, message: "telemetry attribute value is unsafe" });
+  return normalized;
+}
+function isTelemetryAttributeObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  return Object.keys(value).every((key) => {
+    const entry = property(value, key);
+    return typeof entry === "boolean" || typeof entry === "string" || typeof entry === "number" && Number.isFinite(entry);
+  });
+}
+function validateLocalState(input, issues) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    issues.push({ path: "$.local_state", message: "local_state must be an object" });
+    return void 0;
+  }
+  checkKeys(input, ["registry_version", "entries"], issues, "$.local_state", false);
+  if (property(input, "registry_version") !== FEEDBACK_LOCAL_STATE_REGISTRY_VERSION) issues.push({ path: "$.local_state.registry_version", message: "unsupported local state registry" });
+  const entriesInput = property(input, "entries");
+  if (!Array.isArray(entriesInput)) {
+    issues.push({ path: "$.local_state.entries", message: "local state entries must be an array" });
+    return void 0;
+  }
+  if (entriesInput.length > FEEDBACK_MAX_LOCAL_STATE_ENTRIES) issues.push({ path: "$.local_state.entries", message: "too many local state entries" });
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  entriesInput.slice(0, FEEDBACK_MAX_LOCAL_STATE_ENTRIES).forEach((entry, index) => {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+      issues.push({ path: `$.local_state.entries[${index}]`, message: "local state entry must be an object" });
+      return;
+    }
+    checkKeys(entry, ["key", "value"], issues, `$.local_state.entries[${index}]`, false);
+    const key = property(entry, "key");
+    const entryValue = property(entry, "value");
+    if (typeof key !== "string" || key.length === 0 || seen.has(key)) {
+      issues.push({ path: `$.local_state.entries[${index}].key`, message: "local state key is invalid or duplicated" });
+      return;
+    }
+    seen.add(key);
+    if (!validLocalStateEntry(key, entryValue)) issues.push({ path: `$.local_state.entries[${index}]`, message: "local state entry is not allowlisted" });
+    else if (isFeedbackLocalStateValue(entryValue)) entries.push({ key, value: entryValue });
+  });
+  return { registry_version: FEEDBACK_LOCAL_STATE_REGISTRY_VERSION, entries };
+}
+function validateCookies(input, issues) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    issues.push({ path: "$.cookies", message: "cookies must be an object" });
+    return void 0;
+  }
+  checkKeys(input, ["registry_version", "entries"], issues, "$.cookies", false);
+  if (property(input, "registry_version") !== FEEDBACK_COOKIE_REGISTRY_VERSION) issues.push({ path: "$.cookies.registry_version", message: "unsupported cookie registry" });
+  const entriesInput = property(input, "entries");
+  if (!Array.isArray(entriesInput)) {
+    issues.push({ path: "$.cookies.entries", message: "cookie entries must be an array" });
+    return void 0;
+  }
+  if (entriesInput.length > FEEDBACK_MAX_COOKIE_ENTRIES) issues.push({ path: "$.cookies.entries", message: "too many cookie entries" });
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, entry] of entriesInput.slice(0, FEEDBACK_MAX_COOKIE_ENTRIES).entries()) {
+    const parsed = validateCookieEntry(entry, index, seen, issues);
+    if (parsed) entries.push(parsed);
+  }
+  return { registry_version: FEEDBACK_COOKIE_REGISTRY_VERSION, entries };
+}
+function validateCookieEntry(input, index, seen, issues) {
+  const path = `$.cookies.entries[${index}]`;
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    issues.push({ path, message: "cookie entry must be an object" });
+    return void 0;
+  }
+  checkKeys(input, ["name", "present", "value"], issues, path, false);
+  const name = enumValue(property(input, "name"), ["chalk_theme", "chalk_sidebar_state", "account", "csrf"], `${path}.name`, issues);
+  const present = property(input, "present");
+  if (!name || typeof present !== "boolean" || seen.has(name)) {
+    issues.push({ path, message: "cookie entry is invalid or duplicated" });
+    return void 0;
+  }
+  seen.add(name);
+  return buildCookieEntry(name, present, property(input, "value"), path, issues);
+}
+function buildCookieEntry(name, present, input, path, issues) {
+  const value = cookieValue(name, input, `${path}.value`, issues);
+  if (!present && value !== void 0) issues.push({ path: `${path}.value`, message: "absent cookies cannot include values" });
+  return { name, present, ...value !== void 0 ? { value } : {} };
+}
+function cookieValue(name, input, path, issues) {
+  if (input === void 0) return void 0;
+  if (typeof input !== "string") {
+    issues.push({ path, message: "cookie value is invalid" });
+    return void 0;
+  }
+  if (name === "account" || name === "csrf") {
+    issues.push({ path, message: "account and CSRF cookie values are never collected" });
+    return void 0;
+  }
+  if (name === "chalk_theme") {
+    const value2 = ["light", "dark", "system"];
+    const match2 = value2.find((candidate) => candidate === input);
+    if (match2 !== void 0) return match2;
+    issues.push({ path, message: "theme cookie value is invalid" });
+    return void 0;
+  }
+  const value = ["true", "false"];
+  const match = value.find((candidate) => candidate === input);
+  if (match !== void 0) return match;
+  issues.push({ path, message: "sidebar cookie value is invalid" });
+  return void 0;
+}
+function validateScreenshotState(input, issues) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    issues.push({ path: "$.screenshot", message: "screenshot state must be an object" });
+    return void 0;
+  }
+  checkKeys(input, ["state", "captured_at", "failure_code"], issues, "$.screenshot", false);
+  const state = enumValue(property(input, "state"), ["captured", "partial", "removed", "unavailable"], "$.screenshot.state", issues);
+  const failureInput = property(input, "failure_code");
+  const failure3 = failureInput === void 0 ? void 0 : enumValue(failureInput, ["capture_failed", "unsupported", "tainted", "secure_surface", "too_large"], "$.screenshot.failure_code", issues);
+  const capturedAtInput = property(input, "captured_at");
+  const capturedAt = capturedAtInput === void 0 ? void 0 : checkDateTimeValue(capturedAtInput, "$.screenshot.captured_at", issues);
+  validateScreenshotStateConsistency(state, capturedAt, failure3, issues);
+  if (!state) return void 0;
+  return { state, ...capturedAt ? { captured_at: capturedAt } : {}, ...failure3 ? { failure_code: failure3 } : {} };
+}
+function validateScreenshotStateConsistency(state, capturedAt, failure3, issues) {
+  const captured = state === "captured" || state === "partial";
+  if (captured && !capturedAt) issues.push({ path: "$.screenshot.captured_at", message: "captured screenshots require a timestamp" });
+  if (captured && failure3) issues.push({ path: "$.screenshot.failure_code", message: "captured screenshots cannot have a failure code" });
+}
+function validLocalStateEntry(key, value) {
+  if (key === "chalk.tenant-hint") return isUUID(value);
+  if (key === "chalk.web.telemetry.v1" || key === "chalk.mobile.telemetry.v1") return validTelemetrySummary(value);
+  if (key.startsWith("chalk.dashboard-request.")) return DASHBOARD_ACTION_PATTERN.test(key.slice("chalk.dashboard-request.".length)) && value === true;
+  return false;
+}
+function isFeedbackLocalStateValue(value) {
+  if (typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).every((key) => {
+    const entry = property(value, key);
+    return typeof entry === "number" && Number.isFinite(entry);
+  });
+}
+function validTelemetrySummary(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const keys = ["pending_count", "timeline_count", "dropped_count"];
+  if (!keys.some((key) => property(value, key) !== void 0)) return false;
+  return keys.every((key) => {
+    const entry = property(value, key);
+    return entry === void 0 || typeof entry === "number" && Number.isSafeInteger(entry) && entry >= 0 && entry <= 500;
+  });
+}
+function metadata(value, path, issues, required) {
+  if (value === void 0 && !required) return void 0;
+  if (typeof value !== "string" || !isSafeMetadata(value)) {
+    issues.push({ path, message: required ? "metadata is required and unsafe" : "metadata is unsafe" });
+    return void 0;
+  }
+  return value;
+}
+function isSafeMetadata(value) {
+  return value.length > 0 && value.length <= 128 && value.trim() === value && !isControlText(value) && !UNSAFE_VALUE_PATTERN.test(value);
+}
+function safeToken(value, path, issues, required) {
+  if (value === void 0 && !required) return void 0;
+  if (typeof value !== "string" || value.length === 0 || value.length > 128 || !SAFE_TOKEN_PATTERN.test(value) || UNSAFE_VALUE_PATTERN.test(value)) {
+    issues.push({ path, message: required ? "token is required and unsafe" : "token is unsafe" });
+    return void 0;
+  }
+  return value;
+}
+function optionalUUID(value, path, issues) {
+  if (value === void 0) return void 0;
+  return requiredUUID(value, path, issues);
+}
+function requiredUUID(value, path, issues) {
+  if (typeof value !== "string" || !isUUID(value)) {
+    issues.push({ path, message: "expected a non-zero UUID" });
+    return void 0;
+  }
+  return value;
+}
+function optionalHex(value, pattern, path, issues) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !pattern.test(value.toLowerCase()) || value !== value.toLowerCase()) {
+    issues.push({ path, message: "expected a lower-case non-zero hexadecimal ID" });
+    return void 0;
+  }
+  return value;
+}
+function optionalTraceparent(value, path, issues) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !TRACEPARENT_PATTERN.test(value)) {
+    issues.push({ path, message: "traceparent is malformed" });
+    return void 0;
+  }
+  return value;
+}
+function optionalSafeText(value, path, length, issues) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || value.length > length || isControlText(value) || UNSAFE_VALUE_PATTERN.test(value)) {
+    issues.push({ path, message: "text is unsafe" });
+    return void 0;
+  }
+  return value;
+}
+function checkDateTime(value, path, issues) {
+  checkDateTimeValue(value, path, issues);
+}
+function checkDateTimeValue(value, path, issues) {
+  if (typeof value !== "string" || value.length > 64 || !Number.isFinite(Date.parse(value))) {
+    issues.push({ path, message: "expected an ISO date-time" });
+    return void 0;
+  }
+  return value;
+}
+function boundedInteger2(value, minimum, maximum, path, issues) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < minimum || value > maximum) {
+    issues.push({ path, message: "expected a bounded integer" });
+    return void 0;
+  }
+  return value;
+}
+function enumValue(value, values, path, issues) {
+  const match = values.find((candidate) => candidate === value);
+  if (match !== void 0) return match;
+  issues.push({ path, message: `expected one of: ${values.join(", ")}` });
+  return void 0;
+}
+function checkKeys(value, allowed, issues, path, allowNullable) {
+  const allowedSet = new Set(allowed);
+  for (const key of Object.keys(value)) if (!allowedSet.has(key) && !(allowNullable && key === "value")) issues.push({ path: `${path}.${key}`, message: "unknown property" });
+}
+function failure2(path, message) {
+  return { ok: false, issues: [{ path, message }] };
+}
+function property(value, key) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  return Object.prototype.hasOwnProperty.call(value, key) ? Reflect.get(value, key) : void 0;
+}
+function isUUID(value) {
+  return typeof value === "string" && UUID_PATTERN.test(value) && value.replaceAll("0", "").replaceAll("-", "") !== "";
+}
+function validBase64(value) {
+  return value.length > 0 && value.length % 4 === 0 && /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(value);
+}
+function base64ByteLength(value) {
+  const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
+  return Math.floor(value.length * 3 / 4) - padding;
+}
+function encodedByteLength(value) {
+  return encoder3.encode(JSON.stringify(value)).byteLength;
+}
+function isControl(character) {
+  return /\p{Cc}/u.test(character);
+}
+function isControlText(value) {
+  for (const character of value) if (isControl(character)) return true;
+  return false;
+}
+
+// src/feedback/collector.ts
+import { validateDiagnosticEventDraft } from "@q9labsai/diagnostics-contracts";
+
+// src/feedback/context.ts
+function safeSubject(snapshot) {
+  const subject = snapshot.subject;
+  if (!subject) return void 0;
+  return {
+    tenant_id: subject.tenantId,
+    space_id: subject.spaceId,
+    episode_id: subject.episodeId,
+    participant_id: subject.participantId,
+    participant_generation: subject.participantGeneration
+  };
+}
+
+// src/feedback/collector.ts
+function collectFeedbackEvidence(input, context = {}) {
+  const collectedAt = new Date((context.now ?? Date.now)()).toISOString();
+  const evidence = {
+    schema_version: FEEDBACK_EVIDENCE_SCHEMA_VERSION,
+    collected_at: collectedAt,
+    ...input.app ? { app: input.app } : {},
+    sdk: input.sdk,
+    platform: input.platform,
+    ...context.connection ? { connection: context.connection } : {},
+    ...context.scope ? { scope: context.scope } : {},
+    correlations: context.correlations ?? {},
+    diagnostics: context.diagnostics ?? unavailableDiagnostics(),
+    local_state: { registry_version: FEEDBACK_LOCAL_STATE_REGISTRY_VERSION, entries: collectLocalState(input.local_state) },
+    cookies: { registry_version: FEEDBACK_COOKIE_REGISTRY_VERSION, entries: collectCookies(input.cookies) },
+    screenshot: screenshotState(input.screenshot)
+  };
+  return parseFeedbackEvidence(evidence);
+}
+function collectFeedbackEvidenceFromContext(input, context) {
+  const snapshot = context.connection();
+  const subject = safeSubject(snapshot);
+  const activeTelemetry = context.telemetry;
+  const activeDiagnostics = context.diagnosticContext();
+  const correlationContext = activeTelemetry ?? activeDiagnostics;
+  const trace = parseTraceparent(correlationContext?.traceparent);
+  const diagnostics = context.diagnosticSnapshot();
+  const availability = context.diagnosticAvailability();
+  return collectFeedbackEvidence(input, {
+    now: context.now,
+    connection: {
+      state: snapshot.state,
+      ...snapshot.failure?.code ? { error_code: snapshot.failure.code } : {}
+    },
+    ...subject ? {
+      scope: {
+        space_id: subject.space_id,
+        episode_id: subject.episode_id,
+        participant_id: subject.participant_id
+      }
+    } : {},
+    correlations: {
+      ...correlationContext ? { journey_id: correlationContext.journeyId } : {},
+      ...activeTelemetry ? { root_journey_id: activeTelemetry.rootJourneyId } : {},
+      ...trace ? { trace_id: trace.traceId, span_id: trace.spanId } : {}
+    },
+    diagnostics: {
+      availability,
+      dropped_count: diagnostics.dropped,
+      telemetry_events: input.local_state?.telemetry?.events ?? [],
+      diagnostic_events: diagnostics.events.filter(isDiagnosticEvent)
+    }
+  });
+}
+function collectLocalState(input) {
+  if (!input) return [];
+  const entries = [];
+  if (input.telemetry) {
+    const summary = telemetrySummary(input.telemetry);
+    if (summary) entries.push({ key: input.telemetry.storage_key ?? "chalk.web.telemetry.v1", value: summary });
+  }
+  if (input.tenant_hint && validUUID(input.tenant_hint)) entries.push({ key: "chalk.tenant-hint", value: input.tenant_hint });
+  for (const request of input.dashboard_requests ?? []) {
+    if (!request.pending || !/^[a-z][a-z0-9_-]{0,63}$/u.test(request.action)) continue;
+    entries.push({ key: `chalk.dashboard-request.${request.action}`, value: true });
+  }
+  return entries.slice(0, 32);
+}
+function collectCookies(input) {
+  if (!input) return [];
+  const entries = [];
+  if (input.theme !== void 0) entries.push({ name: "chalk_theme", present: true, value: input.theme });
+  if (input.sidebar_state !== void 0) entries.push({ name: "chalk_sidebar_state", present: true, value: input.sidebar_state ? "true" : "false" });
+  if (input.account_present !== void 0) entries.push({ name: "account", present: input.account_present });
+  if (input.csrf_present !== void 0) entries.push({ name: "csrf", present: input.csrf_present });
+  return entries;
+}
+function telemetrySummary(input) {
+  const summary = {
+    ...input.pending_count !== void 0 && boundedCount(input.pending_count) ? { pending_count: input.pending_count } : {},
+    ...input.timeline_count !== void 0 && boundedCount(input.timeline_count) ? { timeline_count: input.timeline_count } : {},
+    ...input.dropped_count !== void 0 && boundedCount(input.dropped_count) ? { dropped_count: input.dropped_count } : {}
+  };
+  return Object.keys(summary).length > 0 ? summary : void 0;
+}
+function boundedCount(value) {
+  return Number.isSafeInteger(value) && value >= 0 && value <= 500;
+}
+function screenshotState(input) {
+  if (!input) return { state: "unavailable", failure_code: "unsupported" };
+  if (input.state === "captured" || input.state === "partial") return { state: input.state, captured_at: input.captured_at };
+  return "failure_code" in input && input.failure_code ? { state: input.state, failure_code: input.failure_code } : { state: input.state };
+}
+function unavailableDiagnostics() {
+  return { availability: "unavailable", dropped_count: 0, telemetry_events: [], diagnostic_events: [] };
+}
+function isDiagnosticEvent(value) {
+  return validateDiagnosticEventDraft(value).ok;
+}
+function validUUID(value) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu.test(value) && value.replaceAll("0", "").replaceAll("-", "") !== "";
+}
+
+// src/feedback/transport.ts
+var FeedbackTransportError = class extends Error {
+  code;
+  status;
+  recoverable;
+  constructor(input) {
+    super(input.message);
+    this.name = "FeedbackTransportError";
+    this.code = input.code;
+    this.recoverable = input.recoverable;
+    this.status = input.status;
+  }
+};
+function createFeedbackTransport(options) {
+  const fetchImplementation = options.fetch ?? globalThis.fetch;
+  const baseUrl = options.baseUrl.replace(/\/+$/u, "");
+  return {
+    send: async ({ request, idempotencyKey }) => {
+      const parsedRequest = parseFeedbackReportRequest(request);
+      validateTransportBounds(parsedRequest);
+      validateIdempotencyKey(idempotencyKey);
+      const credential = options.credential();
+      if (!credential) throw new FeedbackTransportError({ code: "unauthenticated", recoverable: false, message: "Feedback authentication is unavailable.", status: 401 });
+      const headers = feedbackHeaders(idempotencyKey, credential.token, options.telemetry?.());
+      const response = await sendFeedbackRequest(fetchImplementation, `${baseUrl}/v1/feedback-reports`, headers, parsedRequest);
+      return parseFeedbackResponse(response);
+    }
+  };
+}
+function validateIdempotencyKey(idempotencyKey) {
+  if (idempotencyKey.length < 16 || idempotencyKey.length > 128 || !/^[A-Za-z0-9_-]+$/u.test(idempotencyKey)) throw new FeedbackTransportError({ code: "invalid_request", recoverable: false, message: "Feedback idempotency key is invalid.", status: 400 });
+}
+function feedbackHeaders(idempotencyKey, credentialToken, telemetry) {
+  const headers = new Headers({ "content-type": "application/json", authorization: `Bearer ${credentialToken}`, "idempotency-key": idempotencyKey });
+  if (!telemetry) return headers;
+  for (const [key, value] of Object.entries(journeyHeaders(telemetry))) headers.set(key, value);
+  return headers;
+}
+async function sendFeedbackRequest(fetchImplementation, url, headers, request) {
+  try {
+    return await fetchImplementation(url, { method: "POST", headers, body: JSON.stringify(request) });
+  } catch {
+    throw new FeedbackTransportError({ code: "unavailable", recoverable: true, message: "Feedback service is unavailable." });
+  }
+}
+async function parseFeedbackResponse(response) {
+  if (!response.ok) throw responseError3(response.status);
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    throw new FeedbackTransportError({ code: "invalid_response", recoverable: true, message: "Feedback service returned an invalid receipt.", status: response.status });
+  }
+  try {
+    return assertFeedbackReceipt(body);
+  } catch {
+    throw new FeedbackTransportError({ code: "invalid_response", recoverable: true, message: "Feedback service returned an invalid receipt.", status: response.status });
+  }
+}
+function validateTransportBounds(request) {
+  const evidenceBytes = new TextEncoder().encode(JSON.stringify(request.evidence)).byteLength;
+  const requestBytes = new TextEncoder().encode(JSON.stringify(request)).byteLength;
+  if (evidenceBytes > FEEDBACK_MAX_EVIDENCE_BYTES) throw new FeedbackTransportError({ code: "invalid_request", recoverable: false, message: "Feedback evidence exceeds the size limit." });
+  if (requestBytes > FEEDBACK_MAX_REQUEST_BYTES) throw new FeedbackTransportError({ code: "invalid_request", recoverable: false, message: "Feedback request exceeds the size limit." });
+}
+function responseError3(status) {
+  if (status === 400) return new FeedbackTransportError({ code: "invalid_request", recoverable: false, message: "Feedback request was rejected.", status });
+  if (status === 413) return new FeedbackTransportError({ code: "invalid_request", recoverable: false, message: "Feedback request exceeds the size limit.", status });
+  if (status === 401) return new FeedbackTransportError({ code: "unauthenticated", recoverable: false, message: "Feedback authentication was rejected.", status });
+  if (status === 403) return new FeedbackTransportError({ code: "forbidden", recoverable: false, message: "Feedback submission is not allowed.", status });
+  if (status === 409) return new FeedbackTransportError({ code: "conflict", recoverable: false, message: "Feedback idempotency key conflicts with another submission.", status });
+  if (status === 429) return new FeedbackTransportError({ code: "rate_limited", recoverable: true, message: "Feedback submissions are temporarily limited.", status });
+  return new FeedbackTransportError({ code: "unavailable", recoverable: true, message: "Feedback service is unavailable.", status });
+}
+
+// src/space-client/core.ts
+import { Clock as Clock5, Context as Context13, Duration as Duration2, Effect as Effect12, Layer as Layer13 } from "effect";
+
+// src/space-client/controller-effects.ts
+import { Context as Context12, Effect as Effect11, Layer as Layer12 } from "effect";
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+
+// src/space-client/chat-controller.ts
+import { Context as Context5, Effect as Effect4, Layer as Layer5 } from "effect";
+
+// src/space-client/chat-controller-helpers.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+var MAX_CHAT_PAGE_SIZE = 100;
+var MAX_LOADED_CHAT_MESSAGES = 500;
+var MAX_CHAT_TEXT_BYTES = 16384;
+var MAX_CHAT_TEXT_SCALARS = 4e3;
+var encoder4 = new TextEncoder();
+var allowedMimeTypes = new Set(CHALK_CHAT_ATTACHMENT_MIME_TYPES);
+function validateChatMessage(input) {
+  const attachments = input.attachments ?? [];
+  if (input.text.length === 0 && attachments.length === 0) return "A chat message requires text or an attachment";
+  if (Array.from(input.text).length > MAX_CHAT_TEXT_SCALARS || encoder4.encode(input.text).byteLength > MAX_CHAT_TEXT_BYTES) return `Chat text must not exceed ${MAX_CHAT_TEXT_SCALARS} characters or ${MAX_CHAT_TEXT_BYTES} bytes`;
+  if (attachments.length > CHALK_CHAT_ATTACHMENT_LIMITS.maximumPerMessage) return `A chat message supports at most ${CHALK_CHAT_ATTACHMENT_LIMITS.maximumPerMessage} attachments`;
+  if (new Set(attachments.map((attachment2) => attachment2.attachmentId)).size !== attachments.length) return "Chat attachment IDs must be unique";
+  return attachments.map(validateChatAttachment).find((value) => value !== null) ?? null;
+}
+function validateChatUpload(file, bytes, clientAttachmentId) {
+  const fileName = "fileName" in file ? file.fileName : file.name;
+  const mimeType = "mimeType" in file ? file.mimeType : file.type;
+  const error2 = validateChatAttachment({ attachmentId: clientAttachmentId, fileName, mimeType, byteLength: bytes.byteLength });
+  return error2 ?? { fileName, mimeType };
+}
+function chatDigest(bytes) {
+  return Array.from(sha256(new Uint8Array(bytes)), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function chatMessageFor(message) {
+  return Object.freeze({ ...message, attachments: Object.freeze([...message.attachments]) });
+}
+function chatReceiptFor(receipt) {
+  return Object.freeze({ ...receipt });
+}
+function mergeChatMessage(messages, existing, incoming) {
   if (sameChatMessage(existing, incoming)) return messages;
   return Object.freeze(
     messages.map((message) => message === existing ? incoming : message).sort((left, right) => compareChatSequence(left.sequence, right.sequence)).slice(-MAX_LOADED_CHAT_MESSAGES)
@@ -2782,16 +4179,16 @@ function compareChatSequence(left, right) {
   const normalizedRight = right.replace(/^0+/u, "") || "0";
   return normalizedLeft.length === normalizedRight.length ? normalizedLeft < normalizedRight ? -1 : 1 : normalizedLeft.length - normalizedRight.length;
 }
-function validateChatAttachment(attachment) {
-  const fileNameBytes = encoder3.encode(attachment.fileName).byteLength;
-  if (!attachment.attachmentId || fileNameBytes < 1 || fileNameBytes > CHALK_CHAT_ATTACHMENT_LIMITS.maximumFileNameBytes) return "Chat attachment metadata is invalid";
-  if (!Number.isSafeInteger(attachment.byteLength) || attachment.byteLength < 1 || attachment.byteLength > CHALK_CHAT_ATTACHMENT_LIMITS.maximumByteLength) return "Chat attachment metadata is invalid";
-  return allowedMimeTypes.has(attachment.mimeType) ? null : "Chat attachment MIME type is not allowed";
+function validateChatAttachment(attachment2) {
+  const fileNameBytes = encoder4.encode(attachment2.fileName).byteLength;
+  if (!attachment2.attachmentId || fileNameBytes < 1 || fileNameBytes > CHALK_CHAT_ATTACHMENT_LIMITS.maximumFileNameBytes) return "Chat attachment metadata is invalid";
+  if (!Number.isSafeInteger(attachment2.byteLength) || attachment2.byteLength < 1 || attachment2.byteLength > CHALK_CHAT_ATTACHMENT_LIMITS.maximumByteLength) return "Chat attachment metadata is invalid";
+  return allowedMimeTypes.has(attachment2.mimeType) ? null : "Chat attachment MIME type is not allowed";
 }
 function sameChatMessage(left, right) {
-  return left.messageId === right.messageId && left.clientMessageId === right.clientMessageId && left.sequence === right.sequence && left.participantId === right.participantId && left.displayName === right.displayName && left.text === right.text && left.createdAt === right.createdAt && left.attachments.length === right.attachments.length && left.attachments.every((attachment, index) => {
+  return left.messageId === right.messageId && left.clientMessageId === right.clientMessageId && left.sequence === right.sequence && left.participantId === right.participantId && left.displayName === right.displayName && left.text === right.text && left.createdAt === right.createdAt && left.attachments.length === right.attachments.length && left.attachments.every((attachment2, index) => {
     const candidate = right.attachments[index];
-    return candidate?.attachmentId === attachment.attachmentId && candidate.fileName === attachment.fileName && candidate.mimeType === attachment.mimeType && candidate.byteLength === attachment.byteLength;
+    return candidate?.attachmentId === attachment2.attachmentId && candidate.fileName === attachment2.fileName && candidate.mimeType === attachment2.mimeType && candidate.byteLength === attachment2.byteLength;
   });
 }
 
@@ -2807,7 +4204,7 @@ var makeChatController = (input) => Effect4.gen(function* () {
   const controller = yield* Effect4.sync(() => {
     let instance = null;
     const transport = input.createTransport?.({ token: () => Effect4.runPromiseWith(context)(input.connection.getSyncToken()) }) ?? null;
-    instance = new ChatControllerRuntime(input.connection, input.store, transport, input.apiBaseUrl ?? "https://api.chalkmeet.com", input.fetch ?? globalThis.fetch, fork, input.episodeDiagnostics);
+    instance = new ChatControllerRuntime(input.connection, input.store, transport, input.apiBaseUrl ?? "https://api.chalkmeet.com", input.fetch ?? globalThis.fetch, fork, input.episodeDiagnostics, input.offline);
     return instance;
   });
   yield* Effect4.addFinalizer(() => Effect4.sync(() => controller.dispose()));
@@ -2821,8 +4218,10 @@ var ChatControllerRuntime = class {
   #fetch;
   #fork;
   #diagnostics;
+  #offline;
   #catchUpRunning = false;
   #catchUpRequested = false;
+  #contiguousSequence = null;
   #hasOlder = false;
   #historyTruncated = false;
   #initialCatchUpComplete = true;
@@ -2838,7 +4237,8 @@ var ChatControllerRuntime = class {
   #unsubscribeConnection = null;
   #unsubscribeEvents = null;
   #unsubscribeSnapshot = null;
-  constructor(connection, store, transport, apiBaseUrl, fetch, fork, diagnostics) {
+  constructor(connection, store, transport, apiBaseUrl, fetch, fork, diagnostics, offline) {
+    this.#offline = offline;
     this.#apiBaseUrl = apiBaseUrl.replace(/\/+$/u, "");
     this.#connection = connection;
     this.#store = store;
@@ -2854,9 +4254,12 @@ var ChatControllerRuntime = class {
       Effect4.tap(() => Effect4.sync(() => operation?.observe("observed", "validation"))),
       Effect4.map((attachments) => ({ clientMessageId: this.#connection.createId(), attachments })),
       Effect4.flatMap(({ clientMessageId, attachments }) => {
-        this.#upsertPending(clientMessageId, input.text, attachments, "sending", null);
+        const command = this.#connection.runCommand(({ sync }) => foreign(() => sync.sendChatMessage({ text: input.text, attachments, clientMessageId })));
+        const sendNow = () => Effect4.sync(() => this.#upsertPending(clientMessageId, input.text, attachments, "sending", null)).pipe(Effect4.andThen(command));
+        const held = this.#offline?.hold({ kind: "chat_message", text: input.text, clientMessageId, attachments }, sendNow);
+        if (held) this.#upsertPending(clientMessageId, input.text, attachments, "queued", null);
         operation?.observe("observed", "authorization");
-        return this.#connection.runCommand(({ sync }) => foreign(() => sync.sendChatMessage({ text: input.text, attachments, clientMessageId }))).pipe(Effect4.tap(() => Effect4.sync(() => operation?.observe("observed", "durable_commit")))).pipe(
+        return (held ?? sendNow()).pipe(Effect4.tap(() => Effect4.sync(() => operation?.observe("observed", "durable_commit")))).pipe(
           Effect4.map(chatMessageFor),
           Effect4.tap(() => Effect4.sync(() => this.#removePending(clientMessageId))),
           Effect4.map((message) => this.#observeMessage(message, false)),
@@ -2870,7 +4273,8 @@ var ChatControllerRuntime = class {
           Effect4.catch((cause) => {
             const error2 = normalizeClientError(cause, "chat.payload_invalid");
             return Effect4.sync(() => {
-              this.#upsertPending(clientMessageId, input.text, attachments, "failed", failureFromError(error2));
+              if (error2.code === "offline.discarded") this.#removePending(clientMessageId);
+              else this.#upsertPending(clientMessageId, input.text, attachments, "failed", failureFromError(error2));
               operation?.fail("send_failed");
             }).pipe(Effect4.andThen(Effect4.fail(error2)));
           })
@@ -2930,6 +4334,7 @@ var ChatControllerRuntime = class {
     });
   };
   upload = (file) => {
+    const fetch = this.#fetch;
     const prepareOperation = this.#diagnostics?.startOperation("chat.attachment.prepare");
     return Effect4.suspend(() => {
       if (!this.#transport) {
@@ -2950,7 +4355,7 @@ var ChatControllerRuntime = class {
                       prepareOperation?.succeed();
                     }).pipe(
                       Effect4.andThen(
-                        foreign(() => this.#fetch(upload.uploadUrl, { method: upload.method, headers: upload.headers, body: bytes })).pipe(
+                        foreign(() => fetch(upload.uploadUrl, { method: upload.method, headers: upload.headers, body: bytes })).pipe(
                           Effect4.flatMap((response) => {
                             const commitOperation = this.#diagnostics?.startOperation("chat.attachment.commit");
                             if (!response.ok) {
@@ -2988,7 +4393,11 @@ var ChatControllerRuntime = class {
       );
     });
   };
-  url = (attachment) => `${this.#apiBaseUrl}/v1/chat/attachments/${encodeURIComponent(attachment.attachmentId)}/download`;
+  url = (attachment2) => `${this.#apiBaseUrl}/v1/chat/attachments/${encodeURIComponent(attachment2.attachmentId)}/download`;
+  resolveUrl = (attachment2) => Effect4.suspend(() => {
+    if (!this.#transport) return Effect4.fail(new SpaceClientError({ code: "collaboration.unavailable", recoverable: false, message: "Chat file download is unavailable" }));
+    return this.#connection.runPortCommand(() => foreign(() => this.#transport.getDownloadUrl(attachment2.attachmentId)).pipe(Effect4.map((descriptor) => descriptor.downloadUrl))).pipe(Effect4.mapError(normalizeClientError));
+  });
   dispose() {
     this.#unsubscribeConnection?.();
     this.#unsubscribeConnection = null;
@@ -3006,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));
@@ -3018,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;
@@ -3038,7 +4453,6 @@ var ChatControllerRuntime = class {
         Effect4.ensuring(
           Effect4.sync(() => {
             this.#catchUpRunning = false;
-            this.#initialCatchUpComplete = true;
             if (this.#catchUpRequested) {
               this.#catchUpRequested = false;
               this.#scheduleCatchUp();
@@ -3051,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;
         })
       );
     });
@@ -3071,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) {
@@ -3091,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);
@@ -3100,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) {
@@ -3149,6 +4592,7 @@ var ChatControllerRuntime = class {
   }
   #reset() {
     this.#catchUpRequested = false;
+    this.#contiguousSequence = null;
     this.#hasOlder = false;
     this.#historyTruncated = false;
     this.#initialCatchUpComplete = true;
@@ -3190,13 +4634,13 @@ function validateUpload(file, bytes, clientAttachmentId) {
   return upload;
 }
 function bytesFor(file) {
-  return "bytes" in file ? Effect4.succeed(file.bytes) : foreign(() => file.arrayBuffer());
+  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 });
@@ -3228,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;
@@ -3242,6 +4689,10 @@ var MediaControllerRuntime = class {
   #fork;
   #diagnostics;
   #tracks = /* @__PURE__ */ new Map();
+  #observedPublicationIds = /* @__PURE__ */ new Map();
+  #intentRevisions = /* @__PURE__ */ new Map();
+  #pendingEnables = /* @__PURE__ */ new Map();
+  #pendingSources = /* @__PURE__ */ new Set();
   #requestGenerations = /* @__PURE__ */ new Map();
   #intent = { microphone: true, camera: true };
   #requests = Object.freeze([]);
@@ -3319,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();
             })
           ),
@@ -3368,161 +4827,268 @@ var MediaControllerRuntime = class {
   #set(source, enabled) {
     const operation = this.#diagnostics?.startOperation(`${source}.${enabled ? "publish" : "unpublish"}`);
     operation?.observe("observed", "intent");
-    return this.#serialize(
-      source,
-      this.#connection.runCommand((ports) => {
-        const previousIntent = this.#intent[source];
-        this.#intent[source] = enabled;
-        let captured = null;
-        let prepared = false;
-        const action = source === "microphone" ? "setMicrophoneEnabled" : "setCameraEnabled";
-        return Effect5.suspend(() => {
-          const acquire = enabled && !this.#tracks.has(source) ? this.#captureSource(source).pipe(
-            Effect5.tap(
-              (track) => Effect5.sync(() => {
-                captured = track;
-                try {
-                  this.#assertActivePorts(ports, action);
-                } catch (cause) {
-                  track.stop();
-                  throw cause;
-                }
-                this.#tracks.set(source, track);
-                ports.media.prepareLocalTrack(source, track);
-                prepared = true;
-                operation?.observe("observed", "local_track_state");
-                this.#publish();
-              })
-            )
-          ) : Effect5.void;
-          return acquire.pipe(
-            Effect5.asVoid,
-            Effect5.tap(() => Effect5.sync(() => operation?.observe("observed", "local_track_state"))),
-            Effect5.andThen(source === "microphone" ? foreign2(() => ports.sync.setMicrophoneEnabled(enabled)) : foreign2(() => ports.sync.setCameraEnabled(enabled))),
-            Effect5.tap(() => Effect5.sync(() => operation?.observe("observed", "sync_commit"))),
-            Effect5.tap(() => Effect5.sync(() => this.#assertActivePorts(ports, action))),
-            Effect5.tap(
-              () => Effect5.sync(() => {
-                operation?.observe("observed", "sfu_publication");
-                operation?.succeed();
-              })
-            ),
-            Effect5.asVoid,
-            Effect5.catch(
-              (cause) => this.#rollbackCapture({
-                action,
-                cause,
-                fallback: Effect5.void,
-                media: ports.media,
-                permissionMessage: `${source} permission was denied`,
-                prepared,
-                restoreIntent: () => {
-                  this.#intent[source] = previousIntent;
-                },
-                source,
-                track: captured
-              })
-            )
-          );
-        });
-      })
+    let previousIntent = this.#intent[source];
+    let intentRevision = 0;
+    let earlyPause = null;
+    const localPause = Effect5.suspend(() => {
+      previousIntent = this.#intent[source];
+      intentRevision = (this.#intentRevisions.get(source) ?? 0) + 1;
+      this.#intentRevisions.set(source, intentRevision);
+      this.#intent[source] = enabled;
+      if (enabled) this.#pendingEnables.set(source, intentRevision);
+      this.#ports?.media.setLocalSourceIntent?.(source, enabled);
+      if (!enabled && this.#ports) earlyPause = this.#beginLocalPause(this.#ports, source);
+      return Effect5.void;
+    });
+    return localPause.pipe(
+      Effect5.andThen(
+        this.#serialize(
+          source,
+          this.#connection.runCommand((ports) => {
+            let captured = null;
+            let prepared = false;
+            const action = source === "microphone" ? "setMicrophoneEnabled" : "setCameraEnabled";
+            return Effect5.suspend(() => {
+              if (!enabled) {
+                let paused = false;
+                return (earlyPause ? foreign2(() => earlyPause) : this.#localTarget(ports, source, false)).pipe(
+                  Effect5.tap(
+                    () => Effect5.sync(() => {
+                      paused = true;
+                    })
+                  ),
+                  Effect5.tap(() => Effect5.sync(() => operation?.observe("observed", "local_track_state"))),
+                  Effect5.andThen(source === "microphone" ? foreign2(() => ports.sync.setMicrophoneEnabled(false)) : foreign2(() => ports.sync.setCameraEnabled(false))),
+                  Effect5.tap(() => Effect5.sync(() => operation?.observe("observed", "sync_commit"))),
+                  Effect5.tap(() => Effect5.sync(() => operation?.succeed())),
+                  Effect5.asVoid,
+                  Effect5.catch((cause) => {
+                    if (paused && !isSyncRejection(cause) || this.#intentRevisions.get(source) !== intentRevision) return Effect5.fail(cause);
+                    this.#intent[source] = previousIntent;
+                    ports.media.setLocalSourceIntent?.(source, previousIntent);
+                    return this.#localTarget(ports, source, previousIntent).pipe(
+                      Effect5.catch(() => Effect5.void),
+                      Effect5.andThen(Effect5.fail(cause))
+                    );
+                  })
+                );
+              }
+              const acquire = enabled && !this.#tracks.has(source) ? this.#captureSource(source).pipe(
+                Effect5.tap(
+                  (track) => Effect5.sync(() => {
+                    captured = track;
+                    try {
+                      this.#assertActivePorts(ports, action);
+                    } catch (cause) {
+                      track.stop();
+                      throw cause;
+                    }
+                    this.#tracks.set(source, track);
+                    ports.media.prepareLocalTrack(source, track);
+                    prepared = true;
+                    operation?.observe("observed", "local_track_state");
+                    this.#publish();
+                  })
+                )
+              ) : Effect5.void;
+              return acquire.pipe(
+                Effect5.asVoid,
+                Effect5.tap(() => Effect5.sync(() => operation?.observe("observed", "local_track_state"))),
+                Effect5.andThen(source === "microphone" ? foreign2(() => ports.sync.setMicrophoneEnabled(enabled)) : foreign2(() => ports.sync.setCameraEnabled(enabled))),
+                Effect5.tap(() => Effect5.sync(() => operation?.observe("observed", "sync_commit"))),
+                Effect5.tap(() => Effect5.sync(() => this.#assertActivePorts(ports, action))),
+                Effect5.tap(
+                  () => Effect5.sync(() => {
+                    operation?.observe("observed", "sfu_publication");
+                    operation?.succeed();
+                  })
+                ),
+                Effect5.asVoid,
+                Effect5.catch(
+                  (cause) => this.#rollbackCapture({
+                    action,
+                    cause,
+                    fallback: Effect5.void,
+                    media: ports.media,
+                    permissionMessage: `${source} permission was denied`,
+                    prepared,
+                    restoreIntent: () => {
+                      if (this.#intentRevisions.get(source) === intentRevision) this.#intent[source] = previousIntent;
+                    },
+                    source,
+                    track: captured
+                  })
+                )
+              );
+            });
+          })
+        )
+      )
     ).pipe(
       Effect5.mapError(normalizeClientError),
-      Effect5.tapError(() => Effect5.sync(() => operation?.fail("media_failed")))
+      Effect5.tapError(() => Effect5.sync(() => operation?.fail("media_failed"))),
+      Effect5.ensuring(
+        Effect5.sync(() => {
+          if (this.#pendingEnables.get(source) === intentRevision) this.#pendingEnables.delete(source);
+        })
+      )
     );
   }
   #startScreen() {
     const operation = this.#diagnostics?.startOperation("screen.start");
-    return this.#serialize(
-      "screen",
-      this.#connection.runCommand((ports) => {
-        let stream = null;
-        let track = null;
-        let prepared = false;
-        return Effect5.suspend(() => {
-          if (this.#tracks.has("screen")) {
-            operation?.notObservable("permission", "already_active");
-            operation?.notObservable("track_acquisition", "already_active");
-            operation?.notObservable("sync_commit", "already_active");
-            operation?.notObservable("sfu_publication", "already_active");
-            operation?.succeed();
-            return Effect5.void;
-          }
-          return foreign2(() => this.#selection.getDisplayMedia({ video: true, audio: false })).pipe(
-            Effect5.tap(() => Effect5.sync(() => operation?.observe("observed", "permission"))),
-            Effect5.tap(
-              (captured) => Effect5.sync(() => {
-                stream = captured;
-                this.#assertActivePorts(ports, "startScreenShare");
-                track = requireDisplayVideoTrack(captured);
-                this.#tracks.set("screen", track);
-                ports.media.prepareLocalTrack("screen", track);
-                prepared = true;
-                operation?.observe("observed", "track_acquisition");
-                track.addEventListener("ended", () => this.#handleScreenEnded(track));
-                this.#screenEndedPending = false;
-                this.#publish();
-              })
-            ),
-            Effect5.andThen(foreign2(() => ports.sync.setScreenShareEnabled(true))),
-            Effect5.tap(() => Effect5.sync(() => operation?.observe("observed", "sync_commit"))),
-            Effect5.tap(() => Effect5.sync(() => this.#assertActivePorts(ports, "startScreenShare"))),
-            Effect5.tap(
-              () => Effect5.sync(() => {
-                operation?.observe("observed", "sfu_publication");
+    let intentRevision = 0;
+    return Effect5.sync(() => {
+      intentRevision = (this.#intentRevisions.get("screen") ?? 0) + 1;
+      this.#intentRevisions.set("screen", intentRevision);
+      this.#pendingEnables.set("screen", intentRevision);
+      this.#ports?.media.setLocalSourceIntent?.("screen", true);
+    }).pipe(
+      Effect5.andThen(
+        this.#serialize(
+          "screen",
+          this.#connection.runCommand((ports) => {
+            let stream = null;
+            let track = null;
+            let prepared = false;
+            return Effect5.suspend(() => {
+              if (this.#tracks.has("screen")) {
+                operation?.notObservable("permission", "already_active");
+                operation?.notObservable("track_acquisition", "already_active");
+                operation?.notObservable("sync_commit", "already_active");
+                operation?.notObservable("sfu_publication", "already_active");
                 operation?.succeed();
-              })
-            ),
-            Effect5.asVoid,
-            Effect5.catch((cause) => this.#rollbackCapture({ action: "startScreenShare", cause, fallback: Effect5.sync(() => stopStream(stream)), media: ports.media, permissionMessage: "Screen sharing permission was denied", prepared, source: "screen", track }))
-          );
-        });
-      })
+                return Effect5.void;
+              }
+              return foreign2(() => this.#selection.getDisplayMedia({ video: true, audio: false })).pipe(
+                Effect5.tap(() => Effect5.sync(() => operation?.observe("observed", "permission"))),
+                Effect5.tap(
+                  (captured) => Effect5.sync(() => {
+                    stream = captured;
+                    this.#assertActivePorts(ports, "startScreenShare");
+                    track = requireDisplayVideoTrack(captured);
+                    this.#tracks.set("screen", track);
+                    ports.media.prepareLocalTrack("screen", track);
+                    prepared = true;
+                    operation?.observe("observed", "track_acquisition");
+                    track.addEventListener("ended", () => this.#handleScreenEnded(track));
+                    this.#screenEndedPending = false;
+                    this.#publish();
+                  })
+                ),
+                Effect5.andThen(foreign2(() => ports.sync.setScreenShareEnabled(true))),
+                Effect5.tap(() => Effect5.sync(() => operation?.observe("observed", "sync_commit"))),
+                Effect5.tap(() => Effect5.sync(() => this.#assertActivePorts(ports, "startScreenShare"))),
+                Effect5.tap(
+                  () => Effect5.sync(() => {
+                    operation?.observe("observed", "sfu_publication");
+                    operation?.succeed();
+                  })
+                ),
+                Effect5.asVoid,
+                Effect5.catch((cause) => this.#rollbackCapture({ action: "startScreenShare", cause, fallback: Effect5.sync(() => stopStream(stream)), media: ports.media, permissionMessage: "Screen sharing permission was denied", prepared, source: "screen", track }))
+              );
+            });
+          })
+        )
+      )
     ).pipe(
       Effect5.mapError(normalizeClientError),
-      Effect5.tapError(() => Effect5.sync(() => operation?.fail("screen_start_failed")))
+      Effect5.tapError(() => Effect5.sync(() => operation?.fail("screen_start_failed"))),
+      Effect5.ensuring(
+        Effect5.sync(() => {
+          if (this.#pendingEnables.get("screen") === intentRevision) this.#pendingEnables.delete("screen");
+        })
+      )
     );
   }
   #stopScreen() {
     const operation = this.#diagnostics?.startOperation("screen.stop");
-    return this.#serialize(
-      "screen",
-      this.#connection.runCommand(
-        (ports) => Effect5.suspend(() => {
-          const track = this.#tracks.get("screen");
-          if (!track) {
-            operation?.notObservable("stop_confirmation", "already_stopped");
-            operation?.succeed();
-            return Effect5.void;
-          }
-          return foreign2(() => ports.sync.setScreenShareEnabled(false)).pipe(
-            Effect5.tap(() => Effect5.sync(() => this.#assertActivePorts(ports, "stopScreenShare"))),
-            Effect5.andThen(foreign2(() => ports.media.clearPreparedLocalTrack("screen"))),
-            Effect5.tap(
-              () => Effect5.sync(() => {
-                this.#assertActivePorts(ports, "stopScreenShare");
-                if (this.#tracks.get("screen") === track) this.#tracks.delete("screen");
-                track.stop();
-                this.#screenEndedPending = false;
-                this.#publish();
-                operation?.observe("observed", "stop_confirmation");
-                operation?.succeed();
-              })
-            ),
-            Effect5.asVoid
-          );
-        })
+    let intentRevision = 0;
+    let earlyPause = null;
+    const localPause = Effect5.suspend(() => {
+      intentRevision = (this.#intentRevisions.get("screen") ?? 0) + 1;
+      this.#intentRevisions.set("screen", intentRevision);
+      this.#ports?.media.setLocalSourceIntent?.("screen", false);
+      if (this.#ports) earlyPause = this.#beginLocalPause(this.#ports, "screen");
+      return Effect5.void;
+    });
+    return localPause.pipe(
+      Effect5.andThen(
+        this.#serialize(
+          "screen",
+          this.#connection.runCommand(
+            (ports) => Effect5.suspend(() => {
+              const track = this.#tracks.get("screen");
+              let paused = false;
+              return (earlyPause ? foreign2(() => earlyPause) : this.#localTarget(ports, "screen", false)).pipe(
+                Effect5.tap(
+                  () => Effect5.sync(() => {
+                    paused = true;
+                  })
+                ),
+                Effect5.andThen(foreign2(() => ports.sync.setScreenShareEnabled(false))),
+                Effect5.tap(() => Effect5.sync(() => this.#assertActivePorts(ports, "stopScreenShare"))),
+                Effect5.andThen(foreign2(() => ports.media.clearPreparedLocalTrack("screen"))),
+                Effect5.tap(
+                  () => Effect5.sync(() => {
+                    this.#assertActivePorts(ports, "stopScreenShare");
+                    if (this.#tracks.get("screen") === track) this.#tracks.delete("screen");
+                    track?.stop();
+                    this.#screenEndedPending = false;
+                    this.#publish();
+                    operation?.observe("observed", "stop_confirmation");
+                    operation?.succeed();
+                  })
+                ),
+                Effect5.asVoid,
+                Effect5.catch(
+                  (cause) => paused && !isSyncRejection(cause) || this.#intentRevisions.get("screen") !== intentRevision ? Effect5.fail(cause) : Effect5.sync(() => ports.media.setLocalSourceIntent?.("screen", true)).pipe(
+                    Effect5.andThen(this.#localTarget(ports, "screen", true)),
+                    Effect5.catch(() => Effect5.void),
+                    Effect5.andThen(Effect5.fail(cause))
+                  )
+                )
+              );
+            })
+          )
+        )
       )
     ).pipe(
       Effect5.mapError(normalizeClientError),
       Effect5.tapError(() => Effect5.sync(() => operation?.fail("screen_stop_failed")))
     );
   }
+  #beginLocalPause(ports, source) {
+    const pause = Effect5.runPromise(this.#localTarget(ports, source, false));
+    void pause.catch(() => void 0);
+    return pause;
+  }
   #serialize(source, effect) {
-    return this.#gates.get(source).withPermit(effect);
+    return this.#gates.get(source).withPermit(
+      Effect5.sync(() => {
+        this.#pendingSources.add(source);
+        this.#publish();
+      }).pipe(
+        Effect5.andThen(effect),
+        Effect5.ensuring(
+          Effect5.sync(() => {
+            this.#pendingSources.delete(source);
+            this.#publish();
+          })
+        )
+      )
+    );
+  }
+  #localTarget(ports, source, enabled) {
+    return foreign2(() => ports.media.setLocalPublicationTarget({ operationId: `privacy-${source}-${enabled ? "restore" : "off"}`, participantId: ports.sync.getSnapshot().participantId ?? "", source, enabled })).pipe(
+      Effect5.flatMap(
+        (result) => result.outcome === "confirmed" || result.outcome === "satisfied" || !enabled && result.errorCode === "source_unavailable" ? Effect5.void : Effect5.fail(new SpaceClientError({ code: "media.capture_failed", recoverable: true, message: `Could not ${enabled ? "restore" : "pause"} ${source}` }))
+      )
+    );
   }
   #captureSource(source) {
     return foreign2(() => this.#selection.getUserMedia({ audio: source === "microphone", video: source === "camera" })).pipe(
+      Effect5.mapError((cause) => captureError(cause, source === "microphone" ? "setMicrophoneEnabled" : "setCameraEnabled", `${source} permission was denied`)),
       Effect5.tap(() => this.#refreshDevices().pipe(Effect5.ignore)),
       Effect5.flatMap(
         (stream) => Effect5.try({
@@ -3568,8 +5134,8 @@ var MediaControllerRuntime = class {
     input.restoreIntent?.();
     const rollback = input.track ? this.#discardCaptured(input.source, input.track, input.media, input.prepared) : input.fallback;
     const captureWasUnavailable = input.action === "startScreenShare" && !input.prepared && input.track === null;
-    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)));
+    const failure3 = 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(failure3)));
   }
   #assertActivePorts(ports, action) {
     if (this.#connection.getSnapshot().state === "live" && this.#ports?.sync === ports.sync && this.#ports.media === ports.media) return;
@@ -3582,6 +5148,7 @@ var MediaControllerRuntime = class {
     this.#unsubscribeMedia = null;
     this.#unsubscribeRequests = null;
     this.#unsubscribeSync = null;
+    if (this.#ports?.media !== ports?.media) this.#observedPublicationIds.clear();
     this.#ports = ports;
     if (!ports) {
       for (const track of this.#tracks.values()) track.stop();
@@ -3591,11 +5158,57 @@ var MediaControllerRuntime = class {
       this.#publish();
       return;
     }
-    this.#unsubscribeMedia = ports.media.subscribe(() => this.#publish());
+    this.#unsubscribeMedia = ports.media.subscribe(() => {
+      this.#applyRemoteMediaState(ports, ports.sync.getSnapshot());
+      this.#publish();
+    });
     this.#unsubscribeRequests = ports.sync.onDirectedRequest((request) => this.#request(request));
-    this.#unsubscribeSync = ports.sync.subscribe((snapshot) => this.#removeRequestsFromMissingParticipants(snapshot));
+    this.#unsubscribeSync = ports.sync.subscribe((snapshot) => {
+      this.#removeRequestsFromMissingParticipants(snapshot);
+      this.#applyRemoteMediaState(ports, snapshot);
+      this.#applyForcedMediaState(ports, snapshot);
+    });
+    this.#applyRemoteMediaState(ports, ports.sync.getSnapshot());
+    this.#applyForcedMediaState(ports, ports.sync.getSnapshot());
+    this.#publish();
+  }
+  #applyRemoteMediaState(ports, snapshot) {
+    for (const publication of ports.media.getSnapshot().remoteTracks) {
+      publication.track.enabled = snapshot.media?.items.some((item) => item.participantId === publication.participantId && item.source === publication.source && item.enabled) ?? false;
+    }
+  }
+  #applyForcedMediaState(ports, snapshot) {
+    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) {
+        this.#observedPublicationIds.set(source, projected.publicationId);
+        continue;
+      }
+      const previousPublicationId = this.#observedPublicationIds.get(source);
+      if (!this.#observedPublicationIds.delete(source)) continue;
+      const local = ports.media.getSnapshot().localTracks.find((publication) => publication.source === source);
+      if (local && local.publicationId !== previousPublicationId) continue;
+      this.#pauseForcedSource(ports, source);
+    }
+  }
+  #pauseForcedSource(ports, source) {
+    const pendingEnable = this.#hasPendingEnable(source);
+    if (!pendingEnable) {
+      this.#intentRevisions.set(source, (this.#intentRevisions.get(source) ?? 0) + 1);
+      if (source !== "screen") this.#intent[source] = false;
+    }
+    const track = this.#tracks.get(source);
+    if (track) track.enabled = false;
+    ports.media.setLocalSourceIntent?.(source, false);
+    if (ports.media.closeForcedLocalPublication) void ports.media.closeForcedLocalPublication(source).catch(() => void 0);
+    if (pendingEnable) ports.media.setLocalSourceIntent?.(source, true);
     this.#publish();
   }
+  #hasPendingEnable(source) {
+    const revision = this.#pendingEnables.get(source);
+    return revision !== void 0 && revision === this.#intentRevisions.get(source);
+  }
   #request(request) {
     if (request.expires_at_ms <= this.#now()) return;
     const control = this.#ports?.sync.getSnapshot().optimisticControl ?? this.#ports?.sync.getSnapshot().control;
@@ -3665,7 +5278,11 @@ var MediaControllerRuntime = class {
     const current = this.#store.getSnapshot();
     const snapshot = this.#ports?.media.getSnapshot();
     const state = this.#connection.getSnapshot().state;
-    const local = Object.freeze({ microphone: localMedia("microphone", this.#tracks, snapshot, this.#intent.microphone, state), camera: localMedia("camera", this.#tracks, snapshot, this.#intent.camera, state), screen: localMedia("screen", this.#tracks, snapshot, false, state) });
+    const local = Object.freeze({
+      microphone: localMedia("microphone", this.#tracks, snapshot, this.#intent.microphone, state, this.#pendingSources.has("microphone")),
+      camera: localMedia("camera", this.#tracks, snapshot, this.#intent.camera, state, this.#pendingSources.has("camera")),
+      screen: localMedia("screen", this.#tracks, snapshot, false, state, this.#pendingSources.has("screen"))
+    });
     const remote = Object.freeze((snapshot?.remoteTracks ?? []).map((track) => Object.freeze({ participantId: track.participantId, source: track.source, publicationId: track.publicationId, track: track.track })));
     const media = Object.freeze({ ...current.media, local, remote, screenShare: local.screen, incomingRequests: this.#requests });
     if (!sameMediaSlice(current.media, media)) this.#store.updateMedia(media);
@@ -3702,12 +5319,18 @@ function initialTrackEntries(microphone, camera) {
   if (camera) entries.push(["camera", camera]);
   return entries;
 }
-function localMedia(source, tracks, snapshot, intended, connectionState) {
+function localMedia(source, tracks, snapshot, intended, connectionState, pending) {
   const track = tracks.get(source) ?? null;
   const publication = snapshot?.localTracks.find((candidate) => candidate.source === source);
+  if (locallyMuted(intended, track, publication)) return Object.freeze({ source, state: "disabled", track });
+  if (pending) return Object.freeze({ source, state: "requesting", 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 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";
@@ -3750,19 +5373,268 @@ function sameDeviceList(left, right) {
   return left.length === right.length && left.every((device, index) => device.deviceId === right[index]?.deviceId && device.label === right[index]?.label);
 }
 function captureError(cause, action, permissionMessage) {
+  if (cause instanceof ConnectionError) return cause;
   if (isPermissionDenied(cause)) return new ConnectionError({ code: "permission_denied", action, recoverable: true, message: permissionMessage }, { cause });
-  return new ConnectionError({ code: "unsupported_environment", action, recoverable: false, message: action === "startScreenShare" ? "Screen sharing is unavailable in this browser." : "Media capture is unavailable" }, { cause });
+  const failure3 = describeMediaCaptureError(cause);
+  return new ConnectionError({ ...failure3, action, message: action === "startScreenShare" ? "Screen sharing could not start. Check screen recording permission and try again in a supported browser or app." : failure3.message }, { cause });
 }
 function isPermissionDenied(cause) {
-  return cause instanceof DOMException && (cause.name === "NotAllowedError" || cause.name === "SecurityError");
+  return describeMediaCaptureError(cause).code === "permission_denied";
 }
 function isAccessInvalid2(cause) {
   return typeof cause === "object" && cause !== null && "code" in cause && (cause.code === "access.invalid" || cause.code === "invalid_access");
 }
+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/participants-controller.ts
+// src/space-client/offline-actions.ts
 import { Context as Context7, Effect as Effect6, Layer as Layer7 } from "effect";
 
+// src/space-client/offline-actions-storage.ts
+import { Schema as Schema3 } from "effect";
+var OFFLINE_ACTION_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+function browserOfflineActionsStorage() {
+  if (typeof window === "undefined") return void 0;
+  try {
+    return globalThis.localStorage;
+  } catch {
+    return void 0;
+  }
+}
+var attachment = Schema3.Struct({ attachmentId: Schema3.String, fileName: Schema3.String, mimeType: ChatAttachmentMimeTypeSchema, byteLength: Schema3.Number });
+var StoredOfflineAction = Schema3.Struct({
+  id: Schema3.String,
+  kind: Schema3.Literals(["chat_message", "hand_raise", "hand_lower"]),
+  text: Schema3.NullOr(Schema3.String),
+  queuedAt: Schema3.Number,
+  clientMessageId: Schema3.optional(Schema3.String),
+  attachments: Schema3.optional(Schema3.Array(attachment))
+});
+var StoredOfflineActions = Schema3.Struct({
+  version: Schema3.Literal(1),
+  subject: Schema3.Struct({ tenantId: Schema3.String, spaceId: Schema3.String, episodeId: Schema3.String, participantId: Schema3.String, participantGeneration: Schema3.Number }),
+  actions: Schema3.Array(StoredOfflineAction)
+});
+var decodeOfflineActions = Schema3.decodeUnknownSync(StoredOfflineActions);
+
+// src/space-client/offline-actions.ts
+var OfflineActionsService = class extends Context7.Service()("@chalk/client/OfflineActions") {
+};
+var sameSubject = (current, saved) => !!current && !!saved && current.tenantId === saved.tenantId && current.spaceId === saved.spaceId && current.episodeId === saved.episodeId && current.participantId === saved.participantId && current.participantGeneration === saved.participantGeneration;
+var terminalConnection = (snapshot) => snapshot.state === "left" || snapshot.state === "leaving" || snapshot.state === "failed" && !snapshot.failure?.recoverable;
+var validStoredAction = (action, now) => Number.isFinite(action.queuedAt) && action.queuedAt <= now && (action.kind !== "chat_message" || !!action.clientMessageId && action.text !== null && validateChatMessage({ text: action.text, attachments: action.attachments }) === null);
+var discardedError = () => new SpaceClientError({ code: "offline.discarded", recoverable: false, message: "This action was not sent." });
+var makeOfflineActions = (input) => Effect6.gen(function* () {
+  const runtime = new OfflineActionsRuntime(input.connection, input.store, input.storage ?? browserOfflineActionsStorage(), input.storageKey);
+  yield* Effect6.addFinalizer(() => Effect6.sync(() => runtime.dispose()));
+  return runtime;
+});
+var OfflineActionsRuntime = class {
+  #connection;
+  #store;
+  #unsubscribe;
+  #waiters = [];
+  #decisionNeeded = false;
+  #policy = "send";
+  #policyExplicit = false;
+  #restored = false;
+  #subject = null;
+  #notice;
+  #storage;
+  #storageKey;
+  constructor(connection, store, storage, storageKey = "chalk:offline-actions") {
+    this.#connection = connection;
+    this.#store = store;
+    this.#storage = storage;
+    this.#storageKey = storageKey;
+    this.#unsubscribe = connection.subscribe(() => this.#connectionChanged());
+    this.#connectionChanged();
+  }
+  send = () => Effect6.sync(() => this.#settle("send"));
+  discard = () => Effect6.sync(() => this.#settle("discard"));
+  setPolicy = (policy) => Effect6.sync(() => {
+    this.#policyExplicit = true;
+    this.#policy = policy;
+    if (this.#decisionNeeded && policy !== "ask") this.#settle(policy);
+    else this.#publish();
+  });
+  hold = (input, run) => {
+    if (this.#connection.getSnapshot().state !== "reconnecting" && !this.#decisionNeeded) return null;
+    const queuedSubject = this.#connection.getSnapshot().subject;
+    const action = Object.freeze({ ...input, id: this.#connection.createId(), text: input.text ?? null, queuedAt: this.#connection.nowUnsafe() });
+    return Effect6.callback((resume) => {
+      if (this.#waiters.length === 0) this.#subject = queuedSubject;
+      this.#notice = void 0;
+      this.#waiters = [...this.#waiters, { action, resume }];
+      this.#persist();
+      this.#publish();
+      return Effect6.sync(() => this.#drop(action.id));
+    }).pipe(Effect6.andThen(Effect6.suspend(() => sameSubject(this.#connection.getSnapshot().subject, queuedSubject) ? run() : Effect6.fail(discardedError()))));
+  };
+  dispose() {
+    this.#unsubscribe();
+    const waiters = this.#waiters;
+    this.#waiters = [];
+    for (const waiter of waiters) waiter.resume(Effect6.fail(discardedError()));
+  }
+  #connectionChanged() {
+    const snapshot = this.#connection.getSnapshot();
+    const state = snapshot.state;
+    const terminal = terminalConnection(snapshot);
+    if (state === "live") this.#restore();
+    if (this.#waiters.length === 0) {
+      if (terminal) this.#discardSaved();
+      return;
+    }
+    if (state === "live") {
+      if (!this.#validScope()) {
+        this.#notice = "Your offline actions were not sent because the Episode or participant changed.";
+        this.#settle("discard");
+        return;
+      }
+      if (this.#policy === "ask") {
+        this.#decisionNeeded = true;
+        this.#publish();
+      } else this.#settle(this.#policy);
+    } else if (terminal) {
+      this.#notice = "Your offline actions were not sent because the Episode ended or the connection closed.";
+      this.#settle("discard");
+      this.#clearStorage();
+    }
+  }
+  #settle(decision) {
+    if (decision === "send" && this.#connection.getSnapshot().state !== "live") return;
+    if (decision === "send" && !this.#validScope()) {
+      this.#notice = "Your offline actions were not sent because the Episode or participant changed.";
+      decision = "discard";
+    }
+    if (!this.#clearStorage() && this.#storage) {
+      this.#notice = "Your offline actions could not be sent safely. Try again when storage is available.";
+      this.#publish();
+      return;
+    }
+    const waiters = this.#waiters;
+    this.#waiters = [];
+    this.#decisionNeeded = false;
+    this.#publish();
+    for (const waiter of waiters) this.#resumeWaiter(waiter, decision);
+    this.#publish();
+  }
+  #drop(id) {
+    const next = this.#waiters.filter((waiter) => waiter.action.id !== id);
+    if (next.length === this.#waiters.length) return;
+    this.#waiters = next;
+    this.#persist();
+    if (next.length === 0) this.#decisionNeeded = false;
+    this.#publish();
+  }
+  #validScope() {
+    const current = this.#connection.getSnapshot().subject;
+    const saved = this.#subject;
+    return sameSubject(current, saved);
+  }
+  #clearStorage() {
+    try {
+      this.#storage?.removeItem(this.#storageKey);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  #persist() {
+    if (!this.#storage || !this.#subject) return;
+    try {
+      if (this.#waiters.length === 0) this.#storage.removeItem(this.#storageKey);
+      else this.#storage.setItem(this.#storageKey, JSON.stringify({ version: 1, subject: this.#subject, actions: this.#waiters.map(({ action }) => action) }));
+    } catch {
+      this.#notice = "Your offline actions are held, but could not be saved. Keep this page open.";
+    }
+  }
+  #restore() {
+    if (this.#restored || !this.#connection.getSnapshot().subject) return;
+    this.#restored = true;
+    if (this.#waiters.length > 0) return;
+    const saved = this.#readStored();
+    if (!saved) return;
+    this.#subject = saved.subject;
+    if (!this.#validScope()) {
+      this.#notice = "Your offline actions were not sent because the Episode or participant changed.";
+      this.#clearStorage();
+      this.#publish();
+      return;
+    }
+    const actions = saved.actions.filter((action) => this.#connection.nowUnsafe() - action.queuedAt < OFFLINE_ACTION_MAX_AGE_MS);
+    if (actions.length !== saved.actions.length) this.#notice = "Your expired offline actions were not sent. Actions are kept for up to 24 hours.";
+    if (!this.#policyExplicit) this.#policy = "ask";
+    const restoredSubject = saved.subject;
+    this.#waiters = actions.map((action) => ({
+      action,
+      resume: (permission) => {
+        const command = this.#connection.runCommand(
+          ({ sync }) => Effect6.tryPromise({
+            try: () => action.kind === "chat_message" ? sync.sendChatMessage({ text: action.text ?? "", clientMessageId: action.clientMessageId ?? action.id, attachments: action.attachments ?? [] }).then(() => void 0) : sync.setHandRaised(action.kind === "hand_raise"),
+            catch: () => discardedError()
+          })
+        );
+        void Effect6.runPromiseExit(
+          permission.pipe(
+            Effect6.andThen(
+              Effect6.suspend(() => sameSubject(this.#connection.getSnapshot().subject, restoredSubject) ? command : Effect6.fail(discardedError())).pipe(
+                Effect6.tapError(
+                  () => Effect6.sync(() => {
+                    this.#notice = "An offline action was not sent. Please try it again.";
+                    this.#publish();
+                  })
+                )
+              )
+            )
+          )
+        );
+      }
+    }));
+    this.#persist();
+    this.#publish();
+  }
+  #resumeWaiter(waiter, decision) {
+    const expired = this.#connection.nowUnsafe() - waiter.action.queuedAt >= OFFLINE_ACTION_MAX_AGE_MS;
+    if (expired) this.#notice = "Your expired offline actions were not sent. Actions are kept for up to 24 hours.";
+    waiter.resume(decision === "send" && !expired ? Effect6.void : Effect6.fail(discardedError()));
+  }
+  #discardSaved() {
+    try {
+      if (!this.#storage?.getItem(this.#storageKey)) return;
+      this.#notice = "Your offline actions were not sent because the Episode ended or the connection closed.";
+      this.#clearStorage();
+    } catch {
+      this.#notice = "Saved offline actions could not be read. They will not be sent.";
+    }
+    this.#publish();
+  }
+  #readStored() {
+    try {
+      const raw = this.#storage?.getItem(this.#storageKey);
+      if (!raw) return null;
+      const saved = decodeOfflineActions(JSON.parse(raw));
+      if (saved.actions.some((action) => !validStoredAction(action, this.#connection.nowUnsafe()))) throw new Error("Invalid offline action");
+      return saved;
+    } catch {
+      this.#clearStorage();
+      return null;
+    }
+  }
+  #publish() {
+    const slice = Object.freeze({ pending: Object.freeze(this.#waiters.map((waiter) => waiter.action)), decisionNeeded: this.#decisionNeeded, policy: this.#policy, ...this.#notice ? { notice: this.#notice } : {} });
+    this.#store.updateOffline(slice);
+  }
+};
+
+// src/space-client/participants-controller.ts
+import { Context as Context8, Effect as Effect7, Layer as Layer8 } from "effect";
+
 // src/sync/v1-types.ts
 var V1_CAPABILITIES = [
   "publishAudio",
@@ -3793,19 +5665,21 @@ var V1_CAPABILITIES = [
 // src/space-client/participants-controller.ts
 var CAPABILITIES = new Set(V1_CAPABILITIES);
 var EMPTY_PARTICIPANTS = Object.freeze({ roster: Object.freeze([]), admissionQueue: Object.freeze([]) });
-var ParticipantsControllerService = class extends Context7.Service()("@chalk/client/ParticipantsController") {
+var ParticipantsControllerService = class extends Context8.Service()("@chalk/client/ParticipantsController") {
 };
-var makeParticipantsController = (connection, store, diagnostics) => Effect6.acquireRelease(
-  Effect6.sync(() => new ParticipantsControllerRuntime(connection, store, diagnostics)),
-  (controller) => Effect6.sync(() => controller.dispose())
+var makeParticipantsController = (connection, store, diagnostics, offline) => Effect7.acquireRelease(
+  Effect7.sync(() => new ParticipantsControllerRuntime(connection, store, diagnostics, offline)),
+  (controller) => Effect7.sync(() => controller.dispose())
 );
 var ParticipantsControllerRuntime = class {
   #connection;
   #store;
   #diagnostics;
+  #offline;
   #unsubscribePorts = null;
   #unsubscribe = null;
-  constructor(connection, store, diagnostics) {
+  constructor(connection, store, diagnostics, offline) {
+    this.#offline = offline;
     this.#connection = connection;
     this.#store = store;
     this.#diagnostics = diagnostics;
@@ -3831,7 +5705,7 @@ var ParticipantsControllerRuntime = class {
   requestMedia = (participantId, kind) => this.#command("media_request.request", ["capability_decision", "command_commit", "target_result"], () => {
     assertIdentifier(participantId, "participant ID");
     if (kind !== "microphone" && kind !== "camera") throw invalid("Media requests must target a microphone or camera");
-    return ({ sync }) => (kind === "microphone" ? foreign3(() => sync.requestUnmute(participantId)) : foreign3(() => sync.requestStartCamera(participantId))).pipe(Effect6.map(directed));
+    return ({ sync }) => (kind === "microphone" ? foreign3(() => sync.requestUnmute(participantId)) : foreign3(() => sync.requestStartCamera(participantId))).pipe(Effect7.map(directed));
   });
   remove = (participantId) => this.#command("moderation.remove", ["capability_decision", "command_commit", "target_delivery"], () => {
     assertIdentifier(participantId, "participant ID");
@@ -3845,16 +5719,16 @@ var ParticipantsControllerRuntime = class {
     assertIdentifier(requestId, "admission request ID");
     return ({ sync }) => foreign3(() => sync.deny(requestId));
   });
-  raiseHand = () => this.#command(
-    "participant.raised_hand.set",
-    ["membership_transition", "participant_result"],
-    () => ({ sync }) => foreign3(() => sync.setHandRaised(true))
-  );
-  lowerHand = () => this.#command(
-    "participant.raised_hand.set",
-    ["membership_transition", "participant_result"],
-    () => ({ sync }) => foreign3(() => sync.setHandRaised(false))
-  );
+  raiseHand = () => this.#setHandRaised(true);
+  lowerHand = () => this.#setHandRaised(false);
+  #setHandRaised(raised) {
+    const send = () => this.#command(
+      "participant.raised_hand.set",
+      ["membership_transition", "participant_result"],
+      () => ({ sync }) => foreign3(() => sync.setHandRaised(raised))
+    );
+    return this.#offline?.hold({ kind: raised ? "hand_raise" : "hand_lower" }, send) ?? send();
+  }
   renameSelf = (displayName) => this.#command("participant.rename", ["membership_transition", "participant_result"], () => {
     assertName(displayName, "display name");
     return ({ sync }) => foreign3(() => sync.setDisplayName(displayName));
@@ -3867,18 +5741,18 @@ var ParticipantsControllerRuntime = class {
   }
   #command(name, checkpoints, operation) {
     const diagnostic = this.#diagnostics?.startOperation(name);
-    return Effect6.try({ try: operation, catch: normalizeClientError }).pipe(
-      Effect6.tap(() => Effect6.sync(() => diagnostic?.observe("observed", checkpoints[0]))),
-      Effect6.flatMap((run) => this.#connection.runCommand(run)),
-      Effect6.mapError(normalizeClientError),
-      Effect6.tap(
-        () => Effect6.sync(() => {
+    return Effect7.try({ try: operation, catch: normalizeClientError }).pipe(
+      Effect7.tap(() => Effect7.sync(() => diagnostic?.observe("observed", checkpoints[0]))),
+      Effect7.flatMap((run) => this.#connection.runCommand(run)),
+      Effect7.mapError(normalizeClientError),
+      Effect7.tap(
+        () => Effect7.sync(() => {
           for (const checkpoint of checkpoints.slice(1)) diagnostic?.observe("observed", checkpoint);
           if (name.startsWith("moderation.")) diagnostic?.notObservable("target_application", "target_projection_is_conditional");
           diagnostic?.succeed();
         })
       ),
-      Effect6.tapError(() => Effect6.sync(() => diagnostic?.fail("command_failed")))
+      Effect7.tapError(() => Effect7.sync(() => diagnostic?.fail("command_failed")))
     );
   }
   #bind(ports) {
@@ -3900,7 +5774,7 @@ var ParticipantsControllerRuntime = class {
   }
 };
 function foreign3(operation) {
-  return Effect6.tryPromise({ try: operation, catch: (cause) => cause });
+  return Effect7.tryPromise({ try: operation, catch: (cause) => cause });
 }
 function assertIdentifier(value, label) {
   if (typeof value !== "string" || value.trim().length === 0) throw invalid(`A non-empty ${label} is required`);
@@ -4010,20 +5884,20 @@ function sameValues(left, right) {
 }
 
 // src/space-client/reactions-controller.ts
-import { Clock as Clock4, Context as Context8, Effect as Effect7, Layer as Layer8 } from "effect";
+import { Clock as Clock4, Context as Context9, Effect as Effect8, Layer as Layer9 } from "effect";
 var MAX_VISIBLE_REACTIONS = 24;
 var REACTIONS = /* @__PURE__ */ new Set(["\u{1F44D}", "\u2764\uFE0F", "\u{1F602}", "\u{1F62E}", "\u{1F622}", "\u{1F389}"]);
-var ReactionsControllerService = class extends Context8.Service()("@chalk/client/ReactionsController") {
+var ReactionsControllerService = class extends Context9.Service()("@chalk/client/ReactionsController") {
 };
-var makeReactionsController = (connection, store, diagnostics) => Effect7.gen(function* () {
+var makeReactionsController = (connection, store, diagnostics) => Effect8.gen(function* () {
   const clock = yield* Clock4.Clock;
-  const scope = yield* Effect7.scope;
-  const context = yield* Effect7.context();
+  const scope = yield* Effect8.scope;
+  const context = yield* Effect8.context();
   const fork = (effect) => {
-    void Effect7.runForkWith(context)(Effect7.forkIn(effect, scope).pipe(Effect7.asVoid));
+    void Effect8.runForkWith(context)(Effect8.forkIn(effect, scope).pipe(Effect8.asVoid));
   };
   const controller = new ReactionsControllerRuntime(connection, store, clock.currentTimeMillisUnsafe, fork, diagnostics);
-  yield* Effect7.addFinalizer(() => Effect7.sync(() => controller.dispose()));
+  yield* Effect8.addFinalizer(() => Effect8.sync(() => controller.dispose()));
   return controller;
 });
 var ReactionsControllerRuntime = class {
@@ -4046,26 +5920,26 @@ var ReactionsControllerRuntime = class {
   }
   send = (emoji) => {
     const operation = this.#diagnostics?.startOperation("reaction.send");
-    return Effect7.try({
+    return Effect8.try({
       try: () => {
         if (!REACTIONS.has(emoji)) throw new SpaceClientError({ code: "reaction.invalid", recoverable: false, message: "The reaction is not supported" });
       },
       catch: normalizeClientError
     }).pipe(
-      Effect7.tap(() => Effect7.sync(() => operation?.observe("observed", "authorization"))),
-      Effect7.andThen(this.#connection.runCommand(({ sync }) => foreign4(() => sync.sendReaction(emoji)))),
-      Effect7.tap(() => Effect7.sync(() => operation?.observe("observed", "accepted_commit"))),
-      Effect7.map(reactionFor),
-      Effect7.tap(
-        (reaction) => Effect7.sync(() => {
+      Effect8.tap(() => Effect8.sync(() => operation?.observe("observed", "authorization"))),
+      Effect8.andThen(this.#connection.runCommand(({ sync }) => foreign4(() => sync.sendReaction(emoji)))),
+      Effect8.tap(() => Effect8.sync(() => operation?.observe("observed", "accepted_commit"))),
+      Effect8.map(reactionFor),
+      Effect8.tap(
+        (reaction) => Effect8.sync(() => {
           this.#observe(reaction);
           operation?.observe("observed", "sender_result");
           operation?.notObservable("recipient_projection", "recipient_projection_is_conditional");
           operation?.succeed();
         })
       ),
-      Effect7.mapError(normalizeClientError),
-      Effect7.tapError(() => Effect7.sync(() => operation?.fail("send_failed")))
+      Effect8.mapError(normalizeClientError),
+      Effect8.tapError(() => Effect8.sync(() => operation?.fail("send_failed")))
     );
   };
   dispose() {
@@ -4095,9 +5969,9 @@ var ReactionsControllerRuntime = class {
     this.#expiryGenerations.set(reaction.eventId, generation);
     const delay = Math.max(0, expiresAt2 - this.#now());
     this.#fork(
-      Effect7.sleep(delay).pipe(
-        Effect7.andThen(
-          Effect7.sync(() => {
+      Effect8.sleep(delay).pipe(
+        Effect8.andThen(
+          Effect8.sync(() => {
             if (this.#expiryGenerations.get(reaction.eventId) === generation) this.#remove(reaction.eventId);
           })
         )
@@ -4124,7 +5998,7 @@ var ReactionsControllerRuntime = class {
   }
 };
 function foreign4(operation) {
-  return Effect7.tryPromise({ try: operation, catch: (cause) => cause });
+  return Effect8.tryPromise({ try: operation, catch: (cause) => cause });
 }
 function reactionFor(reaction) {
   return Object.freeze({ ...reaction });
@@ -4139,23 +6013,122 @@ function sameReactions(left, right) {
   });
 }
 
+// src/space-client/recording-controller.ts
+import { Context as Context10, Effect as Effect9, Layer as Layer10 } from "effect";
+var RecordingControllerService = class extends Context10.Service()("@chalk/client/RecordingController") {
+};
+var makeRecordingController = (connection, store, diagnostics) => Effect9.acquireRelease(
+  Effect9.sync(() => new RecordingControllerRuntime(connection, store, diagnostics)),
+  (controller) => Effect9.sync(() => controller.dispose())
+);
+var RecordingControllerRuntime = class {
+  #connection;
+  #store;
+  #diagnostics;
+  #subscriptions = { ports: null, recording: null };
+  constructor(connection, store, diagnostics) {
+    this.#connection = connection;
+    this.#store = store;
+    this.#diagnostics = diagnostics;
+    this.#subscriptions.ports = connection.subscribePorts((ports) => this.#bind(ports));
+  }
+  start = () => this.#command(
+    "recording.start",
+    "start_failed",
+    () => this.#authorizeStart(),
+    (_, { sync }) => foreign5(() => sync.startRecording()).pipe(Effect9.map(({ recordingId }) => Object.freeze({ recordingId })))
+  );
+  stop = () => this.#command(
+    "recording.stop",
+    "stop_failed",
+    () => this.#authorizeStop(),
+    (recordingId, { sync }) => foreign5(() => sync.stopRecording(recordingId)).pipe(Effect9.asVoid)
+  );
+  dispose() {
+    this.#subscriptions.ports?.();
+    this.#subscriptions.recording?.();
+    this.#subscriptions.ports = null;
+    this.#subscriptions.recording = null;
+    this.#store.updateRecording(EMPTY_RECORDING);
+  }
+  #authorizeStart() {
+    const snapshot = this.#store.getSnapshot();
+    assertConnectedAndAllowed(snapshot);
+    const current = snapshot.recording.current;
+    if (current && current.status !== "stopped" && current.status !== "failed") throw invalidState("A Recording is already active");
+  }
+  #authorizeStop() {
+    const snapshot = this.#store.getSnapshot();
+    assertConnectedAndAllowed(snapshot);
+    const current = snapshot.recording.current;
+    if (!current || current.status !== "recording") throw invalidState("No active Recording can be stopped");
+    return current.recordingId;
+  }
+  #command(name, failureCode, authorize, execute) {
+    const operation = this.#diagnostics?.startOperation(name);
+    const authorized = Effect9.try({ try: authorize, catch: normalizeClientError });
+    return authorized.pipe(
+      Effect9.tap(() => Effect9.sync(() => operation?.observe("observed", "authorization"))),
+      Effect9.flatMap((authorization) => this.#connection.runCommand((ports) => execute(authorization, ports))),
+      Effect9.tap(() => Effect9.sync(() => operation?.observe("observed", "accepted_commit"))),
+      Effect9.tap(() => Effect9.sync(() => operation?.succeed())),
+      Effect9.mapError(normalizeClientError),
+      Effect9.tapError(() => Effect9.sync(() => operation?.fail(failureCode)))
+    );
+  }
+  #bind(ports) {
+    this.#subscriptions.recording?.();
+    this.#subscriptions.recording = null;
+    if (!ports) {
+      this.#store.updateRecording(EMPTY_RECORDING);
+      return;
+    }
+    this.#subscriptions.recording = ports.sync.subscribe((snapshot) => this.#observe(recordingFor(snapshot)));
+  }
+  #observe(next) {
+    const current = this.#store.getSnapshot().recording;
+    if (sameRecording(current, next)) return;
+    this.#store.updateRecording(next);
+  }
+};
+var EMPTY_RECORDING = Object.freeze({ current: null });
+function recordingFor(snapshot) {
+  const recording = (snapshot.optimisticControl ?? snapshot.control)?.recording ?? null;
+  return Object.freeze({ current: recording ? Object.freeze({ ...recording }) : null });
+}
+function sameRecording(left, right) {
+  if (left.current === right.current) return true;
+  if (!left.current || !right.current) return false;
+  return left.current.recordingId === right.current.recordingId && left.current.status === right.current.status && left.current.failureCode === right.current.failureCode;
+}
+function assertConnectedAndAllowed(snapshot) {
+  if (snapshot.connection.status !== "live" || !snapshot.connection.episode) throw invalidState("Recording commands require a live Episode");
+  if (!snapshot.self.can("manageRecording")) throw new SpaceClientError({ code: "command.rejected", recoverable: false, message: "Recording is not allowed for this Participant" });
+}
+function invalidState(message) {
+  return new SpaceClientError({ code: "connection.invalid_state", recoverable: false, message });
+}
+function foreign5(operation) {
+  return Effect9.tryPromise({ try: operation, catch: (cause) => cause });
+}
+
 // src/space-client/whiteboard-controller.ts
-import { Context as Context9, Effect as Effect8, Layer as Layer9 } from "effect";
+import { Context as Context11, Effect as Effect10, Layer as Layer11 } from "effect";
 var EMPTY_SUMMARY = Object.freeze({ status: "unsubscribed", sceneId: null, revision: null, capabilities: Object.freeze([]), canDraw: false, canClear: false, presenting: false, error: null });
-var WhiteboardControllerService = class extends Context9.Service()("@chalk/client/WhiteboardController") {
+var WhiteboardControllerService = class extends Context11.Service()("@chalk/client/WhiteboardController") {
 };
-var makeWhiteboardController = (connection, store, create) => Effect8.gen(function* () {
-  const context = yield* Effect8.context();
-  const controller = yield* Effect8.sync(() => {
+var makeWhiteboardController = (connection, store, create) => Effect10.gen(function* () {
+  const context = yield* Effect10.context();
+  const controller = yield* Effect10.sync(() => {
     let instance = null;
     const transport = create?.({
-      token: () => Effect8.runPromiseWith(context)(connection.getSyncToken()),
+      token: () => Effect10.runPromiseWith(context)(connection.getSyncToken()),
       onSummary: (summary) => instance?.observe(summary)
     }) ?? null;
     instance = new WhiteboardControllerRuntime(connection, store, transport);
     return instance;
   });
-  yield* Effect8.addFinalizer(() => Effect8.sync(() => controller.dispose()));
+  yield* Effect10.addFinalizer(() => Effect10.sync(() => controller.dispose()));
   return controller;
 });
 var WhiteboardControllerRuntime = class {
@@ -4217,15 +6190,17 @@ function sameError2(left, right) {
 }
 
 // src/space-client/controller-effects.ts
-var ControllerEffectsService = class extends Context10.Service()("@chalk/client/ControllerEffects") {
+var ControllerEffectsService = class extends Context12.Service()("@chalk/client/ControllerEffects") {
 };
-var makeControllerEffects = (input) => Effect9.gen(function* () {
+var makeControllerEffects = (input) => Effect11.gen(function* () {
+  const offlineActions = yield* makeOfflineActions({ connection: input.connection, store: input.store, storage: input.offlineActionsStorage, storageKey: input.offlineActionsStorageKey });
   const media = yield* makeMediaController(input.connection, input.store, input.mediaDeviceSelection, input.episodeDiagnostics);
-  const chat = yield* makeChatController({ connection: input.connection, store: input.store, createTransport: input.featureFactories?.createChatFileTransport, apiBaseUrl: input.apiBaseUrl, fetch: input.fetch, episodeDiagnostics: input.episodeDiagnostics });
-  const participants = yield* makeParticipantsController(input.connection, input.store, input.episodeDiagnostics);
+  const chat = yield* makeChatController({ connection: input.connection, store: input.store, createTransport: input.featureFactories?.createChatFileTransport, apiBaseUrl: input.apiBaseUrl, fetch: input.fetch, episodeDiagnostics: input.episodeDiagnostics, offline: offlineActions });
+  const participants = yield* makeParticipantsController(input.connection, input.store, input.episodeDiagnostics, offlineActions);
   const reactions = yield* makeReactionsController(input.connection, input.store, input.episodeDiagnostics);
+  const recording = yield* makeRecordingController(input.connection, input.store, input.episodeDiagnostics);
   const whiteboard = yield* makeWhiteboardController(input.connection, input.store, input.featureFactories?.createWhiteboardClient);
-  return { media, chat, participants, reactions, whiteboard };
+  return { media, offline: offlineActions, chat, participants, reactions, recording, whiteboard };
 });
 
 // src/space-client/media-device-selection.ts
@@ -4280,7 +6255,7 @@ function requireDeviceId(deviceId) {
 }
 
 // src/space-client/episode-diagnostic-runtime.ts
-import { encodedEventSize, getActionContract, parseDiagnosticEventDraft, redactDiagnosticAttributes } from "@q9labsai/diagnostics-contracts";
+import { encodedEventSize, getActionContract, parseDiagnosticEventDraft as parseDiagnosticEventDraft2, redactDiagnosticAttributes as redactDiagnosticAttributes2 } from "@q9labsai/diagnostics-contracts";
 var DEFAULT_RING_EVENTS = 256;
 var DEFAULT_RING_BYTES = 256 * 1024;
 var DEFAULT_RING_AGE_MS = 2 * 60 * 1e3;
@@ -4388,6 +6363,15 @@ var EpisodeDiagnosticRuntime = class {
   activeContext() {
     return this.#enabled() ? this.context() : void 0;
   }
+  /** Internal Feedback seam. It returns only a short-lived verified credential to the private transport. */
+  feedbackCredentialUnsafe() {
+    if (!this.#enabled() || !this.#credential) return null;
+    return Object.freeze({ ...this.#credential });
+  }
+  feedbackAvailabilityUnsafe() {
+    if (this.#disposed) return "disposed";
+    return this.#enabled() ? "available" : "disabled";
+  }
   startOperation(name, attributes, parentOperationRef, producerOperationRef, correlationInput) {
     if (!this.#enabled()) return void 0;
     const credentialGeneration = this.#credential?.generation;
@@ -4453,7 +6437,7 @@ var EpisodeDiagnosticRuntime = class {
     });
   }
   #draft(input) {
-    return parseDiagnosticEventDraft(
+    return parseDiagnosticEventDraft2(
       buildDraftInput(input, {
         eventId: safeId(this.#createId()),
         producerSequence: ++this.#sequence,
@@ -4764,7 +6748,7 @@ function buildDraftInput(input, context) {
     expectation: expectationFor(contract, checkpoint),
     correlation: optionalCorrelation(correlation),
     release: context.release,
-    attributes: redactDiagnosticAttributes(input.attributes).attributes
+    attributes: redactDiagnosticAttributes2(input.attributes).attributes
   };
 }
 function eventReferences(input) {
@@ -4885,9 +6869,125 @@ function renderRegistry() {
   return target[REGISTRY];
 }
 
+// src/feedback/controller.ts
+var DEFAULT_SDK = Object.freeze({ client: "@q9labsai/chalk-client" });
+var DEFAULT_PLATFORM = Object.freeze({ kind: "web" });
+function createFeedbackController(context) {
+  const transport = createFeedbackTransport({
+    baseUrl: context.apiBaseUrl,
+    fetch: context.fetch,
+    credential: context.diagnosticCredential,
+    telemetry: () => context.telemetry ?? context.diagnosticContext()
+  });
+  let disposed = false;
+  const ensureActive = () => {
+    if (disposed) throw new FeedbackTransportError({ code: "unavailable", recoverable: false, message: "Feedback has been disposed." });
+  };
+  const prepare = async (input = {}) => {
+    ensureActive();
+    const collectionInput = evidenceInput(input.evidence);
+    const screenshot = await resolveScreenshot(input.screenshot_provider ?? input.screenshotProvider);
+    ensureActive();
+    const initialInput = { ...collectionInput, screenshot };
+    const idempotencyKey = idempotencyKeyFor(context.createId);
+    const preparedEvidence = collectFeedbackEvidenceFromContext(initialInput, context);
+    const preparedScreenshot = capturedScreenshot(screenshot) ? screenshotPayload(screenshot).screenshot : void 0;
+    let cachedRequest;
+    const prepared = {
+      idempotency_key: idempotencyKey,
+      evidence: preparedEvidence,
+      ...preparedScreenshot ? { screenshot: preparedScreenshot } : {},
+      collect: (nextInput) => {
+        ensureActive();
+        return collectFeedbackEvidenceFromContext(nextInput ?? initialInput, context);
+      },
+      send: async ({ category, message }) => {
+        ensureActive();
+        const normalizedMessage = assertFeedbackMessage(message);
+        const request = cachedRequest ?? parseFeedbackReportRequest({
+          schema_version: FEEDBACK_REQUEST_SCHEMA_VERSION,
+          category,
+          message: normalizedMessage,
+          source: input.source ?? context.source,
+          evidence: preparedEvidence,
+          ...preparedScreenshot ? { screenshot: preparedScreenshot } : {}
+        });
+        cachedRequest ??= request;
+        return transport.send({ request, idempotencyKey });
+      }
+    };
+    return prepared;
+  };
+  const send = async (input) => {
+    ensureActive();
+    const source = input.source ?? context.source;
+    const evidenceInput2 = input.evidence ?? defaultEvidenceInput();
+    const screenshot = input.screenshot ?? evidenceInput2.screenshot;
+    return sendRequest({ category: input.category, message: input.message, source, evidence: { ...evidenceInput2, ...screenshot ? { screenshot } : {} }, idempotencyKey: input.idempotency_key ?? input.idempotencyKey ?? idempotencyKeyFor(context.createId) });
+  };
+  const sendRequest = async (input) => {
+    ensureActive();
+    const evidence = collectFeedbackEvidenceFromContext(input.evidence, context);
+    const request = parseFeedbackReportRequest({ schema_version: FEEDBACK_REQUEST_SCHEMA_VERSION, category: input.category, message: assertFeedbackMessage(input.message), source: input.source ?? context.source, evidence, ...screenshotPayload(input.evidence.screenshot) });
+    return transport.send({ request, idempotencyKey: input.idempotencyKey });
+  };
+  return {
+    prepare,
+    send,
+    dispose: () => {
+      disposed = true;
+    }
+  };
+}
+function evidenceInput(input) {
+  const base = { sdk: input?.sdk ?? DEFAULT_SDK, platform: input?.platform ?? DEFAULT_PLATFORM };
+  if (!input) return base;
+  return { ...base, ...optionalEvidenceInput(input) };
+}
+function optionalEvidenceInput(input) {
+  return {
+    ...input.app ? { app: input.app } : {},
+    ...input.local_state ? { local_state: input.local_state } : {},
+    ...input.cookies ? { cookies: input.cookies } : {}
+  };
+}
+function defaultEvidenceInput() {
+  return { sdk: DEFAULT_SDK, platform: DEFAULT_PLATFORM };
+}
+async function resolveScreenshot(provider) {
+  if (!provider) return { state: "unavailable", failure_code: "unsupported" };
+  let timeout;
+  try {
+    return await Promise.race([
+      provider(),
+      new Promise((resolve) => {
+        timeout = globalThis.setTimeout(() => resolve({ state: "unavailable", failure_code: "capture_failed" }), 5e3);
+      })
+    ]);
+  } catch {
+    return { state: "unavailable", failure_code: "capture_failed" };
+  } finally {
+    globalThis.clearTimeout(timeout);
+  }
+}
+function capturedScreenshot(input) {
+  return input.state === "captured" || input.state === "partial" ? input : void 0;
+}
+function screenshotPayload(input) {
+  if (!input) return {};
+  const screenshot = capturedScreenshot(input);
+  return screenshot ? { screenshot: { schema_version: "FeedbackScreenshot/v1", mime_type: screenshot.mime_type, width: screenshot.width, height: screenshot.height, captured_at: screenshot.captured_at, data_base64: screenshot.data_base64 } } : {};
+}
+function idempotencyKeyFor(createId) {
+  const generated = createId();
+  if (/^[A-Za-z0-9_-]{16,128}$/u.test(generated)) return generated;
+  if (typeof globalThis.crypto?.randomUUID === "function") return globalThis.crypto.randomUUID();
+  return `feedback-${Date.now()}-${Math.random().toString(36).slice(2, 18)}`;
+}
+
 // src/space-client/core.ts
 var syncClientsByDependencies = /* @__PURE__ */ new WeakMap();
-var SpaceClientCoreService = class extends Context11.Service()("@chalk/client/SpaceClientCore") {
+var SpaceClientCoreService = class extends Context13.Service()("@chalk/client/SpaceClientCore") {
 };
 var makeSpaceClientCoreLayer = (options, platform = {}) => {
   const apiBaseUrl = normalizedBaseUrl2(platform.apiBaseUrl ?? options.baseUrl ?? "https://api.chalkmeet.com");
@@ -4900,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.15" }
+    release: { id: "chalk-client@4.1.17" }
   });
   const diagnosticSyncClients = /* @__PURE__ */ new Set();
   const dependencies = {
@@ -4922,6 +7022,7 @@ var makeSpaceClientCoreLayer = (options, platform = {}) => {
     initialCameraEnabled: platform.initialCameraEnabled,
     telemetry: platform.telemetry,
     recordRtcSummary: platform.recordRtcSummary,
+    recordReconnect: platform.recordReconnect,
     dependencies,
     diagnostics: {
       onEvent: (event) => {
@@ -4930,30 +7031,49 @@ var makeSpaceClientCoreLayer = (options, platform = {}) => {
       }
     }
   });
-  return makeSpaceClientCoreLayerFromServices(options, platform).pipe(Layer11.provideMerge(Layer11.mergeAll(makeSpaceStoreLayer, lifecycle, makeConnectionPlatformLayer(dependencies), liveClock(dependencies))));
+  return makeSpaceClientCoreLayerFromServices(options, platform).pipe(Layer13.provideMerge(Layer13.mergeAll(makeSpaceStoreLayer, lifecycle, makeConnectionPlatformLayer(dependencies), liveClock(dependencies))));
 };
-var makeSpaceClientCoreLayerFromServices = (options, platform = {}) => Layer11.effect(
+var makeSpaceClientCoreLayerFromServices = (options, platform = {}) => Layer13.effect(
   SpaceClientCoreService,
-  Effect10.gen(function* () {
-    const store = yield* Effect10.service(SpaceStoreService);
-    const lifecycle = yield* Effect10.service(ConnectionLifecycleService);
-    const dependencies = yield* Effect10.service(ConnectionPlatformService);
+  Effect12.gen(function* () {
+    const store = yield* Effect12.service(SpaceStoreService);
+    const lifecycle = yield* Effect12.service(ConnectionLifecycleService);
+    const dependencies = yield* Effect12.service(ConnectionPlatformService);
     const space = options.space.trim();
-    if (space.length === 0) return yield* Effect10.die(new TypeError("A Space slug is required"));
-    if (typeof options.getAccess !== "function") return yield* Effect10.die(new TypeError("getAccess is required"));
+    if (space.length === 0) return yield* Effect12.die(new TypeError("A Space slug is required"));
+    if (typeof options.getAccess !== "function") return yield* Effect12.die(new TypeError("getAccess is required"));
     const apiBaseUrl = normalizedBaseUrl2(platform.apiBaseUrl ?? options.baseUrl ?? "https://api.chalkmeet.com");
     const selection = new MediaDeviceSelection(dependencies.mediaDevices);
     const episodeDiagnostics = episodeDiagnosticsForDependencies(dependencies);
     if (episodeDiagnostics) registerEpisodeDiagnosticConnection(lifecycle, episodeDiagnostics);
-    const controllers = yield* makeControllerEffects({ apiBaseUrl, connection: lifecycle, store, mediaDeviceSelection: selection, featureFactories: dependencies, fetch: platform.fetch, episodeDiagnostics });
-    return yield* Effect10.acquireRelease(
-      Effect10.sync(() => new SpaceClientCore(lifecycle, selection, store, controllers, episodeDiagnostics, dependencies, syncClientsByDependencies.get(dependencies))),
-      (core) => Effect10.sync(() => core.dispose())
+    const controllers = yield* makeControllerEffects({
+      offlineActionsStorage: options.offlineActionsStorage,
+      offlineActionsStorageKey: `chalk:offline-actions:${JSON.stringify([apiBaseUrl, space])}`,
+      apiBaseUrl,
+      connection: lifecycle,
+      store,
+      mediaDeviceSelection: selection,
+      featureFactories: dependencies,
+      fetch: platform.fetch,
+      episodeDiagnostics
+    });
+    return yield* Effect12.acquireRelease(
+      Effect12.sync(
+        () => new SpaceClientCore(lifecycle, selection, store, controllers, episodeDiagnostics, dependencies, syncClientsByDependencies.get(dependencies), {
+          apiBaseUrl,
+          fetch: platform.fetch,
+          createId: platform.randomUUID ?? dependencies.createId ?? lifecycle.createId,
+          source: platform.feedbackSource ?? "embedded",
+          telemetry: platform.telemetry
+        })
+      ),
+      (core) => Effect12.sync(() => core.dispose())
     );
   })
 );
 var SpaceClientCore = class {
   controllers;
+  feedback;
   #connection;
   #store;
   #episodeDiagnostics;
@@ -4962,24 +7082,46 @@ 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;
   #leaveOperation;
   #participantJoinOperation;
   #syncConnectOperation;
-  constructor(connection, _selection, store, controllers, episodeDiagnostics, episodeDiagnosticDependencies, episodeDiagnosticSyncClients) {
+  constructor(connection, _selection, store, controllers, episodeDiagnostics, episodeDiagnosticDependencies, episodeDiagnosticSyncClients, feedback) {
     this.#connection = connection;
     this.#store = store;
     this.controllers = controllers;
     this.#episodeDiagnostics = episodeDiagnostics;
     this.#episodeDiagnosticDependencies = episodeDiagnosticDependencies;
     this.#episodeDiagnosticSyncClients = episodeDiagnosticSyncClients;
+    this.feedback = createFeedbackController({
+      apiBaseUrl: feedback?.apiBaseUrl ?? "https://api.chalkmeet.com",
+      fetch: feedback?.fetch,
+      createId: feedback?.createId ?? connection.createId,
+      now: connection.nowUnsafe,
+      source: feedback?.source ?? "embedded",
+      telemetry: feedback?.telemetry,
+      diagnosticContext: () => episodeDiagnostics?.activeContext(),
+      connection: connection.getSnapshot,
+      diagnosticCredential: () => episodeDiagnostics?.feedbackCredentialUnsafe() ?? null,
+      diagnosticAvailability: () => episodeDiagnostics?.feedbackAvailabilityUnsafe() ?? "unavailable",
+      diagnosticSnapshot: () => {
+        const inspected = episodeDiagnostics?.inspect();
+        return { dropped: inspected?.dropped ?? 0, events: inspected?.ring ?? [] };
+      }
+    });
     this.#store.updateConnection(connection.getSnapshot());
     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();
@@ -4992,47 +7134,47 @@ var SpaceClientCore = class {
   join(options = {}) {
     this.#participantJoinOperation = this.#episodeDiagnostics?.startOperation("participant.join");
     this.#syncConnectOperation = this.#episodeDiagnostics?.startOperation("sync.connect");
-    return Effect10.sync(() => this.#requireActive()).pipe(
-      Effect10.tap(() => Effect10.sync(() => this.controllers.media.configure(options))),
-      Effect10.andThen(this.#connection.configureJoin(options)),
-      Effect10.andThen(this.#connection.join()),
-      Effect10.andThen(options.displayName === void 0 ? Effect10.void : this.controllers.participants.renameSelf(options.displayName)),
-      Effect10.tap(
-        () => Effect10.sync(() => {
+    return Effect12.sync(() => this.#requireActive()).pipe(
+      Effect12.tap(() => Effect12.sync(() => this.controllers.media.configure(options))),
+      Effect12.andThen(this.#connection.configureJoin(options)),
+      Effect12.andThen(this.#connection.join()),
+      Effect12.andThen(options.displayName === void 0 ? Effect12.void : this.controllers.participants.renameSelf(options.displayName)),
+      Effect12.tap(
+        () => Effect12.sync(() => {
           this.#participantJoinOperation?.succeed();
           this.#syncConnectOperation?.succeed();
         })
       ),
-      Effect10.tapError(
-        () => Effect10.sync(() => {
+      Effect12.tapError(
+        () => Effect12.sync(() => {
           this.#participantJoinOperation?.fail("join_failed");
           this.#syncConnectOperation?.fail("connect_failed");
         })
       ),
-      Effect10.mapError(normalizeClientError)
+      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)
     );
   }
   leave() {
     this.#leaveOperation = this.#episodeDiagnostics?.startOperation("participant.leave");
     return this.#connection.leave().pipe(
-      Effect10.tap(() => Effect10.sync(() => this.#leaveOperation?.succeed())),
-      Effect10.tapError(() => Effect10.sync(() => this.#leaveOperation?.fail("leave_failed"))),
-      Effect10.mapError(normalizeClientError)
+      Effect12.tap(() => Effect12.sync(() => this.#leaveOperation?.succeed())),
+      Effect12.tapError(() => Effect12.sync(() => this.#leaveOperation?.fail("leave_failed"))),
+      Effect12.mapError(normalizeClientError)
     );
   }
   endEpisode() {
-    return trackedEffect(
-      this.#episodeDiagnostics,
-      "episode.end.authorized",
-      this.#connection.runCommand(({ sync }) => foreign5(() => sync.endEpisode()).pipe(Effect10.tap(() => this.#connection.confirmEpisodeEnded)))
-    ).pipe(Effect10.asVoid, Effect10.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(
       this.#episodeDiagnostics,
       "episode.deadline.extend",
-      this.#connection.runCommand(({ sync }) => foreign5(() => sync.extendEpisode(minutes)))
-    ).pipe(Effect10.asVoid, Effect10.mapError(normalizeClientError));
+      this.#connection.runCommand(({ sync }) => foreign6(() => sync.extendEpisode(minutes)))
+    ).pipe(Effect12.asVoid, Effect12.mapError(normalizeClientError));
   }
   on(event, handler) {
     this.#handlers[event].add(handler);
@@ -5045,6 +7187,7 @@ var SpaceClientCore = class {
     this.#unsubscribeStore?.();
     this.#unsubscribeConnection = null;
     this.#unsubscribeStore = null;
+    this.feedback.dispose();
     this.#disposeDiagnostics();
     this.#clearHandlers();
   }
@@ -5112,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);
   }
@@ -5122,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);
@@ -5146,25 +7285,25 @@ var SpaceClientCore = class {
   }
 };
 function liveClock(dependencies) {
-  return Layer11.succeed(Clock5.Clock, {
+  return Layer13.succeed(Clock5.Clock, {
     currentTimeMillisUnsafe: dependencies.clock.now,
-    currentTimeMillis: Effect10.sync(dependencies.clock.now),
+    currentTimeMillis: Effect12.sync(dependencies.clock.now),
     currentTimeNanosUnsafe: () => BigInt(dependencies.clock.now()) * 1000000n,
-    currentTimeNanos: Effect10.sync(() => BigInt(dependencies.clock.now()) * 1000000n),
-    sleep: (duration) => Effect10.callback((resume) => {
-      const handle = dependencies.clock.setTimeout(() => resume(Effect10.void), Duration2.toMillis(duration));
-      return Effect10.sync(() => dependencies.clock.clearTimeout(handle));
+    currentTimeNanos: Effect12.sync(() => BigInt(dependencies.clock.now()) * 1000000n),
+    sleep: (duration) => Effect12.callback((resume) => {
+      const handle = dependencies.clock.setTimeout(() => resume(Effect12.void), Duration2.toMillis(duration));
+      return Effect12.sync(() => dependencies.clock.clearTimeout(handle));
     })
   });
 }
-function foreign5(operation) {
-  return Effect10.tryPromise({ try: operation, catch: (cause) => cause });
+function foreign6(operation) {
+  return Effect12.tryPromise({ try: operation, catch: (cause) => cause });
 }
 function trackedEffect(diagnostics, name, effect) {
   const operation = diagnostics?.startOperation(name);
   return effect.pipe(
-    Effect10.tap(() => Effect10.sync(() => operation?.succeed())),
-    Effect10.tapError(() => Effect10.sync(() => operation?.fail("operation_failed")))
+    Effect12.tap(() => Effect12.sync(() => operation?.succeed())),
+    Effect12.tapError(() => Effect12.sync(() => operation?.fail("operation_failed")))
   );
 }
 async function resolveAccessGrant(input) {
@@ -5186,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) });
+  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";
@@ -5225,17 +7364,17 @@ function sameDiagnosticTrack(left, right) {
 }
 
 // src/space-client/space-client.ts
-import { Effect as Effect12, ManagedRuntime } from "effect";
+import { Effect as Effect14, ManagedRuntime } from "effect";
 
 // src/space-client/promise-facade.ts
-import { Effect as Effect11 } from "effect";
+import { Effect as Effect13 } from "effect";
 function toPromiseController(runtime, controller) {
   const projected = {};
   for (const [name, command] of Object.entries(controller)) {
     if (name === "configure" || name === "dispose") continue;
     projected[name] = (...args) => {
       const result = command(...args);
-      return Effect11.isEffect(result) ? runtime.runPromise(result) : result;
+      return Effect13.isEffect(result) ? runtime.runPromise(result) : result;
     };
   }
   return projected;
@@ -5243,24 +7382,30 @@ function toPromiseController(runtime, controller) {
 
 // src/space-client/space-client.ts
 var PromiseSpaceClient = class {
+  feedback;
   media;
   chat;
   participants;
+  offline;
   reactions;
+  recording;
   whiteboard;
   #core;
   #runtime;
   #disposed = false;
   constructor(options, platform) {
     this.#runtime = ManagedRuntime.make(makeSpaceClientCoreLayer(options, platform));
-    this.#core = this.#runtime.runSync(Effect12.service(SpaceClientCoreService));
+    this.#core = this.#runtime.runSync(Effect14.service(SpaceClientCoreService));
     const controllers = this.#core.controllers;
+    this.feedback = this.#core.feedback;
     this.media = toPromiseController(this.#runtime, controllers.media);
     const chat = toPromiseController(this.#runtime, controllers.chat);
-    const { upload, url, ...chatCommands } = chat;
-    this.chat = { ...chatCommands, files: { upload, url } };
+    const { upload, url, resolveUrl, ...chatCommands } = chat;
+    this.chat = { ...chatCommands, files: { upload, url, resolveUrl } };
+    this.offline = toPromiseController(this.#runtime, controllers.offline);
     this.participants = toPromiseController(this.#runtime, controllers.participants);
     this.reactions = toPromiseController(this.#runtime, controllers.reactions);
+    this.recording = toPromiseController(this.#runtime, controllers.recording);
     this.whiteboard = toPromiseController(this.#runtime, controllers.whiteboard);
   }
   join = (options) => this.#runtime.runPromise(this.#core.join(options));
@@ -5293,11 +7438,11 @@ export {
   ConnectionPlatformService,
   makeConnectionPlatformLayer,
   makeFakeConnectionPlatformLayer,
+  ChalkWhiteboardV1Error,
   CHALK_CHAT_ATTACHMENT_LIMITS,
   CHALK_CHAT_ATTACHMENT_MIME_TYPES,
   ChalkChatFileError,
   createChalkChatFileHttpTransport,
-  ChalkWhiteboardV1Error,
   createChalkWhiteboardV1FileHttpTransport,
   encodeWhiteboardV1ClientFrame,
   decodeWhiteboardV1ServerFrame,
@@ -5312,6 +7457,35 @@ export {
   SpaceStoreService,
   makeSpaceStoreLayer,
   makeFakeSpaceStoreLayer,
+  FEEDBACK_EVIDENCE_SCHEMA_VERSION,
+  FEEDBACK_REQUEST_SCHEMA_VERSION,
+  FEEDBACK_RECEIPT_SCHEMA_VERSION,
+  FEEDBACK_SCREENSHOT_SCHEMA_VERSION,
+  FEEDBACK_LOCAL_STATE_REGISTRY_VERSION,
+  FEEDBACK_COOKIE_REGISTRY_VERSION,
+  FEEDBACK_MAX_MESSAGE_BYTES,
+  FEEDBACK_MAX_EVIDENCE_BYTES,
+  FEEDBACK_MAX_REQUEST_BYTES,
+  FEEDBACK_MAX_SCREENSHOT_BYTES,
+  FEEDBACK_MAX_SCREENSHOT_WIDTH,
+  FEEDBACK_MAX_SCREENSHOT_HEIGHT,
+  FEEDBACK_MAX_TELEMETRY_EVENTS,
+  FEEDBACK_MAX_DIAGNOSTIC_EVENTS,
+  FEEDBACK_MAX_LOCAL_STATE_ENTRIES,
+  FEEDBACK_MAX_COOKIE_ENTRIES,
+  FeedbackValidationError,
+  validateFeedbackReportRequest,
+  parseFeedbackReportRequest,
+  validateFeedbackEvidence,
+  parseFeedbackEvidence,
+  validateFeedbackScreenshot,
+  parseFeedbackScreenshot,
+  assertFeedbackReceipt,
+  assertFeedbackMessage,
+  collectFeedbackEvidence,
+  collectLocalState,
+  collectCookies,
+  FeedbackTransportError,
   SpaceClientCoreService,
   makeSpaceClientCoreLayer,
   makeSpaceClientCoreLayerFromServices,