@q9labsai/chalk-client 4.1.15 → 4.1.16

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

@@ -1,26 +1,38 @@
 import {
   CloudflareRTKClient,
   CloudflareSFUClient,
-  createCloudflareSFUHTTPTransport
-} from "./chunk-PQNSA7ZN.js";
-import {
-  createBrowserSyncLifecycle,
-  createBrowserWebSocketFactory,
-  createV1SyncClient
-} from "./chunk-PWUU6T3R.js";
+  createCloudflareSFUHTTPTransport,
+  describeMediaCaptureError
+} from "./chunk-O7WTAXAY.js";
 import {
   AccessGrantError,
   requireParsedAccessGrant,
   validEpisodeDiagnosticCredential
-} from "./chunk-LSDDADCN.js";
+} from "./chunk-M3S7HNQF.js";
+import {
+  normalizeTelemetryAttributes
+} from "./chunk-EWTITNJ3.js";
 import {
   createTraceContext,
+  journeyHeaders,
   parseTraceparent
-} from "./chunk-NKOKY2AE.js";
+} from "./chunk-HW5TTZL2.js";
+import {
+  ChatAttachmentMimeTypeSchema,
+  V1SyncError,
+  createBrowserSyncLifecycle,
+  createBrowserWebSocketFactory,
+  createV1SyncClient
+} from "./chunk-OKIL2ELF.js";
+import {
+  recordInitialConnection,
+  recordReconnect
+} from "./chunk-RCDXIDCN.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 })
@@ -168,12 +183,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;
   }
 };
 
@@ -291,12 +306,12 @@ var ChalkWhiteboardV1Error = class extends Error {
   operation;
   code;
   recoverable;
-  constructor(failure2, options) {
-    super(failure2.message, options);
+  constructor(failure3, options) {
+    super(failure3.message, options);
     this.name = "ChalkWhiteboardV1Error";
-    this.operation = failure2.operation;
-    this.code = failure2.code;
-    this.recoverable = failure2.recoverable;
+    this.operation = failure3.operation;
+    this.code = failure3.code;
+    this.recoverable = failure3.recoverable;
   }
 };
 
@@ -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 };
@@ -1328,6 +1343,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 +1391,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 +1442,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 +1488,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."));
   }
@@ -1705,11 +1729,11 @@ function createChalkWhiteboardV1Client(options) {
 function createBrowserMediaDevices(mediaDevices = globalThis.navigator?.mediaDevices) {
   return {
     async getUserMedia(constraints) {
-      if (!mediaDevices?.getUserMedia) throw new TypeError("Browser media capture is unavailable");
+      if (!mediaDevices?.getUserMedia) throw new DOMException("Browser media capture is unavailable", "NotSupportedError");
       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 +1826,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 +1858,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 +1879,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}`
   });
 }
@@ -1941,12 +1972,12 @@ var ConnectionError = class extends Error {
   code;
   action;
   recoverable;
-  constructor(failure2, options) {
-    super(failure2.message, options);
+  constructor(failure3, options) {
+    super(failure3.message, options);
     this.name = "ConnectionError";
-    this.code = failure2.code;
-    this.action = failure2.action;
-    this.recoverable = failure2.recoverable;
+    this.code = failure3.code;
+    this.action = failure3.action;
+    this.recoverable = failure3.recoverable;
   }
 };
 
@@ -1965,7 +1996,7 @@ var makeConnectionLifecycleLayer = (options) => {
   const platform = { ...defaults, ...options.dependencies };
   const access = makeConnectionAccessLayer(
     (request) => Effect2.tryPromise({
-      try: () => Promise.resolve(options.access(request)),
+      try: (signal) => Promise.resolve(options.access(request ? { ...request, signal } : void 0)),
       catch: (cause) => new ConnectionAccessFailure({ code: "access.unavailable", cause })
     }),
     options.accessRefreshWindowMs
@@ -2006,6 +2037,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       sync: null,
       media: null,
       syncSnapshot: null,
+      syncNoticeUnresponsive: false,
       mediaSnapshot: null,
       failure: null,
       initialMedia: (intent) => Effect2.tryPromise({
@@ -2023,7 +2055,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       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 foreign7 = (operation, code = "internal_error", message = "A browser transport operation failed") => Effect2.tryPromise({ try: operation, catch: (cause) => lifecycleFailure(code, true, message, cause) });
     const toPromise = (effect) => Effect2.runPromiseWith(context)(effect);
     const publish = () => Effect2.sync(() => snapshotFor(model, access.currentUnsafe())).pipe(
       Effect2.tap((snapshot) => SubscriptionRef.set(snapshotRef, snapshot)),
@@ -2096,6 +2128,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       model.sync = null;
       model.media = null;
       model.syncSnapshot = null;
+      model.syncNoticeUnresponsive = false;
       model.mediaSnapshot = null;
       yield* emitPorts();
       if (scope) yield* Scope.close(scope, Exit.void);
@@ -2104,9 +2137,17 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
     });
     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;
@@ -2167,7 +2208,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
     );
     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" })))
       );
@@ -2195,6 +2236,8 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
               access: grant,
               credential: () => toPromise(access.getMediaToken()),
               replaceMediaConnection: () => toPromise(access.refresh("media_recovery", true)).then((replacement) => replacement.media),
+              recordReconnect: options.recordReconnect,
+              telemetry: options.telemetry,
               ...options.recordRtcSummary ? { recordRtcSummary: options.recordRtcSummary } : {},
               onFailure: () => enqueueBackground(handleMediaFailure()),
               onScreenEnded: () => enqueueBackground(notifyScreenEnded())
@@ -2206,7 +2249,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 +2259,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,17 +2269,17 @@ 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"));
             }
             yield* stopPorts();
-            if (!retried && failure2.code === "invalid_access") return yield* performJoin("access_retry", true);
+            if (!retried && failure3.code === "invalid_access") 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);
+            span.end({ state: model.state, epoch: model.epoch, outcome: "failed", code: failure3.code });
+            return yield* Effect2.fail(failure3);
           }),
           onSuccess: () => Effect2.gen(function* () {
             model.syncSnapshot = model.sync?.getSnapshot() ?? null;
@@ -2262,7 +2305,7 @@ 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 withFreshAccess = (operation) => Effect2.gen(function* () {
@@ -2290,6 +2333,19 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
         })
       );
     });
+    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* recoverEffect() {
       if (!active(model)) return;
       if (model.recoveryQueued === kind) return;
@@ -2312,10 +2368,11 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       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));
+        if (attempt < plan.attempts) yield* traceRecovery("lifecycle_backoff", Effect2.sleep(recoveryDelay(plan, attempt)));
       }
       return null;
     });
@@ -2339,9 +2396,13 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       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));
+      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));
+      yield* traceRecovery(
+        "media_rebuild",
+        foreign7(() => media.restart(restartInput))
+      );
       model.mediaSnapshot = media.getSnapshot();
       yield* waitForSyncLive(sync, boundedInteger(options.recovery?.budgetMs, RECOVERY_BUDGET_MS, 1, 6e4));
     });
@@ -2354,12 +2415,12 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       model.syncBindingCleanup?.();
       model.sync = null;
       const sync = yield* 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) => lifecycleFailure("sync_start_failed", true, "The sync layer could not start", cause)
       });
       model.sync = sync;
       yield* bindSync(scope, sync);
-      yield* foreign6(() => sync.start());
+      yield* foreign7(() => sync.start());
       yield* waitForSyncLive(sync, boundedInteger(options.recovery?.budgetMs, RECOVERY_BUDGET_MS, 1, 6e4));
       yield* emitPorts();
     });
@@ -2374,9 +2435,9 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
     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 syncNeedsRecovery = (snapshot) => active(model) && snapshot.connection.phase === "terminal";
+    const failForSnapshot = (failure3) => Effect2.gen(function* failForSnapshotEffect() {
+      model.failure = toFailure(failure3);
       yield* stopPorts();
       yield* transition("failed");
     });
@@ -2392,7 +2453,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       const media = model.media;
       if (!media || !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"));
+      const restarted = yield* Effect2.exit(foreign7(() => media.restart(restartInput), "media_start_failed", "The media client could not apply a replacement access grant"));
       if (restarted._tag === "Failure") {
         yield* recover("media");
         return;
@@ -2502,7 +2563,7 @@ 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) }),
+    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
   });
 }
@@ -2578,6 +2639,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 +2675,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 +2701,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 +2717,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 {
@@ -2672,8 +2743,9 @@ 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 status = snapshot.state === "live" && (INTERRUPTED_CONNECTION_PHASES.has(snapshot.connection.sync) || INTERRUPTED_CONNECTION_PHASES.has(snapshot.connection.media)) ? "reconnecting" : snapshot.state;
+    if (current.status === status && sameEpisode(current.episode, snapshot.episode) && sameError(current.lastError, error2)) return;
+    this.#replace("connection", empty({ status, episode: snapshot.episode, lastError: error2 }));
   }
   updateSelf(value) {
     this.#replace("self", value);
@@ -2690,6 +2762,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);
   }
@@ -2728,11 +2806,943 @@ function sameError(left, right) {
   return left.code === right.code && left.recoverable === right.recoverable && left.message === right.message;
 }
 
+// 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/feedback/validation.ts
+import { isDiagnosticReference, parseDiagnosticEventDraft, redactDiagnosticAttributes } from "@q9labsai/diagnostics-contracts";
+var encoder3 = new TextEncoder();
+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 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 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 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 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 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 Context11, Duration as Duration2, Effect as Effect10, Layer as Layer11 } from "effect";
+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 Context10, Effect as Effect9, Layer as Layer10 } from "effect";
+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
@@ -2744,14 +3754,14 @@ 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 encoder3 = new TextEncoder();
+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 || 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 (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((attachment) => attachment.attachmentId)).size !== attachments.length) return "Chat attachment IDs must be unique";
+  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) {
@@ -2782,16 +3792,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 +3817,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,6 +3831,7 @@ var ChatControllerRuntime = class {
   #fetch;
   #fork;
   #diagnostics;
+  #offline;
   #catchUpRunning = false;
   #catchUpRequested = false;
   #hasOlder = false;
@@ -2838,7 +3849,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 +3866,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 +3885,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 +3946,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 +3967,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 +4005,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;
@@ -3190,7 +4211,7 @@ 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) {
   const extension = ports.sync.getCollaborationExtensionState();
@@ -3242,6 +4263,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([]);
@@ -3368,161 +4393,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 +4700,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 +4714,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 +4724,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 (!snapshot.media || !snapshot.participantId) 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 +4844,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 +4885,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 +4939,265 @@ 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";
+}
 
-// 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 +5228,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 +5268,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 +5282,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 +5304,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 +5337,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 +5447,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 +5483,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 +5532,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 +5561,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 +5576,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 +5753,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 +5818,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 +5926,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 +6000,7 @@ var EpisodeDiagnosticRuntime = class {
     });
   }
   #draft(input) {
-    return parseDiagnosticEventDraft(
+    return parseDiagnosticEventDraft2(
       buildDraftInput(input, {
         eventId: safeId(this.#createId()),
         producerSequence: ++this.#sequence,
@@ -4764,7 +6311,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 +6432,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 +6563,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.16" }
   });
   const diagnosticSyncClients = /* @__PURE__ */ new Set();
   const dependencies = {
@@ -4922,6 +6585,7 @@ var makeSpaceClientCoreLayer = (options, platform = {}) => {
     initialCameraEnabled: platform.initialCameraEnabled,
     telemetry: platform.telemetry,
     recordRtcSummary: platform.recordRtcSummary,
+    recordReconnect: platform.recordReconnect,
     dependencies,
     diagnostics: {
       onEvent: (event) => {
@@ -4930,30 +6594,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;
@@ -4968,13 +6651,29 @@ var SpaceClientCore = class {
   #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());
@@ -4992,47 +6691,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.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));
+      this.#connection.runCommand(({ sync }) => foreign6(() => sync.endEpisode()).pipe(Effect12.tap(() => this.#connection.confirmEpisodeEnded)))
+    ).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 +6744,7 @@ var SpaceClientCore = class {
     this.#unsubscribeStore?.();
     this.#unsubscribeConnection = null;
     this.#unsubscribeStore = null;
+    this.feedback.dispose();
     this.#disposeDiagnostics();
     this.#clearHandlers();
   }
@@ -5146,25 +6846,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 +6886,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), signal: input.request?.signal });
 }
 function accessReason(reason) {
   if (reason === void 0 || reason === "join") return "join";
@@ -5225,17 +6925,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 +6943,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));
@@ -5312,6 +7018,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,