@q9labsai/chalk-client 4.1.17 → 5.0.1

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

@@ -1,33 +1,23 @@
 import {
   AccessGrantError,
-  requireParsedAccessGrant,
-  validEpisodeDiagnosticCredential
-} from "./chunk-ZRMGKMX4.js";
+  requireParsedAccessGrant
+} from "./chunk-2HJIJVE2.js";
 import {
-  CloudflareRTKClient,
   CloudflareSFUClient,
   createCloudflareSFUHTTPTransport,
   describeMediaCaptureError
-} from "./chunk-2DZUHV6I.js";
+} from "./chunk-O2NOZKJP.js";
 import {
   ChatAttachmentMimeTypeSchema,
+  ChatReactionSetFrameSchema,
+  ReactionSchema,
+  ReactionValues,
+  UuidSchema,
   V1SyncError,
   createBrowserSyncLifecycle,
   createBrowserWebSocketFactory,
   createV1SyncClient
-} from "./chunk-CZUJNAUI.js";
-import {
-  recordInitialConnection,
-  recordReconnect
-} from "./chunk-RCDXIDCN.js";
-import {
-  normalizeTelemetryAttributes
-} from "./chunk-EWTITNJ3.js";
-import {
-  createTraceContext,
-  journeyHeaders,
-  parseTraceparent
-} from "./chunk-HW5TTZL2.js";
+} from "./chunk-AVXJ4HQU.js";
 
 // src/access/manager.ts
 import { Clock, Context, Data, Effect, Layer, SynchronizedRef } from "effect";
@@ -46,7 +36,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", (failure3) => failure3.code === "access.invalid" && SynchronizedRef.getUnsafe(state).access === null ? fetch(reason, false, true) : Effect.fail(failure3)));
+    const initialize = (reason = "join") => fetch(reason, false, false).pipe(Effect.catchTag("ConnectionAccessFailure", (failure2) => failure2.code === "access.invalid" && SynchronizedRef.getUnsafe(state).access === null ? fetch(reason, false, true) : Effect.fail(failure2)));
     const millisecondsUntilRefresh = Effect.gen(function* () {
       const access = yield* SynchronizedRef.get(state);
       if (!access.access) return null;
@@ -137,8 +127,6 @@ function mediaBinding(access) {
   switch (access.media.provider) {
     case "cloudflare_sfu":
       return access.media.clientPayload.connectionId;
-    case "cloudflare_rtk":
-      return access.media.clientPayload.providerSubject;
   }
 }
 function expiresAt(value) {
@@ -159,16 +147,17 @@ var ChalkWhiteboardV1Error = class extends Error {
   operation;
   code;
   recoverable;
-  constructor(failure3, options) {
-    super(failure3.message, options);
+  constructor(failure2, options) {
+    super(failure2.message, options);
     this.name = "ChalkWhiteboardV1Error";
-    this.operation = failure3.operation;
-    this.code = failure3.code;
-    this.recoverable = failure3.recoverable;
+    this.operation = failure2.operation;
+    this.code = failure2.code;
+    this.recoverable = failure2.recoverable;
   }
 };
 
 // src/collaboration/types.ts
+var CHALK_REACTIONS = ReactionValues;
 var CHALK_CHAT_ATTACHMENT_LIMITS = {
   maximumPerMessage: 5,
   maximumByteLength: 25 * 1024 * 1024,
@@ -197,12 +186,12 @@ var ChalkChatFileError = class extends Error {
   operation;
   code;
   recoverable;
-  constructor(failure3, options) {
-    super(failure3.message, options);
+  constructor(failure2, options) {
+    super(failure2.message, options);
     this.name = "ChalkChatFileError";
-    this.operation = failure3.operation;
-    this.code = failure3.code;
-    this.recoverable = failure3.recoverable;
+    this.operation = failure2.operation;
+    this.code = failure2.code;
+    this.recoverable = failure2.recoverable;
   }
 };
 
@@ -315,28 +304,13 @@ function isAllowedMimeType(value) {
   return typeof value === "string" && CHALK_CHAT_ATTACHMENT_MIME_TYPES.includes(value);
 }
 
-// src/whiteboard/file-http-transport.ts
-function createChalkWhiteboardV1FileHttpTransport(options) {
+// src/whiteboard/file-download-transport.ts
+function createChalkWhiteboardV1FileDownloadTransport(options) {
   const fetchImplementation = options.fetch ?? globalThis.fetch;
-  const baseUrl = options.baseUrl.replace(/\/+$/u, "");
+  let baseUrlEnd = options.baseUrl.length;
+  while (baseUrlEnd > 0 && options.baseUrl[baseUrlEnd - 1] === "/") baseUrlEnd -= 1;
+  const baseUrl = options.baseUrl.slice(0, baseUrlEnd);
   return {
-    initiateUpload: async (input) => {
-      const response = await authorizedFetch(fetchImplementation, options.token, `${baseUrl}/v1/whiteboard/files/uploads`, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ ...input, sceneId: options.sceneId() })
-      });
-      if (!response.ok) throw await responseError2(response, "initiate_file_upload");
-      const value = await response.json();
-      if (!isInitiateUploadResponse2(value)) {
-        throw whiteboardError("initiate_file_upload", "file_transfer_failed", false, "Whiteboard upload service returned an invalid response.");
-      }
-      return value;
-    },
-    finalizeUpload: async (uploadId) => {
-      const response = await authorizedFetch(fetchImplementation, options.token, `${baseUrl}/v1/whiteboard/files/uploads/${encodeURIComponent(uploadId)}/finalize`, { method: "POST" });
-      if (!response.ok) throw await responseError2(response, "finalize_file_upload");
-    },
     getDownloadUrl: async (fileId) => {
       const response = await authorizedFetch(fetchImplementation, options.token, `${baseUrl}/v1/whiteboard/files/${encodeURIComponent(fileId)}/download`, { method: "GET" });
       if (!response.ok) throw await responseError2(response, "get_file_download");
@@ -357,7 +331,7 @@ async function authorizedFetch(fetchImplementation, token, url, init) {
   } catch (cause) {
     throw new ChalkWhiteboardV1Error(
       {
-        operation: operationFromUrl(url),
+        operation: "get_file_download",
         code: "storage_unavailable",
         recoverable: true,
         message: "Whiteboard file storage is unavailable."
@@ -370,26 +344,15 @@ async function responseError2(response, operation) {
   const code = response.status === 401 || response.status === 403 ? "permission_denied" : response.status === 400 ? "invalid_payload" : response.status >= 500 || response.status === 429 ? "storage_unavailable" : "file_transfer_failed";
   return whiteboardError(operation, code, response.status >= 500 || response.status === 429, "Whiteboard file request failed.");
 }
-function operationFromUrl(url) {
-  if (url.endsWith("/finalize")) return "finalize_file_upload";
-  if (url.endsWith("/download")) return "get_file_download";
-  return "initiate_file_upload";
-}
 function whiteboardError(operation, code, recoverable, message) {
   return new ChalkWhiteboardV1Error({ operation, code, recoverable, message });
 }
-function isInitiateUploadResponse2(value) {
-  return isExactObject(value, ["uploadId", "method", "uploadUrl", "headers", "expiresAt"]) && typeof value.uploadId === "string" && value.method === "PUT" && isHttpUrl2(value.uploadUrl) && isStringRecord2(value.headers) && isDate2(value.expiresAt);
-}
 function isDownloadResponse2(value) {
   return isExactObject(value, ["downloadUrl", "expiresAt"]) && isHttpUrl2(value.downloadUrl) && isDate2(value.expiresAt);
 }
 function isExactObject(value, keys) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
 }
-function isStringRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
-}
 function isHttpUrl2(value) {
   if (typeof value !== "string") return false;
   try {
@@ -558,13 +521,6 @@ var WhiteboardV1ProtocolMetadata = {
     durablePayloadContainsContent: false
   },
   fileTransport: {
-    initiateUploadResult: {
-      method: "PUT",
-      uploadUrl: "string",
-      headers: "exact-string-map",
-      expiresAt: "rfc3339"
-    },
-    finalizeVerifies: ["provider_existence", "byte_length", "sha256", "mime_type", "immutable_object_identity", "active_scene", "file_id_uniqueness", "participant_authorization"],
     download: "participant-bound-short-lived-url"
   },
   persistence: {
@@ -921,8 +877,11 @@ function completeAssembly(assembly) {
 // src/whiteboard/v1-client.ts
 var CLIENT_RESTART_CLOSE_CODE = 4e3;
 var DEPENDENCY_UNAVAILABLE_CLOSE_CODE = 1012;
-var HEARTBEAT_INTERVAL_MS = 2e4;
-var MAX_MISSED_HEARTBEATS = 2;
+var HEARTBEAT_INTERVAL_MS = 4e3;
+var SLOW_HEARTBEAT_MS = 2e3;
+var MAX_SLOW_HEARTBEATS = 2;
+var MAX_TIMER_DRIFT_MS = 250;
+var MAX_SLOW_CONNECTION_BACKOFF_MS = 4e3;
 var DEFAULT_RECONNECT_DELAY_MS = 250;
 var MAX_RECONNECT_DELAY_MS = 5e3;
 var encoder2 = new TextEncoder();
@@ -962,7 +921,20 @@ var ChalkWhiteboardV1Client = class {
   #reconnectTimer;
   #reconnectAttempt = 0;
   #heartbeatTimer;
-  #missedHeartbeats = 0;
+  #heartbeats = [];
+  #ignoredHeartbeats = 0;
+  #slowHeartbeats = 0;
+  #nextSlowConnectionReplacementAt = 0;
+  #heartbeatDueAt = 0;
+  #lastProgressAt = Number.NEGATIVE_INFINITY;
+  #slowConnectionBackoffMs = 0;
+  #healthySince = null;
+  #roundTrips = [];
+  #resumedAt = Number.NEGATIVE_INFINITY;
+  #visibilityChanged = () => {
+    this.#resumedAt = this.#elapsedNow();
+    this.#resetProbeState();
+  };
   #lastCursorAt = Number.NEGATIVE_INFINITY;
   #unsubscribeLifecycle;
   #transportAvailable = true;
@@ -971,6 +943,9 @@ var ChalkWhiteboardV1Client = class {
   #inbound = Promise.resolve();
   constructor(options) {
     assertWhiteboardV1Url(options.url);
+    if (options.clock && typeof options.clock.monotonicNow !== "function") {
+      throw new TypeError("whiteboard clock.monotonicNow must use the same timeline as clock.setTimeout");
+    }
     this.#options = options;
     this.files = options.files;
     this.#store = options.pendingStore ?? new InMemoryChalkWhiteboardV1PendingOperationStore();
@@ -981,6 +956,7 @@ var ChalkWhiteboardV1Client = class {
     if (this.#stopPromise) return this.#stopPromise.then(() => this.startSceneSubscription());
     if (this.#started && this.#startPromise) return this.#startPromise;
     this.#started = true;
+    globalThis.document?.addEventListener("visibilitychange", this.#visibilityChanged);
     this.#useLegacyHello = false;
     this.#phase = "connecting";
     this.#publishSummary("loading", null);
@@ -1005,6 +981,7 @@ var ChalkWhiteboardV1Client = class {
   }
   #stopNow() {
     this.#started = false;
+    this.#removeVisibilityListener();
     this.#startupGeneration += 1;
     this.#unsubscribeLifecycle?.();
     this.#unsubscribeLifecycle = void 0;
@@ -1139,6 +1116,7 @@ var ChalkWhiteboardV1Client = class {
     }
   }
   #failStartup(cause) {
+    this.#removeVisibilityListener();
     const startupFailure = failure("start_scene_subscription", "unavailable", true, "Unable to restore whiteboard retry state.");
     this.#started = false;
     this.#phase = "idle";
@@ -1175,7 +1153,12 @@ var ChalkWhiteboardV1Client = class {
       if (typeof data !== "string" || encoder2.encode(data).byteLength > WhiteboardV1ProtocolLimits.encodedOutboundFrameBytes) {
         throw new Error("invalid whiteboard frame size");
       }
-      this.#handleFrame(decodeWhiteboardV1ServerFrame(data));
+      const frame = decodeWhiteboardV1ServerFrame(data);
+      if (frame.type !== "pong") {
+        this.#lastProgressAt = this.#elapsedNow();
+        this.#resetProbeState();
+      }
+      this.#handleFrame(frame);
     } catch {
       socket.close(1009, "invalid whiteboard frame");
     }
@@ -1238,7 +1221,7 @@ var ChalkWhiteboardV1Client = class {
         return;
       case "pong":
         this.#requireLive();
-        this.#missedHeartbeats = 0;
+        this.#receivePong();
         return;
     }
   }
@@ -1287,7 +1270,7 @@ var ChalkWhiteboardV1Client = class {
     this.#presentationSupported = "presenting" in frame;
     this.#presenting = "presenting" in frame ? frame.presenting : false;
     this.#publishSummary("loading", null);
-    this.#missedHeartbeats = 0;
+    this.#clearHeartbeat();
     const pendingOperations = [...this.#operations.values()].sort((left, right) => compareChalkWhiteboardV1PendingOperations(left.pending, right.pending));
     this.#awaitingOperationIds.clear();
     this.#waitingForOperations = true;
@@ -1296,7 +1279,7 @@ var ChalkWhiteboardV1Client = class {
       this.#sendOperation(entry.pending.frame);
     }
     this.#requestSnapshotAfterOperations();
-    this.#startHeartbeat();
+    this.#startHeartbeat(HEARTBEAT_INTERVAL_MS + Math.max(0, this.#nextSlowConnectionReplacementAt - this.#elapsedNow()));
   }
   #requestSnapshotAfterOperations() {
     if (this.#phase !== "live" || !this.#waitingForOperations || this.#awaitingOperationIds.size > 0) return;
@@ -1494,6 +1477,7 @@ var ChalkWhiteboardV1Client = class {
     this.#publishSummary("recovering", failure("start_scene_subscription", "unavailable", true, "Whiteboard connection interrupted."));
   }
   #failRejectedConnection(closeCode) {
+    this.#removeVisibilityListener();
     const terminalFailure = failure("start_scene_subscription", closeCode === 1008 ? "permission_denied" : "invalid_payload", false, "Whiteboard connection was rejected.");
     this.#started = false;
     this.#publishSummary("failed", terminalFailure);
@@ -1573,19 +1557,88 @@ var ChalkWhiteboardV1Client = class {
     } catch {
     }
   }
-  #startHeartbeat() {
-    this.#clearHeartbeat();
+  #startHeartbeat(delay = HEARTBEAT_INTERVAL_MS) {
+    this.#heartbeatDueAt = this.#elapsedNow() + delay;
     this.#heartbeatTimer = this.#clock().setTimeout(() => {
       this.#heartbeatTimer = void 0;
       if (this.#phase !== "live") return;
-      this.#missedHeartbeats += 1;
-      if (this.#missedHeartbeats > MAX_MISSED_HEARTBEATS) {
-        this.#socket?.close(DEPENDENCY_UNAVAILABLE_CLOSE_CODE, "whiteboard heartbeat timeout");
-        return;
-      }
+      const now = this.#elapsedNow();
+      const qualified = this.#qualifyProbe(now);
+      if (qualified && this.#checkSlowHeartbeats(now)) return;
+      if (qualified) this.#heartbeats.push({ sentAt: now, slow: false });
+      else this.#ignoredHeartbeats += 1;
       this.#send({ type: "ping" });
+      const outstanding = this.#heartbeats.length > 0;
+      this.#startHeartbeat(this.#options.watchdog !== false && outstanding ? SLOW_HEARTBEAT_MS : HEARTBEAT_INTERVAL_MS);
+    }, delay);
+  }
+  #checkSlowHeartbeats(now) {
+    for (const heartbeat of this.#heartbeats) {
+      if (!heartbeat.slow && now - heartbeat.sentAt >= SLOW_HEARTBEAT_MS) {
+        heartbeat.slow = true;
+        this.#healthySince = null;
+        this.#slowHeartbeats += 1;
+      }
+    }
+    return this.#replaceSlowConnection();
+  }
+  #resetProbeState() {
+    this.#ignoredHeartbeats += this.#heartbeats.length;
+    this.#heartbeats.length = 0;
+    this.#slowHeartbeats = 0;
+    this.#roundTrips.length = 0;
+    this.#healthySince = null;
+  }
+  #qualifyProbe(now) {
+    if (this.#options.watchdog === false || globalThis.document?.hidden || now - this.#resumedAt < HEARTBEAT_INTERVAL_MS || now - this.#heartbeatDueAt > MAX_TIMER_DRIFT_MS || now - this.#lastProgressAt < SLOW_HEARTBEAT_MS) {
+      this.#resetProbeState();
+      return false;
+    }
+    return true;
+  }
+  #receivePong() {
+    const now = this.#elapsedNow();
+    const qualified = this.#qualifyProbe(now);
+    if (this.#ignoredHeartbeats > 0) {
+      this.#ignoredHeartbeats -= 1;
+      return;
+    }
+    const heartbeat = this.#heartbeats.shift();
+    if (!heartbeat) {
+      this.#resetProbeState();
+      return;
+    }
+    if (!qualified) return;
+    const roundTrip = now - heartbeat.sentAt;
+    this.#roundTrips.push(roundTrip);
+    if (this.#roundTrips.length > MAX_SLOW_HEARTBEATS) this.#roundTrips.shift();
+    if (roundTrip < SLOW_HEARTBEAT_MS) {
+      this.#slowHeartbeats = 0;
+      this.#healthySince ??= now;
+      if (now - this.#healthySince >= 6e4) this.#slowConnectionBackoffMs = 0;
+      this.#clock().clearTimeout(this.#heartbeatTimer);
       this.#startHeartbeat();
-    }, HEARTBEAT_INTERVAL_MS);
+    } else {
+      this.#healthySince = null;
+      if (!heartbeat.slow) this.#slowHeartbeats += 1;
+    }
+    this.#replaceSlowConnection();
+  }
+  #replaceSlowConnection() {
+    const now = this.#elapsedNow();
+    if (this.#slowHeartbeats < MAX_SLOW_HEARTBEATS || now < this.#nextSlowConnectionReplacementAt) return false;
+    const socket = this.#socket;
+    if (!socket) return false;
+    this.#slowConnectionBackoffMs = Math.min(MAX_SLOW_CONNECTION_BACKOFF_MS, this.#slowConnectionBackoffMs === 0 ? 1e3 : this.#slowConnectionBackoffMs * 2);
+    this.#nextSlowConnectionReplacementAt = now + this.#slowConnectionBackoffMs;
+    const event = { reason: "slow_heartbeat", roundTripsMs: [...this.#roundTrips], outstandingAgesMs: this.#heartbeats.slice(-2).map((heartbeat) => now - heartbeat.sentAt), backoffMs: this.#slowConnectionBackoffMs };
+    this.#disconnected(socket, DEPENDENCY_UNAVAILABLE_CLOSE_CODE);
+    socket.close(CLIENT_RESTART_CLOSE_CODE, "whiteboard connection slow");
+    try {
+      this.#options.onWatchdogReplacement?.(event);
+    } catch {
+    }
+    return true;
   }
   #rejectSnapshots(value) {
     for (const assembly of this.#snapshots.values()) rejectDeferred(assembly.deferred, error(value));
@@ -1621,13 +1674,25 @@ var ChalkWhiteboardV1Client = class {
     this.#reconnectTimer = void 0;
   }
   #clearHeartbeat() {
+    this.#heartbeats.length = 0;
+    this.#ignoredHeartbeats = 0;
+    this.#slowHeartbeats = 0;
+    this.#roundTrips.length = 0;
+    this.#healthySince = null;
     if (this.#heartbeatTimer === void 0) return;
     this.#clock().clearTimeout(this.#heartbeatTimer);
     this.#heartbeatTimer = void 0;
   }
+  #removeVisibilityListener() {
+    globalThis.document?.removeEventListener("visibilitychange", this.#visibilityChanged);
+  }
+  #elapsedNow() {
+    return this.#clock().monotonicNow();
+  }
   #clock() {
     return this.#options.clock ?? {
       now: Date.now,
+      monotonicNow: () => globalThis.performance.now(),
       setTimeout: (callback, milliseconds) => globalThis.setTimeout(callback, milliseconds),
       clearTimeout: (handle) => globalThis.clearTimeout(handle)
     };
@@ -1732,12 +1797,12 @@ var ConnectionError = class extends Error {
   code;
   action;
   recoverable;
-  constructor(failure3, options) {
-    super(failure3.message, options);
+  constructor(failure2, options) {
+    super(failure2.message, options);
     this.name = "ConnectionError";
-    this.code = failure3.code;
-    this.action = failure3.action;
-    this.recoverable = failure3.recoverable;
+    this.code = failure2.code;
+    this.action = failure2.action;
+    this.recoverable = failure2.recoverable;
   }
 };
 
@@ -1759,7 +1824,9 @@ function createBrowserMediaDevices(mediaDevices = globalThis.navigator?.mediaDev
   };
 }
 function stopStream(stream) {
-  for (const track of stream?.getTracks() ?? []) track.stop();
+  for (const track of stream?.getTracks() ?? []) {
+    if (track.readyState !== "ended") track.stop();
+  }
 }
 function streamFromTracks(tracks) {
   return { getTracks: () => [...tracks] };
@@ -1771,10 +1838,23 @@ function requireDisplayVideoTrack(stream) {
     throw new TypeError("Display capture did not return a video track");
   }
   for (const track of stream.getTracks()) {
-    if (track !== video) track.stop();
+    if (track !== video && track.kind !== "audio") track.stop();
   }
   return video;
 }
+function displayMediaConstraints(options = {}) {
+  return {
+    video: options.surface ? { displaySurface: options.surface } : true,
+    audio: options.audio ? { suppressLocalAudioPlayback: false, echoCancellation: false, noiseSuppression: false, autoGainControl: false } : false,
+    systemAudio: "exclude",
+    selfBrowserSurface: "exclude",
+    surfaceSwitching: "include"
+  };
+}
+function screenShareCapture(track) {
+  const surface = track.getSettings().displaySurface;
+  return { surface: surface === "monitor" || surface === "window" || surface === "browser" ? surface : null, label: track.label || null };
+}
 
 // src/connection/production.ts
 function createDefaultConnectionDependencies(options) {
@@ -1820,16 +1900,6 @@ function createChatFileTransport(apiBaseURL, input) {
   });
 }
 function createMediaClient(apiBaseURL, input) {
-  if (input.access.media.provider === "cloudflare_rtk") {
-    return createRTKConnectionMediaClient(
-      new CloudflareRTKClient({
-        authToken: input.access.media.clientPayload.token,
-        participantId: input.access.subject.participantId,
-        onError: input.onFailure,
-        onScreenEnded: input.onScreenEnded
-      })
-    );
-  }
   const { subject } = input.access;
   const replaceMediaConnection = input.replaceMediaConnection;
   const client = new CloudflareSFUClient({
@@ -1842,26 +1912,17 @@ 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
   });
   return createSFUConnectionMediaClient(client);
 }
-function createRTKConnectionMediaClient(client) {
-  return bindConnectionMediaClient(client, (input) => {
-    if (!("provider" in input) || input.provider !== "cloudflare_rtk") throw new TypeError("The RealtimeKit adapter requires a Cloudflare RealtimeKit access grant");
-    return client.restart(input);
-  });
-}
 function createSFUConnectionMediaClient(client) {
   return bindConnectionMediaClient(client, (input) => {
     if ("provider" in input) {
@@ -1878,6 +1939,7 @@ function bindConnectionMediaClient(client, restart) {
     ...client.closeForcedLocalPublication ? { closeForcedLocalPublication: client.closeForcedLocalPublication.bind(client) } : {},
     observeLocalPublications: client.observeLocalPublications.bind(client),
     observeRemotePublications: client.observeRemotePublications.bind(client),
+    ...client.remoteParticipantsChanged ? { remoteParticipantsChanged: client.remoteParticipantsChanged.bind(client) } : {},
     ...client.remotePublicationsChanged ? { remotePublicationsChanged: client.remotePublicationsChanged.bind(client) } : {},
     ...client.remotePublicationResumed ? { remotePublicationResumed: client.remotePublicationResumed.bind(client) } : {},
     start: client.start.bind(client),
@@ -1894,27 +1956,21 @@ function createSyncClient(syncURL, input) {
     url: syncURL,
     token: input.token,
     mediaPlane: input.media,
-    telemetry: input.telemetry,
-    recordReconnect: input.recordReconnect,
+    collaboration: { name: "collaboration_v2", chatCursor: { afterSequence: null, retainedFloorSequence: null } },
     persistenceScope: `${input.access.subject.tenantId}:${input.access.subject.episodeId}:${input.access.subject.participantId}`
   });
 }
 function createWhiteboardClient(apiBaseURL, url, input) {
-  let sceneId = null;
-  const files = createChalkWhiteboardV1FileHttpTransport({
+  const files = createChalkWhiteboardV1FileDownloadTransport({
     baseUrl: apiBaseURL,
-    token: input.token,
-    sceneId: () => {
-      if (sceneId === null) throw new TypeError("Whiteboard scene is not ready");
-      return sceneId;
-    }
+    token: input.token
   });
   return createChalkWhiteboardV1Client({
     url,
     token: input.token,
     files,
+    onWatchdogReplacement: input.onWatchdogReplacement,
     onSummary: (summary) => {
-      sceneId = summary.sceneId;
       input.onSummary(summary);
     }
   });
@@ -2074,6 +2130,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       initialMediaIntent: null,
       intent: { microphone: options.initialMicrophoneEnabled ?? true, camera: options.initialCameraEnabled ?? true },
       episodeEndConfirmed: false,
+      removedByHost: false,
       activeScope: null,
       syncBindingCleanup: null,
       mediaBindingCleanup: null,
@@ -2087,10 +2144,10 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
     };
     const mediaAttempt = { expiresAt: null };
     const foreign7 = (operation, code = "internal_error", message = "A browser transport operation failed") => Effect2.tryPromise({ try: operation, catch: (cause) => lifecycleFailure(code, true, message, cause) });
-    const withinForegroundBudget = (effect, milliseconds, failure3) => Effect2.raceFirst(
+    const withinForegroundBudget = (effect, milliseconds, failure2) => Effect2.raceFirst(
       effect,
       Effect2.callback((resume) => {
-        const cancel = scheduleForegroundDeadline(platform.clock, milliseconds, () => resume(Effect2.fail(failure3)));
+        const cancel = scheduleForegroundDeadline(platform.clock, milliseconds, () => resume(Effect2.fail(failure2)));
         return Effect2.sync(cancel);
       })
     );
@@ -2165,13 +2222,13 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
         access.ensureFresh("scheduled_refresh").pipe(
           Effect2.match({ onSuccess: () => null, onFailure: (cause) => cause }),
           Effect2.flatMap(
-            (failure3) => enqueue(
+            (failure2) => enqueue(
               Effect2.gen(function* () {
                 if (model.epoch !== epoch || !active(model)) return;
                 model.refreshInFlight = false;
-                if (failure3) {
-                  diagnostics.record({ event: "access_refresh_failed", state: model.state, epoch, code: failure3.code === "access.invalid" ? "invalid_access" : "access_unavailable" });
-                  if (failure3.code === "access.invalid") return yield* failForSnapshot(accessFailure(failure3));
+                if (failure2) {
+                  diagnostics.record({ event: "access_refresh_failed", state: model.state, epoch, code: failure2.code === "access.invalid" ? "invalid_access" : "access_unavailable" });
+                  if (failure2.code === "access.invalid") return yield* failForSnapshot(accessFailure(failure2));
                   model.refreshFailures = Math.min(model.refreshFailures + 1, 5);
                   yield* scheduleRefresh(Math.min(BACKGROUND_RETRY_MAX_MS, REFRESH_RETRY_MS * 2 ** (model.refreshFailures - 1)));
                   return;
@@ -2276,7 +2333,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
     }).pipe((effect) => withinForegroundBudget(effect, timeoutMs, lifecycleFailure("sync_start_failed", true, "Sync did not become live before the startup deadline")));
     const trace = (step, effect) => {
       const span = diagnostics.startSpan({ step, state: model.state, epoch: model.epoch });
-      return traceRecovery(step, effect, recordInitialConnection).pipe(
+      return effect.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" })))
       );
@@ -2287,6 +2344,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       model.epoch += 1;
       model.failure = null;
       model.episodeEndConfirmed = false;
+      model.removedByHost = false;
       yield* transition("joining");
       const span = diagnostics.startSpan({ step: "join", state: model.state, epoch: model.epoch });
       const scope = yield* Scope.make("sequential");
@@ -2310,9 +2368,6 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
                 if (media === model.media) mediaAttempt.expiresAt = platform.clock.now() + MEDIA_RECOVERY_TIMEOUT_MS;
                 return replacement.media;
               }),
-              recordReconnect: options.recordReconnect,
-              telemetry: options.telemetry,
-              ...options.recordRtcSummary ? { recordRtcSummary: options.recordRtcSummary } : {},
               onFailure: () => enqueueBackground(handleMediaFailure()),
               onScreenEnded: () => enqueueBackground(notifyScreenEnded())
             }),
@@ -2323,7 +2378,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, recordReconnect: options.recordReconnect }),
+            try: () => platform.createSyncClient({ access: grant, token: () => toPromise(access.getSyncToken()), media }),
             catch: (cause) => accessRejected(cause) ? lifecycleFailure("invalid_access", false, "Access was rejected", cause) : lifecycleFailure("sync_start_failed", true, "The sync layer could not start", cause)
           })
         );
@@ -2343,19 +2398,19 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
         Effect2.matchEffect({
           onFailure: (cause) => Effect2.gen(function* () {
             stopStream(stream);
-            const failure3 = failureFromCause(cause, "sync_start_failed", "The Connection could not start");
-            model.failure = toFailure(failure3);
+            const failure2 = failureFromCause(cause, "sync_start_failed", "The Connection could not start");
+            model.failure = toFailure(failure2);
             if (model.joinCancelled) {
               span.end({ state: model.state, epoch: model.epoch, outcome: "cancelled", code: "invalid_state" });
               return yield* Effect2.fail(lifecycleFailure("invalid_state", false, "Join was cancelled by Leave"));
             }
-            span.end({ state: model.state, epoch: model.epoch, outcome: "failed", code: failure3.code });
-            const retry = !retried && failure3.code === "invalid_access";
-            if (!retry) yield* recordFailure(failure3);
+            span.end({ state: model.state, epoch: model.epoch, outcome: "failed", code: failure2.code });
+            const retry = !retried && failure2.code === "invalid_access";
+            if (!retry) yield* recordFailure(failure2);
             yield* stopPorts();
             if (retry) return yield* performJoin("access_retry", true);
             yield* transition("failed");
-            return yield* Effect2.fail(failure3);
+            return yield* Effect2.fail(failure2);
           }),
           onSuccess: () => Effect2.gen(function* () {
             model.syncSnapshot = model.sync?.getSnapshot() ?? null;
@@ -2412,7 +2467,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
             if (!accessRejected(cause)) return Effect2.fail(cause);
             return requireOpen.pipe(
               Effect2.andThen(access.refreshAfterRejection()),
-              Effect2.mapError((failure3) => failure3 instanceof ConnectionAccessFailure ? accessFailure(failure3) : failure3),
+              Effect2.mapError((failure2) => failure2 instanceof ConnectionAccessFailure ? accessFailure(failure2) : failure2),
               Effect2.andThen(publishFreshAccess()),
               Effect2.andThen(run)
             );
@@ -2420,19 +2475,6 @@ 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* () {
       const scope = model.activeScope;
       if (!active(model) || !scope) return;
@@ -2465,12 +2507,12 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
             const outcome = yield* attemptRecovery(plan, mediaAttempt, syncAttempt).pipe(
               Effect2.match({
                 onSuccess: (attempt) => ({ attempt, failure: null }),
-                onFailure: (failure3) => ({ attempt: null, failure: failure3 })
+                onFailure: (failure2) => ({ attempt: null, failure: failure2 })
               })
             );
             if (outcome.failure) {
-              const failure3 = outcome.failure;
-              enqueueBackground(Effect2.suspend(() => model.epoch === epoch && active(model) ? failForSnapshot(failure3) : Effect2.void));
+              const failure2 = outcome.failure;
+              enqueueBackground(Effect2.suspend(() => model.epoch === epoch && active(model) ? failForSnapshot(failure2) : Effect2.void));
               return;
             }
             if (outcome.attempt !== null) {
@@ -2507,29 +2549,28 @@ 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 failure3 = yield* recoveryOperation(mediaAttempt2, syncAttempt).pipe(
+        const failure2 = yield* recoveryOperation(mediaAttempt2, syncAttempt).pipe(
           Effect2.timeout(remaining),
           Effect2.catchTag("TimeoutError", () => Effect2.fail(lifecycleFailure("sync_start_failed", true, "Connection recovery is still waiting for the transport"))),
           Effect2.match({ onSuccess: () => null, onFailure: (cause) => cause })
         );
-        if (failure3 === null) return attempt;
-        if (!failure3.recoverable) return yield* Effect2.fail(failure3);
+        if (failure2 === null) return attempt;
+        if (!failure2.recoverable) return yield* Effect2.fail(failure2);
         if (attempt < plan.attempts) {
           const remaining2 = Math.max(0, plan.deadline - (yield* Clock2.currentTimeMillis));
-          yield* traceRecovery("lifecycle_backoff", Effect2.sleep(Math.min(recoveryDelay(plan, attempt), remaining2)));
+          yield* Effect2.sleep(Math.min(recoveryDelay(plan, attempt), remaining2));
         }
       }
       return null;
     });
     const recoveryOperation = (mediaAttempt2, syncAttempt) => Effect2.gen(function* () {
       const results = yield* Effect2.all(
-        [recoverSync(syncAttempt), recoverMedia(mediaAttempt2)].map((effect) => effect.pipe(Effect2.matchEffect({ onSuccess: () => Effect2.succeed(null), onFailure: (failure4) => failure4.recoverable ? Effect2.succeed(failure4) : Effect2.fail(failure4) }))),
+        [recoverSync(syncAttempt), recoverMedia(mediaAttempt2)].map((effect) => effect.pipe(Effect2.matchEffect({ onSuccess: () => Effect2.succeed(null), onFailure: (failure3) => failure3.recoverable ? Effect2.succeed(failure3) : Effect2.fail(failure3) }))),
         { concurrency: "unbounded" }
       );
-      const failure3 = results.find((failure4) => failure4 !== null);
-      if (failure3) return yield* Effect2.fail(failure3);
+      const failure2 = results.find((failure3) => failure3 !== null);
+      if (failure2) return yield* Effect2.fail(failure2);
     });
     const recoveryDelay = (plan, attempt) => {
       const delay = plan.delays[Math.min(attempt - 1, plan.delays.length - 1)] ?? 0;
@@ -2591,14 +2632,10 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
         if (typeof document !== "undefined" && document.visibilityState === "hidden") attempt.expiresAt = now + MEDIA_RECOVERY_TIMEOUT_MS;
         if (now < attempt.expiresAt) return yield* waitForMediaLive(media);
       }
-      recordReconnect(options.recordReconnect, "media_decision", { strategy: "full_rebuild" });
-      const grant = yield* traceRecovery("access_refresh", access.refresh("media_recovery", true).pipe(Effect2.mapError(accessFailure)));
+      const grant = yield* access.refresh("media_recovery", true).pipe(Effect2.mapError(accessFailure));
       const restartInput = grant.media.provider === "cloudflare_sfu" ? grant.media.clientPayload : grant.media;
       attempt.expiresAt = (yield* Clock2.currentTimeMillis) + MEDIA_RECOVERY_TIMEOUT_MS;
-      yield* traceRecovery(
-        "media_rebuild",
-        foreign7(() => media.restart(restartInput), "media_start_failed", "Media transport could not restart")
-      );
+      yield* foreign7(() => media.restart(restartInput), "media_start_failed", "Media transport could not restart");
       yield* waitForMediaLive(media);
     });
     const syncAttemptExpired = (attempt, sync, now) => {
@@ -2614,8 +2651,8 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
     const syncNeedsReplacement = (snapshot) => {
       if (snapshot.connection.phase === "idle" || snapshot.connection.phase === "stopped") return Effect2.succeed(true);
       if (snapshot.connection.phase !== "terminal") return Effect2.succeed(false);
-      const failure3 = syncTerminalFailure(snapshot);
-      return failure3.recoverable ? Effect2.succeed(true) : Effect2.fail(failure3);
+      const failure2 = syncTerminalFailure(snapshot);
+      return failure2.recoverable ? Effect2.succeed(true) : Effect2.fail(failure2);
     };
     const recoverSync = (attempt) => Effect2.gen(function* () {
       const sync = model.sync;
@@ -2642,7 +2679,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
           model.syncBindingCleanup?.();
           model.sync = null;
           const sync2 = yield* Effect2.try({
-            try: () => platform.createSyncClient({ access: grant, token: () => toPromise(access.getSyncToken()), media, telemetry: options.telemetry, recordReconnect: options.recordReconnect }),
+            try: () => platform.createSyncClient({ access: grant, token: () => toPromise(access.getSyncToken()), media }),
             catch: (cause) => lifecycleFailure("sync_start_failed", true, "The sync layer could not start", cause)
           });
           model.sync = sync2;
@@ -2683,15 +2720,17 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
     });
     const settleTerminalSnapshot = (snapshot) => Effect2.gen(function* () {
       const ended = episodeEnded(snapshot);
-      if (ended || snapshot.connection.terminalReason === "participant_inactive") {
+      const removed = snapshot.connection.terminalReason === "participant_removed";
+      if (ended || removed || snapshot.connection.terminalReason === "participant_inactive") {
         if (ended) model.episodeEndConfirmed = true;
+        if (removed) model.removedByHost = true;
         yield* finishTerminalSnapshot();
         return true;
       }
       if (snapshot.connection.phase !== "terminal") return false;
-      const failure3 = syncTerminalFailure(snapshot);
-      if (failure3.recoverable) return false;
-      yield* failForSnapshot(failure3);
+      const failure2 = syncTerminalFailure(snapshot);
+      if (failure2.recoverable) return false;
+      yield* failForSnapshot(failure2);
       return true;
     });
     const isCurrentSyncSnapshot = (sync, snapshot) => sync === model.sync && snapshot !== model.syncSnapshot;
@@ -2704,15 +2743,12 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       yield* transition("left");
     });
     const syncNeedsRecovery = (snapshot) => active(model) && (snapshot.connection.phase === "connecting" || snapshot.connection.phase === "recovering" || snapshot.connection.phase === "terminal");
-    const recordFailure = (failure3) => Effect2.sync(() => {
-      const reason = model.sync?.getSnapshot().connection.terminalReason;
-      const terminalReason = reason === "participant_inactive" || reason === "stale_participant_generation" || reason === "episode_ended" ? reason : failure3.code;
-      diagnostics.record({ event: "connection_failed", state: model.state, epoch: model.epoch, code: failure3.code });
-      recordReconnect(options.recordReconnect, "terminal_failure", { code: failure3.code, terminal_reason: terminalReason }, "failed");
+    const recordFailure = (failure2) => Effect2.sync(() => {
+      diagnostics.record({ event: "connection_failed", state: model.state, epoch: model.epoch, code: failure2.code });
     });
-    const failForSnapshot = (failure3) => Effect2.gen(function* failForSnapshotEffect() {
-      model.failure = toFailure(failure3);
-      yield* recordFailure(failure3);
+    const failForSnapshot = (failure2) => Effect2.gen(function* failForSnapshotEffect() {
+      model.failure = toFailure(failure2);
+      yield* recordFailure(failure2);
       yield* stopPorts();
       yield* transition("failed");
     });
@@ -2873,7 +2909,8 @@ function snapshotFor(model, access) {
     episode: episodeFor(access, control),
     connection: Object.freeze({ sync: model.syncSnapshot?.connection.phase === "live" && model.syncNoticeUnresponsive ? "unresponsive" : syncPhase(model.syncSnapshot?.connection.phase), media: mediaPhase(model.mediaSnapshot?.connection.phase) }),
     failure: model.failure ? Object.freeze({ ...model.failure }) : null,
-    episodeEnded: model.episodeEndConfirmed
+    episodeEnded: model.episodeEndConfirmed,
+    removedByHost: model.removedByHost
   });
 }
 function subjectFor(access) {
@@ -2905,9 +2942,9 @@ function accessFailure(value) {
 }
 function captureFailure(cause) {
   if (cause instanceof ConnectionError && cause.cause === void 0) return lifecycleFailure(cause.code, cause.recoverable, cause.message, cause);
-  const failure3 = describeMediaCaptureError(cause instanceof ConnectionError ? cause.cause : cause);
-  if (failure3.code === "unsupported_environment") return lifecycleFailure("media_capture_failed", true, "Media capture failed. Try again or enter with devices off.", cause);
-  return lifecycleFailure(failure3.code, failure3.recoverable, failure3.message, cause);
+  const failure2 = describeMediaCaptureError(cause instanceof ConnectionError ? cause.cause : cause);
+  if (failure2.code === "unsupported_environment") return lifecycleFailure("media_capture_failed", true, "Media capture failed. Try again or enter with devices off.", cause);
+  return lifecycleFailure(failure2.code, failure2.recoverable, failure2.message, cause);
 }
 function acquireInitialMedia(provider, intent) {
   return provider(intent).pipe(
@@ -2953,7 +2990,7 @@ function initialCaptureWarning(failures) {
   const first = failures[0];
   if (!first) return null;
   const names = failures.length === 2 ? "Microphone and camera" : first.source === "microphone" ? "Microphone" : "Camera";
-  const message = failures.length === 2 && first.failure.code !== failures[1]?.failure.code ? failures.map(({ source, failure: failure3 }) => `${source === "microphone" ? "Microphone" : "Camera"}: ${failure3.message}`).join(" ") : `${names}: ${first.failure.message}`;
+  const message = failures.length === 2 && first.failure.code !== failures[1]?.failure.code ? failures.map(({ source, failure: failure2 }) => `${source === "microphone" ? "Microphone" : "Camera"}: ${failure2.message}`).join(" ") : `${names}: ${first.failure.message}`;
   return lifecycleFailure(first.failure.code, true, message, first.failure.cause);
 }
 function failureFromCause(cause, code, message) {
@@ -2991,7 +3028,7 @@ function mediaPhase(phase) {
 function syncTerminalFailure(snapshot) {
   const reason = snapshot.connection.terminalReason;
   if (reason === "episode_ended") return lifecycleFailure("episode_ended", false, "The Episode has ended");
-  if (reason === "participant_inactive" || reason === "stale_participant_generation") return lifecycleFailure("invalid_access", false, "Participant access is no longer valid");
+  if (reason === "participant_inactive" || reason === "participant_removed" || reason === "stale_participant_generation") return lifecycleFailure("invalid_access", false, "Participant access is no longer valid");
   return lifecycleFailure("sync_start_failed", true, "The Sync transport needs recovery");
 }
 
@@ -3068,7 +3105,7 @@ import { Context as Context4, Effect as Effect3, Layer as Layer4, SubscriptionRe
 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 }),
+  connection: empty({ status: "idle", episode: null, lastError: null, episodeEnded: false, removedByHost: false }),
   self: empty({ participantId: null, displayName: null, role: null, capabilities: empty([]), handRaised: false, can: () => false }),
   participants: empty({ roster: empty([]), admissionQueue: empty([]) }),
   media: empty({
@@ -3076,7 +3113,7 @@ var EMPTY = empty({
     selection: empty({ microphone: null, camera: null, speaker: null }),
     local: empty({ microphone: empty({ source: "microphone", state: "unavailable", track: null }), camera: empty({ source: "camera", state: "unavailable", track: null }), screen: empty({ source: "screen", state: "unavailable", track: null }) }),
     remote: empty([]),
-    screenShare: empty({ source: "screen", state: "unavailable", track: null }),
+    screenShare: empty({ source: "screen", state: "unavailable", track: null, hasAudio: false }),
     incomingRequests: empty([])
   }),
   chat: empty({ status: "idle", messages: empty([]), pendingSends: empty([]), readReceipts: empty([]), unreadCount: 0, pagination: empty({ cursor: null, hasOlder: false, historyTruncated: false }), lastError: null }),
@@ -3106,10 +3143,16 @@ var SpaceStore = class _SpaceStore {
   };
   updateConnection(snapshot) {
     const current = this.getSnapshot().connection;
-    const error2 = snapshot.failure ? empty({ code: publicCode(snapshot.failure.code), recoverable: snapshot.failure.recoverable, message: snapshot.failure.message }) : null;
-    const status = snapshot.state === "live" && (INTERRUPTED_CONNECTION_PHASES.has(snapshot.connection.sync) || INTERRUPTED_CONNECTION_PHASES.has(snapshot.connection.media)) ? "reconnecting" : snapshot.state;
-    if (current.status === status && sameEpisode(current.episode, snapshot.episode) && sameError(current.lastError, error2)) return;
-    this.#replace("connection", empty({ status, episode: snapshot.episode, lastError: sameError(current.lastError, error2) ? current.lastError : error2 }));
+    const error2 = connectionError(snapshot.failure);
+    const next = {
+      status: connectionStatus(snapshot),
+      episode: snapshot.episode,
+      lastError: sameError(current.lastError, error2) ? current.lastError : error2,
+      episodeEnded: snapshot.episodeEnded ?? false,
+      removedByHost: snapshot.removedByHost ?? false
+    };
+    if (sameConnection(current, next)) return;
+    this.#replace("connection", empty(next));
   }
   updateSelf(value) {
     this.#replace("self", value);
@@ -3168,6 +3211,16 @@ function mapCode(code) {
     command_rejected: "command.rejected"
   }[code] ?? "client.internal_error";
 }
+function connectionError(failure2) {
+  return failure2 ? empty({ code: publicCode(failure2.code), recoverable: failure2.recoverable, message: failure2.message }) : null;
+}
+function connectionStatus(snapshot) {
+  const interrupted = INTERRUPTED_CONNECTION_PHASES.has(snapshot.connection.sync) || INTERRUPTED_CONNECTION_PHASES.has(snapshot.connection.media);
+  return snapshot.state === "live" && interrupted ? "reconnecting" : snapshot.state;
+}
+function sameConnection(left, right) {
+  return left.status === right.status && sameEpisode(left.episode, right.episode) && left.lastError === right.lastError && left.episodeEnded === right.episodeEnded && left.removedByHost === right.removedByHost;
+}
 function sameEpisode(left, right) {
   if (left === right) return true;
   if (!left || !right) return false;
@@ -3193,1099 +3246,173 @@ function publicCode(code) {
   }
 }
 
-// src/feedback/types.ts
-var FEEDBACK_EVIDENCE_SCHEMA_VERSION = "FeedbackEvidence/v1";
-var FEEDBACK_REQUEST_SCHEMA_VERSION = "FeedbackReportRequest/v1";
-var FEEDBACK_RECEIPT_SCHEMA_VERSION = "FeedbackReportReceipt/v1";
-var FEEDBACK_SCREENSHOT_SCHEMA_VERSION = "FeedbackScreenshot/v1";
-var FEEDBACK_LOCAL_STATE_REGISTRY_VERSION = "FeedbackLocalState/v1";
-var FEEDBACK_COOKIE_REGISTRY_VERSION = "FeedbackCookies/v1";
-var FEEDBACK_MAX_MESSAGE_BYTES = 8e3;
-var FEEDBACK_MAX_EVIDENCE_BYTES = 128 * 1024;
-var FEEDBACK_MAX_REQUEST_BYTES = 1 << 20;
-var FEEDBACK_MAX_SCREENSHOT_BYTES = 450 * 1024;
-var FEEDBACK_MAX_SCREENSHOT_WIDTH = 1920;
-var FEEDBACK_MAX_SCREENSHOT_HEIGHT = 1080;
-var FEEDBACK_MAX_TELEMETRY_EVENTS = 50;
-var FEEDBACK_MAX_DIAGNOSTIC_EVENTS = 50;
-var FEEDBACK_MAX_LOCAL_STATE_ENTRIES = 32;
-var FEEDBACK_MAX_COOKIE_ENTRIES = 16;
+// src/space-client/core.ts
+import { Clock as Clock5, Context as Context13, Duration as Duration2, Effect as Effect12, Layer as Layer13 } from "effect";
+
+// src/space-client/controller-effects.ts
+import { Context as Context12, Effect as Effect11, Layer as Layer12 } from "effect";
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+
+// src/space-client/chat-controller.ts
+import { Schema as Schema3 } from "effect";
+import { Context as Context5, Effect as Effect4, Layer as Layer5 } from "effect";
 
-// src/feedback/validation.ts
-import { isDiagnosticReference, parseDiagnosticEventDraft, redactDiagnosticAttributes } from "@q9labsai/diagnostics-contracts";
+// src/space-client/chat-controller-helpers.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+var MAX_CHAT_PAGE_SIZE = 100;
+var MAX_LOADED_CHAT_MESSAGES = 500;
+var MAX_CHAT_TEXT_BYTES = 16384;
+var MAX_CHAT_TEXT_SCALARS = 4e3;
 var 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);
+var allowedMimeTypes = new Set(CHALK_CHAT_ATTACHMENT_MIME_TYPES);
+var chatMessageFields = ["reactionRevision", "messageId", "clientMessageId", "sequence", "participantId", "displayName", "text", "createdAt"];
+function validateChatMessage(input) {
+  const attachments = input.attachments ?? [];
+  if (input.text.length === 0 && attachments.length === 0) return "A chat message requires text or an attachment";
+  if (Array.from(input.text).length > MAX_CHAT_TEXT_SCALARS || encoder3.encode(input.text).byteLength > MAX_CHAT_TEXT_BYTES) return `Chat text must not exceed ${MAX_CHAT_TEXT_SCALARS} characters or ${MAX_CHAT_TEXT_BYTES} bytes`;
+  if (attachments.length > CHALK_CHAT_ATTACHMENT_LIMITS.maximumPerMessage) return `A chat message supports at most ${CHALK_CHAT_ATTACHMENT_LIMITS.maximumPerMessage} attachments`;
+  if (new Set(attachments.map((attachment2) => attachment2.attachmentId)).size !== attachments.length) return "Chat attachment IDs must be unique";
+  return attachments.map(validateChatAttachment).find((value) => value !== null) ?? null;
 }
-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 validateChatUpload(file, bytes, clientAttachmentId) {
+  const fileName = "fileName" in file ? file.fileName : file.name;
+  const mimeType = "mimeType" in file ? file.mimeType : file.type;
+  const error2 = validateChatAttachment({ attachmentId: clientAttachmentId, fileName, mimeType, byteLength: bytes.byteLength });
+  return error2 ?? { fileName, mimeType };
 }
-function 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 chatDigest(bytes) {
+  return Array.from(sha256(new Uint8Array(bytes)), (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
-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 chatMessageFor(message) {
+  return Object.freeze({
+    ...message,
+    reactionRevision: message.reactionRevision ?? "0",
+    reactions: Object.freeze((message.reactions ?? []).map((reaction) => Object.freeze({ ...reaction, participantIds: Object.freeze([...reaction.participantIds]) }))),
+    attachments: Object.freeze([...message.attachments])
+  });
 }
-function buildFeedbackScope(space, episode, participant) {
-  if (!space && !episode && !participant) return {};
-  return {
-    ...space ? { space_id: space } : {},
-    ...episode ? { episode_id: episode } : {},
-    ...participant ? { participant_id: participant } : {}
-  };
+function chatReceiptFor(receipt) {
+  return Object.freeze({ ...receipt });
 }
-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 mergeChatMessage(messages, existing, incoming) {
+  if (compareChatSequence(existing.reactionRevision ?? "0", incoming.reactionRevision ?? "0") > 0) incoming = { ...incoming, reactions: existing.reactions, reactionRevision: existing.reactionRevision };
+  if (sameChatMessage(existing, incoming)) return messages;
+  return Object.freeze(
+    messages.map((message) => message === existing ? incoming : message).sort((left, right) => compareChatSequence(left.sequence, right.sequence)).slice(-MAX_LOADED_CHAT_MESSAGES)
+  );
 }
-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 compareChatSequence(left, right) {
+  if (left === right) return 0;
+  if (!/^\d+$/u.test(left) || !/^\d+$/u.test(right)) return left < right ? -1 : 1;
+  const normalizedLeft = left.replace(/^0+/u, "") || "0";
+  const normalizedRight = right.replace(/^0+/u, "") || "0";
+  return normalizedLeft.length === normalizedRight.length ? normalizedLeft < normalizedRight ? -1 : 1 : normalizedLeft.length - normalizedRight.length;
 }
-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 validateChatAttachment(attachment2) {
+  const fileNameBytes = encoder3.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 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" });
-    }
+function sameChatMessage(left, right) {
+  return chatMessageFields.every((field) => left[field] === right[field]) && left.attachments.length === right.attachments.length && left.attachments.every((attachment2, index) => {
+    const candidate = right.attachments[index];
+    return candidate?.attachmentId === attachment2.attachmentId && candidate.fileName === attachment2.fileName && candidate.mimeType === attachment2.mimeType && candidate.byteLength === attachment2.byteLength;
   });
-  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)
+
+// src/space-client/chat-controller.ts
+var ChatControllerService = class extends Context5.Service()("@chalk/client/ChatController") {
+};
+var makeChatController = (input) => Effect4.gen(function* () {
+  const scope = yield* Effect4.scope;
+  const context = yield* Effect4.context();
+  const fork = (effect) => {
+    void Effect4.runForkWith(context)(Effect4.forkIn(effect, scope).pipe(Effect4.asVoid));
   };
-}
-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 });
+  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.offline);
+    return instance;
   });
-  return { registry_version: FEEDBACK_LOCAL_STATE_REGISTRY_VERSION, entries };
-}
-function validateCookies(input, issues) {
-  if (typeof input !== "object" || input === null || Array.isArray(input)) {
-    issues.push({ path: "$.cookies", message: "cookies must be an object" });
-    return void 0;
-  }
-  checkKeys(input, ["registry_version", "entries"], issues, "$.cookies", false);
-  if (property(input, "registry_version") !== FEEDBACK_COOKIE_REGISTRY_VERSION) issues.push({ path: "$.cookies.registry_version", message: "unsupported cookie registry" });
-  const entriesInput = property(input, "entries");
-  if (!Array.isArray(entriesInput)) {
-    issues.push({ path: "$.cookies.entries", message: "cookie entries must be an array" });
-    return void 0;
-  }
-  if (entriesInput.length > FEEDBACK_MAX_COOKIE_ENTRIES) issues.push({ path: "$.cookies.entries", message: "too many cookie entries" });
-  const entries = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const [index, entry] of entriesInput.slice(0, FEEDBACK_MAX_COOKIE_ENTRIES).entries()) {
-    const parsed = validateCookieEntry(entry, index, seen, issues);
-    if (parsed) entries.push(parsed);
-  }
-  return { registry_version: FEEDBACK_COOKIE_REGISTRY_VERSION, entries };
-}
-function validateCookieEntry(input, index, seen, issues) {
-  const path = `$.cookies.entries[${index}]`;
-  if (typeof input !== "object" || input === null || Array.isArray(input)) {
-    issues.push({ path, message: "cookie entry must be an object" });
-    return void 0;
-  }
-  checkKeys(input, ["name", "present", "value"], issues, path, false);
-  const name = enumValue(property(input, "name"), ["chalk_theme", "chalk_sidebar_state", "account", "csrf"], `${path}.name`, issues);
-  const present = property(input, "present");
-  if (!name || typeof present !== "boolean" || seen.has(name)) {
-    issues.push({ path, message: "cookie entry is invalid or duplicated" });
-    return void 0;
-  }
-  seen.add(name);
-  return buildCookieEntry(name, present, property(input, "value"), path, issues);
-}
-function buildCookieEntry(name, present, input, path, issues) {
-  const value = cookieValue(name, input, `${path}.value`, issues);
-  if (!present && value !== void 0) issues.push({ path: `${path}.value`, message: "absent cookies cannot include values" });
-  return { name, present, ...value !== void 0 ? { value } : {} };
-}
-function cookieValue(name, input, path, issues) {
-  if (input === void 0) return void 0;
-  if (typeof input !== "string") {
-    issues.push({ path, message: "cookie value is invalid" });
-    return void 0;
-  }
-  if (name === "account" || name === "csrf") {
-    issues.push({ path, message: "account and CSRF cookie values are never collected" });
-    return void 0;
-  }
-  if (name === "chalk_theme") {
-    const value2 = ["light", "dark", "system"];
-    const match2 = value2.find((candidate) => candidate === input);
-    if (match2 !== void 0) return match2;
-    issues.push({ path, message: "theme cookie value is invalid" });
-    return void 0;
-  }
-  const value = ["true", "false"];
-  const match = value.find((candidate) => candidate === input);
-  if (match !== void 0) return match;
-  issues.push({ path, message: "sidebar cookie value is invalid" });
-  return void 0;
-}
-function validateScreenshotState(input, issues) {
-  if (typeof input !== "object" || input === null || Array.isArray(input)) {
-    issues.push({ path: "$.screenshot", message: "screenshot state must be an object" });
-    return void 0;
-  }
-  checkKeys(input, ["state", "captured_at", "failure_code"], issues, "$.screenshot", false);
-  const state = enumValue(property(input, "state"), ["captured", "partial", "removed", "unavailable"], "$.screenshot.state", issues);
-  const failureInput = property(input, "failure_code");
-  const failure3 = failureInput === void 0 ? void 0 : enumValue(failureInput, ["capture_failed", "unsupported", "tainted", "secure_surface", "too_large"], "$.screenshot.failure_code", issues);
-  const capturedAtInput = property(input, "captured_at");
-  const capturedAt = capturedAtInput === void 0 ? void 0 : checkDateTimeValue(capturedAtInput, "$.screenshot.captured_at", issues);
-  validateScreenshotStateConsistency(state, capturedAt, failure3, issues);
-  if (!state) return void 0;
-  return { state, ...capturedAt ? { captured_at: capturedAt } : {}, ...failure3 ? { failure_code: failure3 } : {} };
-}
-function validateScreenshotStateConsistency(state, capturedAt, failure3, issues) {
-  const captured = state === "captured" || state === "partial";
-  if (captured && !capturedAt) issues.push({ path: "$.screenshot.captured_at", message: "captured screenshots require a timestamp" });
-  if (captured && failure3) issues.push({ path: "$.screenshot.failure_code", message: "captured screenshots cannot have a failure code" });
-}
-function validLocalStateEntry(key, value) {
-  if (key === "chalk.tenant-hint") return isUUID(value);
-  if (key === "chalk.web.telemetry.v1" || key === "chalk.mobile.telemetry.v1") return validTelemetrySummary(value);
-  if (key.startsWith("chalk.dashboard-request.")) return DASHBOARD_ACTION_PATTERN.test(key.slice("chalk.dashboard-request.".length)) && value === true;
-  return false;
-}
-function isFeedbackLocalStateValue(value) {
-  if (typeof value === "string" || typeof value === "boolean") return true;
-  if (typeof value === "number") return Number.isFinite(value);
-  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).every((key) => {
-    const entry = property(value, key);
-    return typeof entry === "number" && Number.isFinite(entry);
-  });
-}
-function validTelemetrySummary(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-  const keys = ["pending_count", "timeline_count", "dropped_count"];
-  if (!keys.some((key) => property(value, key) !== void 0)) return false;
-  return keys.every((key) => {
-    const entry = property(value, key);
-    return entry === void 0 || typeof entry === "number" && Number.isSafeInteger(entry) && entry >= 0 && entry <= 500;
-  });
-}
-function metadata(value, path, issues, required) {
-  if (value === void 0 && !required) return void 0;
-  if (typeof value !== "string" || !isSafeMetadata(value)) {
-    issues.push({ path, message: required ? "metadata is required and unsafe" : "metadata is unsafe" });
-    return void 0;
-  }
-  return value;
-}
-function isSafeMetadata(value) {
-  return value.length > 0 && value.length <= 128 && value.trim() === value && !isControlText(value) && !UNSAFE_VALUE_PATTERN.test(value);
-}
-function safeToken(value, path, issues, required) {
-  if (value === void 0 && !required) return void 0;
-  if (typeof value !== "string" || value.length === 0 || value.length > 128 || !SAFE_TOKEN_PATTERN.test(value) || UNSAFE_VALUE_PATTERN.test(value)) {
-    issues.push({ path, message: required ? "token is required and unsafe" : "token is unsafe" });
-    return void 0;
-  }
-  return value;
-}
-function optionalUUID(value, path, issues) {
-  if (value === void 0) return void 0;
-  return requiredUUID(value, path, issues);
-}
-function requiredUUID(value, path, issues) {
-  if (typeof value !== "string" || !isUUID(value)) {
-    issues.push({ path, message: "expected a non-zero UUID" });
-    return void 0;
-  }
-  return value;
-}
-function optionalHex(value, pattern, path, issues) {
-  if (value === void 0) return void 0;
-  if (typeof value !== "string" || !pattern.test(value.toLowerCase()) || value !== value.toLowerCase()) {
-    issues.push({ path, message: "expected a lower-case non-zero hexadecimal ID" });
-    return void 0;
-  }
-  return value;
-}
-function optionalTraceparent(value, path, issues) {
-  if (value === void 0) return void 0;
-  if (typeof value !== "string" || !TRACEPARENT_PATTERN.test(value)) {
-    issues.push({ path, message: "traceparent is malformed" });
-    return void 0;
-  }
-  return value;
-}
-function optionalSafeText(value, path, length, issues) {
-  if (value === void 0) return void 0;
-  if (typeof value !== "string" || value.length > length || isControlText(value) || UNSAFE_VALUE_PATTERN.test(value)) {
-    issues.push({ path, message: "text is unsafe" });
-    return void 0;
-  }
-  return value;
-}
-function checkDateTime(value, path, issues) {
-  checkDateTimeValue(value, path, issues);
-}
-function checkDateTimeValue(value, path, issues) {
-  if (typeof value !== "string" || value.length > 64 || !Number.isFinite(Date.parse(value))) {
-    issues.push({ path, message: "expected an ISO date-time" });
-    return void 0;
-  }
-  return value;
-}
-function boundedInteger2(value, minimum, maximum, path, issues) {
-  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < minimum || value > maximum) {
-    issues.push({ path, message: "expected a bounded integer" });
-    return void 0;
-  }
-  return value;
-}
-function enumValue(value, values, path, issues) {
-  const match = values.find((candidate) => candidate === value);
-  if (match !== void 0) return match;
-  issues.push({ path, message: `expected one of: ${values.join(", ")}` });
-  return void 0;
-}
-function checkKeys(value, allowed, issues, path, allowNullable) {
-  const allowedSet = new Set(allowed);
-  for (const key of Object.keys(value)) if (!allowedSet.has(key) && !(allowNullable && key === "value")) issues.push({ path: `${path}.${key}`, message: "unknown property" });
-}
-function failure2(path, message) {
-  return { ok: false, issues: [{ path, message }] };
-}
-function property(value, key) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
-  return Object.prototype.hasOwnProperty.call(value, key) ? Reflect.get(value, key) : void 0;
-}
-function isUUID(value) {
-  return typeof value === "string" && UUID_PATTERN.test(value) && value.replaceAll("0", "").replaceAll("-", "") !== "";
-}
-function validBase64(value) {
-  return value.length > 0 && value.length % 4 === 0 && /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(value);
-}
-function base64ByteLength(value) {
-  const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
-  return Math.floor(value.length * 3 / 4) - padding;
-}
-function encodedByteLength(value) {
-  return encoder3.encode(JSON.stringify(value)).byteLength;
-}
-function isControl(character) {
-  return /\p{Cc}/u.test(character);
-}
-function isControlText(value) {
-  for (const character of value) if (isControl(character)) return true;
-  return false;
-}
-
-// src/feedback/collector.ts
-import { validateDiagnosticEventDraft } from "@q9labsai/diagnostics-contracts";
-
-// src/feedback/context.ts
-function safeSubject(snapshot) {
-  const subject = snapshot.subject;
-  if (!subject) return void 0;
-  return {
-    tenant_id: subject.tenantId,
-    space_id: subject.spaceId,
-    episode_id: subject.episodeId,
-    participant_id: subject.participantId,
-    participant_generation: subject.participantGeneration
-  };
-}
-
-// src/feedback/collector.ts
-function collectFeedbackEvidence(input, context = {}) {
-  const collectedAt = new Date((context.now ?? Date.now)()).toISOString();
-  const evidence = {
-    schema_version: FEEDBACK_EVIDENCE_SCHEMA_VERSION,
-    collected_at: collectedAt,
-    ...input.app ? { app: input.app } : {},
-    sdk: input.sdk,
-    platform: input.platform,
-    ...context.connection ? { connection: context.connection } : {},
-    ...context.scope ? { scope: context.scope } : {},
-    correlations: context.correlations ?? {},
-    diagnostics: context.diagnostics ?? unavailableDiagnostics(),
-    local_state: { registry_version: FEEDBACK_LOCAL_STATE_REGISTRY_VERSION, entries: collectLocalState(input.local_state) },
-    cookies: { registry_version: FEEDBACK_COOKIE_REGISTRY_VERSION, entries: collectCookies(input.cookies) },
-    screenshot: screenshotState(input.screenshot)
-  };
-  return parseFeedbackEvidence(evidence);
-}
-function collectFeedbackEvidenceFromContext(input, context) {
-  const snapshot = context.connection();
-  const subject = safeSubject(snapshot);
-  const activeTelemetry = context.telemetry;
-  const activeDiagnostics = context.diagnosticContext();
-  const correlationContext = activeTelemetry ?? activeDiagnostics;
-  const trace = parseTraceparent(correlationContext?.traceparent);
-  const diagnostics = context.diagnosticSnapshot();
-  const availability = context.diagnosticAvailability();
-  return collectFeedbackEvidence(input, {
-    now: context.now,
-    connection: {
-      state: snapshot.state,
-      ...snapshot.failure?.code ? { error_code: snapshot.failure.code } : {}
-    },
-    ...subject ? {
-      scope: {
-        space_id: subject.space_id,
-        episode_id: subject.episode_id,
-        participant_id: subject.participant_id
-      }
-    } : {},
-    correlations: {
-      ...correlationContext ? { journey_id: correlationContext.journeyId } : {},
-      ...activeTelemetry ? { root_journey_id: activeTelemetry.rootJourneyId } : {},
-      ...trace ? { trace_id: trace.traceId, span_id: trace.spanId } : {}
-    },
-    diagnostics: {
-      availability,
-      dropped_count: diagnostics.dropped,
-      telemetry_events: input.local_state?.telemetry?.events ?? [],
-      diagnostic_events: diagnostics.events.filter(isDiagnosticEvent)
-    }
-  });
-}
-function collectLocalState(input) {
-  if (!input) return [];
-  const entries = [];
-  if (input.telemetry) {
-    const summary = telemetrySummary(input.telemetry);
-    if (summary) entries.push({ key: input.telemetry.storage_key ?? "chalk.web.telemetry.v1", value: summary });
-  }
-  if (input.tenant_hint && validUUID(input.tenant_hint)) entries.push({ key: "chalk.tenant-hint", value: input.tenant_hint });
-  for (const request of input.dashboard_requests ?? []) {
-    if (!request.pending || !/^[a-z][a-z0-9_-]{0,63}$/u.test(request.action)) continue;
-    entries.push({ key: `chalk.dashboard-request.${request.action}`, value: true });
-  }
-  return entries.slice(0, 32);
-}
-function collectCookies(input) {
-  if (!input) return [];
-  const entries = [];
-  if (input.theme !== void 0) entries.push({ name: "chalk_theme", present: true, value: input.theme });
-  if (input.sidebar_state !== void 0) entries.push({ name: "chalk_sidebar_state", present: true, value: input.sidebar_state ? "true" : "false" });
-  if (input.account_present !== void 0) entries.push({ name: "account", present: input.account_present });
-  if (input.csrf_present !== void 0) entries.push({ name: "csrf", present: input.csrf_present });
-  return entries;
-}
-function telemetrySummary(input) {
-  const summary = {
-    ...input.pending_count !== void 0 && boundedCount(input.pending_count) ? { pending_count: input.pending_count } : {},
-    ...input.timeline_count !== void 0 && boundedCount(input.timeline_count) ? { timeline_count: input.timeline_count } : {},
-    ...input.dropped_count !== void 0 && boundedCount(input.dropped_count) ? { dropped_count: input.dropped_count } : {}
-  };
-  return Object.keys(summary).length > 0 ? summary : void 0;
-}
-function boundedCount(value) {
-  return Number.isSafeInteger(value) && value >= 0 && value <= 500;
-}
-function screenshotState(input) {
-  if (!input) return { state: "unavailable", failure_code: "unsupported" };
-  if (input.state === "captured" || input.state === "partial") return { state: input.state, captured_at: input.captured_at };
-  return "failure_code" in input && input.failure_code ? { state: input.state, failure_code: input.failure_code } : { state: input.state };
-}
-function unavailableDiagnostics() {
-  return { availability: "unavailable", dropped_count: 0, telemetry_events: [], diagnostic_events: [] };
-}
-function isDiagnosticEvent(value) {
-  return validateDiagnosticEventDraft(value).ok;
-}
-function validUUID(value) {
-  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu.test(value) && value.replaceAll("0", "").replaceAll("-", "") !== "";
-}
-
-// src/feedback/transport.ts
-var FeedbackTransportError = class extends Error {
-  code;
-  status;
-  recoverable;
-  constructor(input) {
-    super(input.message);
-    this.name = "FeedbackTransportError";
-    this.code = input.code;
-    this.recoverable = input.recoverable;
-    this.status = input.status;
-  }
-};
-function createFeedbackTransport(options) {
-  const fetchImplementation = options.fetch ?? globalThis.fetch;
-  const baseUrl = options.baseUrl.replace(/\/+$/u, "");
-  return {
-    send: async ({ request, idempotencyKey }) => {
-      const parsedRequest = parseFeedbackReportRequest(request);
-      validateTransportBounds(parsedRequest);
-      validateIdempotencyKey(idempotencyKey);
-      const credential = options.credential();
-      if (!credential) throw new FeedbackTransportError({ code: "unauthenticated", recoverable: false, message: "Feedback authentication is unavailable.", status: 401 });
-      const headers = feedbackHeaders(idempotencyKey, credential.token, options.telemetry?.());
-      const response = await sendFeedbackRequest(fetchImplementation, `${baseUrl}/v1/feedback-reports`, headers, parsedRequest);
-      return parseFeedbackResponse(response);
-    }
-  };
-}
-function validateIdempotencyKey(idempotencyKey) {
-  if (idempotencyKey.length < 16 || idempotencyKey.length > 128 || !/^[A-Za-z0-9_-]+$/u.test(idempotencyKey)) throw new FeedbackTransportError({ code: "invalid_request", recoverable: false, message: "Feedback idempotency key is invalid.", status: 400 });
-}
-function feedbackHeaders(idempotencyKey, credentialToken, telemetry) {
-  const headers = new Headers({ "content-type": "application/json", authorization: `Bearer ${credentialToken}`, "idempotency-key": idempotencyKey });
-  if (!telemetry) return headers;
-  for (const [key, value] of Object.entries(journeyHeaders(telemetry))) headers.set(key, value);
-  return headers;
-}
-async function sendFeedbackRequest(fetchImplementation, url, headers, request) {
-  try {
-    return await fetchImplementation(url, { method: "POST", headers, body: JSON.stringify(request) });
-  } catch {
-    throw new FeedbackTransportError({ code: "unavailable", recoverable: true, message: "Feedback service is unavailable." });
-  }
-}
-async function parseFeedbackResponse(response) {
-  if (!response.ok) throw responseError3(response.status);
-  let body;
-  try {
-    body = await response.json();
-  } catch {
-    throw new FeedbackTransportError({ code: "invalid_response", recoverable: true, message: "Feedback service returned an invalid receipt.", status: response.status });
-  }
-  try {
-    return assertFeedbackReceipt(body);
-  } catch {
-    throw new FeedbackTransportError({ code: "invalid_response", recoverable: true, message: "Feedback service returned an invalid receipt.", status: response.status });
-  }
-}
-function validateTransportBounds(request) {
-  const evidenceBytes = new TextEncoder().encode(JSON.stringify(request.evidence)).byteLength;
-  const requestBytes = new TextEncoder().encode(JSON.stringify(request)).byteLength;
-  if (evidenceBytes > FEEDBACK_MAX_EVIDENCE_BYTES) throw new FeedbackTransportError({ code: "invalid_request", recoverable: false, message: "Feedback evidence exceeds the size limit." });
-  if (requestBytes > FEEDBACK_MAX_REQUEST_BYTES) throw new FeedbackTransportError({ code: "invalid_request", recoverable: false, message: "Feedback request exceeds the size limit." });
-}
-function responseError3(status) {
-  if (status === 400) return new FeedbackTransportError({ code: "invalid_request", recoverable: false, message: "Feedback request was rejected.", status });
-  if (status === 413) return new FeedbackTransportError({ code: "invalid_request", recoverable: false, message: "Feedback request exceeds the size limit.", status });
-  if (status === 401) return new FeedbackTransportError({ code: "unauthenticated", recoverable: false, message: "Feedback authentication was rejected.", status });
-  if (status === 403) return new FeedbackTransportError({ code: "forbidden", recoverable: false, message: "Feedback submission is not allowed.", status });
-  if (status === 409) return new FeedbackTransportError({ code: "conflict", recoverable: false, message: "Feedback idempotency key conflicts with another submission.", status });
-  if (status === 429) return new FeedbackTransportError({ code: "rate_limited", recoverable: true, message: "Feedback submissions are temporarily limited.", status });
-  return new FeedbackTransportError({ code: "unavailable", recoverable: true, message: "Feedback service is unavailable.", status });
-}
-
-// src/space-client/core.ts
-import { Clock as Clock5, Context as Context13, Duration as Duration2, Effect as Effect12, Layer as Layer13 } from "effect";
-
-// src/space-client/controller-effects.ts
-import { Context as Context12, Effect as Effect11, Layer as Layer12 } from "effect";
-import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
-
-// src/space-client/chat-controller.ts
-import { Context as Context5, Effect as Effect4, Layer as Layer5 } from "effect";
-
-// src/space-client/chat-controller-helpers.ts
-import { sha256 } from "@noble/hashes/sha2.js";
-var MAX_CHAT_PAGE_SIZE = 100;
-var MAX_LOADED_CHAT_MESSAGES = 500;
-var MAX_CHAT_TEXT_BYTES = 16384;
-var MAX_CHAT_TEXT_SCALARS = 4e3;
-var encoder4 = new TextEncoder();
-var allowedMimeTypes = new Set(CHALK_CHAT_ATTACHMENT_MIME_TYPES);
-function validateChatMessage(input) {
-  const attachments = input.attachments ?? [];
-  if (input.text.length === 0 && attachments.length === 0) return "A chat message requires text or an attachment";
-  if (Array.from(input.text).length > MAX_CHAT_TEXT_SCALARS || encoder4.encode(input.text).byteLength > MAX_CHAT_TEXT_BYTES) return `Chat text must not exceed ${MAX_CHAT_TEXT_SCALARS} characters or ${MAX_CHAT_TEXT_BYTES} bytes`;
-  if (attachments.length > CHALK_CHAT_ATTACHMENT_LIMITS.maximumPerMessage) return `A chat message supports at most ${CHALK_CHAT_ATTACHMENT_LIMITS.maximumPerMessage} attachments`;
-  if (new Set(attachments.map((attachment2) => attachment2.attachmentId)).size !== attachments.length) return "Chat attachment IDs must be unique";
-  return attachments.map(validateChatAttachment).find((value) => value !== null) ?? null;
-}
-function validateChatUpload(file, bytes, clientAttachmentId) {
-  const fileName = "fileName" in file ? file.fileName : file.name;
-  const mimeType = "mimeType" in file ? file.mimeType : file.type;
-  const error2 = validateChatAttachment({ attachmentId: clientAttachmentId, fileName, mimeType, byteLength: bytes.byteLength });
-  return error2 ?? { fileName, mimeType };
-}
-function chatDigest(bytes) {
-  return Array.from(sha256(new Uint8Array(bytes)), (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-function chatMessageFor(message) {
-  return Object.freeze({ ...message, attachments: Object.freeze([...message.attachments]) });
-}
-function chatReceiptFor(receipt) {
-  return Object.freeze({ ...receipt });
-}
-function mergeChatMessage(messages, existing, incoming) {
-  if (sameChatMessage(existing, incoming)) return messages;
-  return Object.freeze(
-    messages.map((message) => message === existing ? incoming : message).sort((left, right) => compareChatSequence(left.sequence, right.sequence)).slice(-MAX_LOADED_CHAT_MESSAGES)
-  );
-}
-function compareChatSequence(left, right) {
-  if (left === right) return 0;
-  if (!/^\d+$/u.test(left) || !/^\d+$/u.test(right)) return left < right ? -1 : 1;
-  const normalizedLeft = left.replace(/^0+/u, "") || "0";
-  const normalizedRight = right.replace(/^0+/u, "") || "0";
-  return normalizedLeft.length === normalizedRight.length ? normalizedLeft < normalizedRight ? -1 : 1 : normalizedLeft.length - normalizedRight.length;
-}
-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((attachment2, index) => {
-    const candidate = right.attachments[index];
-    return candidate?.attachmentId === attachment2.attachmentId && candidate.fileName === attachment2.fileName && candidate.mimeType === attachment2.mimeType && candidate.byteLength === attachment2.byteLength;
-  });
-}
-
-// src/space-client/chat-controller.ts
-var ChatControllerService = class extends Context5.Service()("@chalk/client/ChatController") {
-};
-var makeChatController = (input) => Effect4.gen(function* () {
-  const scope = yield* Effect4.scope;
-  const context = yield* Effect4.context();
-  const fork = (effect) => {
-    void Effect4.runForkWith(context)(Effect4.forkIn(effect, scope).pipe(Effect4.asVoid));
-  };
-  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, input.offline);
-    return instance;
-  });
-  yield* Effect4.addFinalizer(() => Effect4.sync(() => controller.dispose()));
-  return controller;
-});
-var ChatControllerRuntime = class {
-  #apiBaseUrl;
-  #connection;
-  #store;
-  #transport;
-  #fetch;
-  #fork;
-  #diagnostics;
-  #offline;
-  #catchUpRunning = false;
-  #catchUpRequested = false;
-  #contiguousSequence = null;
-  #hasOlder = false;
-  #historyTruncated = false;
-  #initialCatchUpComplete = true;
-  #lastError = null;
-  #localReadThroughSequence = null;
-  #messages = Object.freeze([]);
-  #pendingSends = Object.freeze([]);
-  #ports = null;
-  #readReceipts = Object.freeze([]);
-  #retainedFloorSequence = null;
-  #status = "idle";
-  #unreadCount = 0;
-  #unsubscribeConnection = null;
-  #unsubscribeEvents = null;
-  #unsubscribeSnapshot = null;
-  constructor(connection, store, transport, apiBaseUrl, fetch, fork, diagnostics, offline) {
-    this.#offline = offline;
-    this.#apiBaseUrl = apiBaseUrl.replace(/\/+$/u, "");
-    this.#connection = connection;
-    this.#store = store;
-    this.#transport = transport;
-    this.#fetch = fetch;
-    this.#fork = fork;
-    this.#diagnostics = diagnostics;
-    this.#unsubscribeConnection = connection.subscribePorts((ports) => this.#bind(ports));
+  yield* Effect4.addFinalizer(() => Effect4.sync(() => controller.dispose()));
+  return controller;
+});
+var ChatControllerRuntime = class {
+  #apiBaseUrl;
+  #connection;
+  #store;
+  #transport;
+  #fetch;
+  #fork;
+  #offline;
+  #reactionStates = /* @__PURE__ */ new Map();
+  #catchUpRunning = false;
+  #catchUpRequested = false;
+  #contiguousSequence = null;
+  #hasOlder = false;
+  #historyTruncated = false;
+  #initialCatchUpComplete = true;
+  #lastError = null;
+  #localReadThroughSequence = null;
+  #messages = Object.freeze([]);
+  #pendingSends = Object.freeze([]);
+  #ports = null;
+  #readReceipts = Object.freeze([]);
+  #retainedFloorSequence = null;
+  #status = "idle";
+  #unreadCount = 0;
+  #unsubscribeConnection = null;
+  #unsubscribeEvents = null;
+  #unsubscribeSnapshot = null;
+  constructor(connection, store, transport, apiBaseUrl, fetch, fork, offline) {
+    this.#offline = offline;
+    this.#apiBaseUrl = apiBaseUrl.replace(/\/+$/u, "");
+    this.#connection = connection;
+    this.#store = store;
+    this.#transport = transport;
+    this.#fetch = fetch;
+    this.#fork = fork;
+    this.#unsubscribeConnection = connection.subscribePorts((ports) => this.#bind(ports));
   }
   send = (input) => {
-    const operation = this.#diagnostics?.startOperation("chat.send");
     return Effect4.try({ try: () => validate(input), catch: normalizeClientError }).pipe(
-      Effect4.tap(() => Effect4.sync(() => operation?.observe("observed", "validation"))),
       Effect4.map((attachments) => ({ clientMessageId: this.#connection.createId(), attachments })),
       Effect4.flatMap(({ clientMessageId, attachments }) => {
         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 (held ?? sendNow()).pipe(Effect4.tap(() => Effect4.sync(() => operation?.observe("observed", "durable_commit")))).pipe(
+        return (held ?? sendNow()).pipe(Effect4.tap(() => Effect4.void)).pipe(
           Effect4.map(chatMessageFor),
           Effect4.tap(() => Effect4.sync(() => this.#removePending(clientMessageId))),
           Effect4.map((message) => this.#observeMessage(message, false)),
-          Effect4.tap(
-            () => Effect4.sync(() => {
-              operation?.observe("observed", "paging_visibility");
-              operation?.notObservable("recipient_projection", "recipient_projection_is_conditional");
-              operation?.succeed();
-            })
-          ),
           Effect4.catch((cause) => {
             const error2 = normalizeClientError(cause, "chat.payload_invalid");
             return Effect4.sync(() => {
               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)));
           })
         );
       }),
-      Effect4.mapError(normalizeClientError),
-      Effect4.tapError(() => Effect4.sync(() => operation?.fail("send_failed")))
+      Effect4.mapError(normalizeClientError)
     );
   };
+  react = (input) => Effect4.try({
+    try: () => Schema3.decodeUnknownSync(ChatReactionSetFrameSchema)({ type: "chat_reaction_set", request_id: this.#connection.createId(), message_id: input.messageId, emoji: input.emoji, on: input.on }),
+    catch: () => chatError("The message reaction is invalid")
+  }).pipe(
+    Effect4.flatMap(() => {
+      const sendNow = () => this.#connection.runCommand(({ sync }) => foreign(() => sync.reactToChatMessage(input)));
+      return (this.#offline?.hold({ kind: "chat_reaction", reaction: input }, sendNow) ?? sendNow()).pipe(
+        Effect4.tap((state) => Effect4.sync(() => this.#mergeReactions(state))),
+        Effect4.mapError(normalizeClientError)
+      );
+    })
+  );
   loadOlder = () => {
-    const operation = this.#diagnostics?.startOperation("chat.page");
     this.#status = "loading";
     this.#lastError = null;
     this.#publish();
@@ -4293,8 +3420,6 @@ var ChatControllerRuntime = class {
       Effect4.tap(
         (result) => Effect4.sync(() => {
           this.#applyPage(result);
-          operation?.observe("observed", "page_visibility");
-          operation?.succeed();
         })
       ),
       Effect4.mapError((cause) => {
@@ -4303,74 +3428,49 @@ var ChatControllerRuntime = class {
         this.#lastError = failureFromError(error2);
         this.#publish();
         return error2;
-      }),
-      Effect4.tapError(() => Effect4.sync(() => operation?.fail("page_failed")))
+      })
     );
   };
   markRead = (messageId) => {
-    const operation = this.#diagnostics?.startOperation("chat.read");
     return Effect4.suspend(() => {
       const message = this.#messages.find((candidate) => candidate.messageId === messageId);
       if (!message) {
-        operation?.notObservable("read_commit", "message_not_found");
-        operation?.succeed();
         return Effect4.succeed(null);
       }
       this.#applyLocalReadThrough(message.sequence);
       const ports = this.#ports;
-      if (!ports || ports.sync.getCollaborationExtensionState().version !== 1) {
-        operation?.notObservable("read_commit", "collaboration_extension_unavailable");
-        operation?.succeed();
+      if (!ports || ports.sync.getCollaborationExtensionState().version === null) {
         return Effect4.succeed(null);
       }
-      operation?.observe("observed", "read_commit");
       return this.#connection.runCommand(({ sync }) => foreign(() => sync.markChatRead(message.sequence))).pipe(
         Effect4.map(chatReceiptFor),
         Effect4.tap((receipt) => Effect4.sync(() => this.#mergeReceipt(receipt))),
-        Effect4.tap(() => Effect4.sync(() => operation?.succeed())),
-        Effect4.mapError(normalizeClientError),
-        Effect4.tapError(() => Effect4.sync(() => operation?.fail("read_failed")))
+        Effect4.mapError(normalizeClientError)
       );
     });
   };
   upload = (file) => {
     const fetch = this.#fetch;
-    const prepareOperation = this.#diagnostics?.startOperation("chat.attachment.prepare");
     return Effect4.suspend(() => {
       if (!this.#transport) {
-        prepareOperation?.fail("transport_unavailable");
         return Effect4.fail(new SpaceClientError({ code: "collaboration.unavailable", recoverable: false, message: "Chat file upload is unavailable" }));
       }
       return bytesFor(file).pipe(
         Effect4.flatMap((bytes) => {
           const clientAttachmentId = this.#connection.createId();
           return Effect4.try({ try: () => validateUpload(file, bytes, clientAttachmentId), catch: normalizeClientError }).pipe(
-            Effect4.tap(() => Effect4.sync(() => prepareOperation?.observe("observed", "validation"))),
             Effect4.flatMap(
               (uploadFile) => this.#connection.runPortCommand(
                 () => foreign(() => this.#transport.initiateUpload({ clientAttachmentId, fileName: uploadFile.fileName, mimeType: uploadFile.mimeType, byteLength: bytes.byteLength, sha256: chatDigest(bytes) })).pipe(
                   Effect4.flatMap(
-                    (upload) => Effect4.sync(() => {
-                      prepareOperation?.observe("observed", "storage_prepare");
-                      prepareOperation?.succeed();
-                    }).pipe(
+                    (upload) => Effect4.void.pipe(
                       Effect4.andThen(
                         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) {
-                              commitOperation?.fail("storage_rejected");
                               return Effect4.fail(new SpaceClientError({ code: "command.rejected", recoverable: response.status >= 500, message: `Attachment upload failed with HTTP ${response.status}` }));
                             }
-                            return foreign(() => this.#transport.finalizeUpload(upload.uploadId)).pipe(
-                              Effect4.tap(
-                                () => Effect4.sync(() => {
-                                  commitOperation?.observe("observed", "storage_commit");
-                                  commitOperation?.succeed();
-                                })
-                              ),
-                              Effect4.tapError(() => Effect4.sync(() => commitOperation?.fail("storage_commit_failed")))
-                            );
+                            return foreign(() => this.#transport.finalizeUpload(upload.uploadId)).pipe();
                           })
                         )
                       )
@@ -4381,15 +3481,7 @@ var ChatControllerRuntime = class {
             )
           );
         }),
-        Effect4.mapError(normalizeClientError),
-        Effect4.tapError(
-          () => Effect4.sync(() => {
-            prepareOperation?.fail("upload_failed");
-            const failureOperation = this.#diagnostics?.startOperation("chat.attachment.fail");
-            failureOperation?.observe("observed", "failure");
-            failureOperation?.succeed();
-          })
-        )
+        Effect4.mapError(normalizeClientError)
       );
     });
   };
@@ -4419,13 +3511,46 @@ var ChatControllerRuntime = class {
     this.#initialCatchUpComplete = this.#contiguousSequence !== null;
     this.#unsubscribeEvents = ports.sync.subscribeCollaboration((event) => {
       if (event.type === "chat_message") this.#observeMessage(chatMessageFor(event.message), this.#initialCatchUpComplete);
+      else if (event.type === "chat_reactions") this.#mergeReactions(event.state);
       else if (event.type === "chat_read_receipt") this.#mergeReceipt(chatReceiptFor(event.receipt));
       else if (event.type === "chat_cursor_reset") this.#applyCursorReset(event.retainedFloorSequence);
     });
-    this.#unsubscribeSnapshot = ports.sync.subscribe(() => this.#scheduleCatchUp());
+    let wasReady = ports.sync.getCollaborationExtensionState().negotiated && ports.sync.getSnapshot().connection.phase === "live";
+    this.#unsubscribeSnapshot = ports.sync.subscribe(() => {
+      const ready = ports.sync.getCollaborationExtensionState().negotiated && ports.sync.getSnapshot().connection.phase === "live";
+      if (ready && !wasReady) this.#refreshLoaded(ports);
+      wasReady = ready;
+      this.#scheduleCatchUp();
+    });
+    this.#refreshLoaded(ports);
     this.#scheduleCatchUp();
     this.#publish();
   }
+  #refreshLoaded(ports) {
+    const first = this.#messages[0];
+    const last = this.#messages.at(-1);
+    if (!first || !last || ports.sync.getCollaborationExtensionState().version !== 2 || ports.sync.getSnapshot().connection.phase !== "live") return;
+    const owner = this;
+    this.#fork(
+      Effect4.gen(function* () {
+        let cursor = String(BigInt(first.sequence) - 1n);
+        for (let page = 0; page < MAX_LOADED_CHAT_MESSAGES && owner.#ports === ports; page++) {
+          const result = yield* foreign(() => ports.sync.readChatPage({ afterSequence: cursor, limit: MAX_CHAT_PAGE_SIZE }));
+          if (result.status !== "loaded" || result.count === 0) break;
+          const next = owner.#messages.filter((message) => compareChatSequence(message.sequence, cursor) > 0).at(Math.min(result.count, MAX_LOADED_CHAT_MESSAGES) - 1)?.sequence;
+          if (!next || compareChatSequence(next, cursor) <= 0 || compareChatSequence(next, last.sequence) >= 0) break;
+          cursor = next;
+        }
+      }).pipe(
+        Effect4.catch(
+          (cause) => Effect4.sync(() => {
+            this.#lastError = failureFromError(normalizeClientError(cause));
+            this.#publish();
+          })
+        )
+      )
+    );
+  }
   #scheduleCatchUp() {
     const ports = this.#ports;
     const floor = ports?.sync.getCollaborationExtensionState().retainedFloorSequence;
@@ -4535,6 +3660,8 @@ var ChatControllerRuntime = class {
     this.#contiguousSequence = String(sequence);
   }
   #observeMessage(message, countUnread) {
+    const cached = this.#reactionStates.get(message.messageId);
+    if (cached && compareChatSequence(cached.revision, message.reactionRevision ?? "0") > 0) message = chatMessageFor({ ...message, reactions: cached.reactions, reactionRevision: cached.revision });
     const existing = this.#messages.find((candidate) => candidate.messageId === message.messageId || candidate.sequence === message.sequence);
     const next = this.#messagesWith(message, existing);
     const pendingSends = this.#pendingSends.filter((pending) => pending.clientMessageId !== message.clientMessageId);
@@ -4562,6 +3689,17 @@ var ChatControllerRuntime = class {
   #messageStateMatches(messages, pendingSends, unread) {
     return messages === this.#messages && pendingSends.length === this.#pendingSends.length && unread === this.#unreadCount && this.#status === "ready" && this.#lastError === null;
   }
+  #mergeReactions(state) {
+    const cached = this.#reactionStates.get(state.messageId);
+    if (cached && compareChatSequence(cached.revision, state.revision) >= 0) return;
+    this.#reactionStates.delete(state.messageId);
+    this.#reactionStates.set(state.messageId, state);
+    if (this.#reactionStates.size > MAX_LOADED_CHAT_MESSAGES) this.#reactionStates.delete(this.#reactionStates.keys().next().value);
+    const existing = this.#messages.find((message) => message.messageId === state.messageId);
+    if (!existing || compareChatSequence(state.revision, existing.reactionRevision ?? "0") <= 0) return;
+    this.#messages = mergeChatMessage(this.#messages, existing, chatMessageFor({ ...existing, reactions: state.reactions, reactionRevision: state.revision }));
+    this.#publish();
+  }
   #mergeReceipt(receipt) {
     const existing = this.#readReceipts.find((candidate) => candidate.participantId === receipt.participantId && candidate.participantGeneration === receipt.participantGeneration);
     if (existing && compareChatSequence(existing.readThroughSequence, receipt.readThroughSequence) >= 0) return;
@@ -4591,6 +3729,7 @@ var ChatControllerRuntime = class {
     this.#publish();
   }
   #reset() {
+    this.#reactionStates.clear();
     this.#catchUpRequested = false;
     this.#contiguousSequence = null;
     this.#hasOlder = false;
@@ -4647,11 +3786,11 @@ function chatError(message) {
 }
 
 // src/space-client/media-controller.ts
-import { Clock as Clock3, Context as Context6, Effect as Effect5, Layer as Layer6, Semaphore } from "effect";
+import { Clock as Clock3, Context as Context6, Effect as Effect5, Exit as Exit2, Layer as Layer6, Semaphore } from "effect";
 var MEDIA_SOURCES = ["microphone", "camera", "screen"];
 var MediaControllerService = class extends Context6.Service()("@chalk/client/MediaController") {
 };
-var makeMediaController = (connection, store, selection, diagnostics) => Effect5.gen(function* () {
+var makeMediaController = (connection, store, selection) => Effect5.gen(function* () {
   const [microphone, camera, screen] = yield* Effect5.all([Semaphore.make(1), Semaphore.make(1), Semaphore.make(1)]);
   const clock = yield* Clock3.Clock;
   const scope = yield* Effect5.scope;
@@ -4669,8 +3808,7 @@ var makeMediaController = (connection, store, selection, diagnostics) => Effect5
       ["screen", screen]
     ]),
     clock.currentTimeMillisUnsafe,
-    fork,
-    diagnostics
+    fork
   );
   yield* connection.setInitialMedia(
     (intent) => controller.captureInitial(intent),
@@ -4687,7 +3825,6 @@ var MediaControllerRuntime = class {
   #gates;
   #now;
   #fork;
-  #diagnostics;
   #tracks = /* @__PURE__ */ new Map();
   #observedPublicationIds = /* @__PURE__ */ new Map();
   #intentRevisions = /* @__PURE__ */ new Map();
@@ -4698,20 +3835,20 @@ var MediaControllerRuntime = class {
   #requests = Object.freeze([]);
   #ports = null;
   #screenEndedPending = false;
+  #screenAudioTrack = null;
   #unsubscribeMedia = null;
   #unsubscribeRequests = null;
   #unsubscribeSync = null;
   #unsubscribeConnection = null;
   #unsubscribeScreenEnded = null;
   #unsubscribePorts = null;
-  constructor(connection, store, selection, gates, now, fork, diagnostics) {
+  constructor(connection, store, selection, gates, now, fork) {
     this.#connection = connection;
     this.#store = store;
     this.#selection = selection;
     this.#gates = gates;
     this.#now = now;
     this.#fork = fork;
-    this.#diagnostics = diagnostics;
     this.#unsubscribeConnection = connection.subscribe(() => this.#handleConnectionChange());
     this.#unsubscribeScreenEnded = connection.subscribeScreenEnded(() => this.#handleScreenEnded());
     this.#unsubscribePorts = connection.subscribePorts((ports) => this.#bind(ports));
@@ -4722,7 +3859,7 @@ var MediaControllerRuntime = class {
   }
   setMicrophoneEnabled = (enabled) => this.#set("microphone", enabled);
   setCameraEnabled = (enabled) => this.#set("camera", enabled);
-  setScreenShareEnabled = (enabled) => enabled ? this.#startScreen() : this.#stopScreen();
+  setScreenShareEnabled = (enabled, options) => enabled ? this.#startScreen(options) : this.#stopScreen();
   selectMicrophone = (deviceId) => Effect5.sync(() => {
     this.#selection.selectCapture("microphone", deviceId);
     this.#store.select("microphone", deviceId);
@@ -4736,39 +3873,22 @@ var MediaControllerRuntime = class {
     Effect5.mapError(normalizeClientError)
   );
   acceptRequest = (requestId) => {
-    const operation = this.#diagnostics?.startOperation("media_request.accept");
     return Effect5.suspend(() => {
       const request = this.#requests.find((candidate) => candidate.requestId === requestId);
       if (!request) return Effect5.fail(new SpaceClientError({ code: "media.request_invalid", recoverable: false, message: "The media request is no longer active" }));
-      operation?.observe("observed", "capability_decision");
       return (request.kind === "unmute" ? this.#set("microphone", true) : this.#set("camera", true)).pipe(
         Effect5.tap(
           () => Effect5.sync(() => {
             this.#removeRequest(requestId);
-            operation?.observe("observed", "command_commit");
-            operation?.observe("observed", "target_result");
-            operation?.succeed();
           })
-        ),
-        Effect5.tapError(() => Effect5.sync(() => operation?.fail("accept_failed")))
+        )
       );
-    }).pipe(
-      Effect5.mapError(normalizeClientError),
-      Effect5.tapError(() => Effect5.sync(() => operation?.fail("accept_failed")))
-    );
+    }).pipe(Effect5.mapError(normalizeClientError));
   };
   declineRequest = (requestId) => {
-    const operation = this.#diagnostics?.startOperation("media_request.decline");
     return Effect5.sync(() => {
-      operation?.observe("observed", "capability_decision");
       this.#removeRequest(requestId);
-      operation?.notObservable("command_commit", "decline_is_local_only");
-      operation?.observe("observed", "target_result");
-      operation?.succeed();
-    }).pipe(
-      Effect5.mapError(normalizeClientError),
-      Effect5.tapError(() => Effect5.sync(() => operation?.fail("decline_failed")))
-    );
+    }).pipe(Effect5.mapError(normalizeClientError));
   };
   initialIntent() {
     return { ...this.#intent };
@@ -4819,14 +3939,14 @@ var MediaControllerRuntime = class {
     this.#unsubscribeScreenEnded = null;
     this.#unsubscribePorts = null;
     this.#ports = null;
+    this.#screenAudioTrack?.stop();
+    this.#screenAudioTrack = null;
     for (const track of this.#tracks.values()) track.stop();
     this.#tracks.clear();
     this.#clearRequests();
     this.#publish();
   }
   #set(source, enabled) {
-    const operation = this.#diagnostics?.startOperation(`${source}.${enabled ? "publish" : "unpublish"}`);
-    operation?.observe("observed", "intent");
     let previousIntent = this.#intent[source];
     let intentRevision = 0;
     let earlyPause = null;
@@ -4857,10 +3977,7 @@ var MediaControllerRuntime = class {
                       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);
@@ -4886,23 +4003,14 @@ var MediaControllerRuntime = class {
                     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({
@@ -4926,7 +4034,6 @@ var MediaControllerRuntime = class {
       )
     ).pipe(
       Effect5.mapError(normalizeClientError),
-      Effect5.tapError(() => Effect5.sync(() => operation?.fail("media_failed"))),
       Effect5.ensuring(
         Effect5.sync(() => {
           if (this.#pendingEnables.get(source) === intentRevision) this.#pendingEnables.delete(source);
@@ -4934,8 +4041,7 @@ var MediaControllerRuntime = class {
       )
     );
   }
-  #startScreen() {
-    const operation = this.#diagnostics?.startOperation("screen.start");
+  #startScreen(options) {
     let intentRevision = 0;
     return Effect5.sync(() => {
       intentRevision = (this.#intentRevisions.get("screen") ?? 0) + 1;
@@ -4947,45 +4053,64 @@ var MediaControllerRuntime = class {
         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();
+              if (this.#tracks.has("screen") && options === void 0) {
                 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();
-                  })
+              return Effect5.acquireUseRelease(
+                foreign2(() => this.#selection.getDisplayMedia(displayMediaConstraints(options))).pipe(Effect5.mapError((cause) => captureError(cause, "startScreenShare", "Screen sharing permission was denied"))),
+                (stream) => Effect5.sync(() => {
+                  this.#assertActivePorts(ports, "startScreenShare");
+                  track = requireDisplayVideoTrack(stream);
+                  return { stream, track };
+                }).pipe(
+                  Effect5.tap(() => {
+                    const previous = this.#tracks.get("screen");
+                    if (!previous) return Effect5.void;
+                    return foreign2(() => ports.sync.setScreenShareEnabled(false)).pipe(
+                      Effect5.andThen(this.#clearScreenAudio(ports.media)),
+                      Effect5.andThen(foreign2(() => ports.media.clearPreparedLocalTrack("screen"))),
+                      Effect5.tap(
+                        () => Effect5.sync(() => {
+                          this.#assertActivePorts(ports, "startScreenShare");
+                          this.#tracks.delete("screen");
+                          previous.stop();
+                        })
+                      )
+                    );
+                  }),
+                  Effect5.tap(
+                    ({ stream: captured, track: screenTrack }) => Effect5.sync(() => {
+                      const audio = captured.getAudioTracks()[0];
+                      for (const extra of captured.getAudioTracks().slice(1)) extra.stop();
+                      ports.media.prepareLocalTrack("screen", screenTrack);
+                      prepared = true;
+                      this.#tracks.set("screen", screenTrack);
+                      this.#screenAudioTrack = audio ?? null;
+                      if (audio) {
+                        ports.media.prepareLocalTrack("screen_audio", audio);
+                        audio.addEventListener("ended", () => this.#handleScreenAudioEnded(audio, ports));
+                      }
+                      screenTrack.addEventListener("ended", () => this.#handleScreenEnded(screenTrack));
+                      this.#screenEndedPending = false;
+                      this.#publish();
+                    })
+                  ),
+                  Effect5.andThen(foreign2(() => ports.sync.setScreenShareEnabled(true))),
+                  Effect5.tap(() => Effect5.sync(() => this.#assertActivePorts(ports, "startScreenShare"))),
+                  Effect5.asVoid,
+                  Effect5.catch(
+                    (cause) => (prepared ? this.#clearScreenAudio(ports.media) : Effect5.void).pipe(
+                      Effect5.ignore,
+                      Effect5.andThen(this.#rollbackCapture({ action: "startScreenShare", cause, fallback: Effect5.sync(() => stopStream(stream)), media: ports.media, permissionMessage: "Screen sharing permission was denied", prepared, source: "screen", track }))
+                    )
+                  )
                 ),
-                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 }))
+                (stream, exit) => Effect5.sync(() => {
+                  if (Exit2.isFailure(exit)) stopStream(stream);
+                })
               );
             });
           })
@@ -4993,7 +4118,6 @@ var MediaControllerRuntime = class {
       )
     ).pipe(
       Effect5.mapError(normalizeClientError),
-      Effect5.tapError(() => Effect5.sync(() => operation?.fail("screen_start_failed"))),
       Effect5.ensuring(
         Effect5.sync(() => {
           if (this.#pendingEnables.get("screen") === intentRevision) this.#pendingEnables.delete("screen");
@@ -5002,7 +4126,6 @@ var MediaControllerRuntime = class {
     );
   }
   #stopScreen() {
-    const operation = this.#diagnostics?.startOperation("screen.stop");
     let intentRevision = 0;
     let earlyPause = null;
     const localPause = Effect5.suspend(() => {
@@ -5028,6 +4151,7 @@ var MediaControllerRuntime = class {
                 ),
                 Effect5.andThen(foreign2(() => ports.sync.setScreenShareEnabled(false))),
                 Effect5.tap(() => Effect5.sync(() => this.#assertActivePorts(ports, "stopScreenShare"))),
+                Effect5.andThen(this.#clearScreenAudio(ports.media)),
                 Effect5.andThen(foreign2(() => ports.media.clearPreparedLocalTrack("screen"))),
                 Effect5.tap(
                   () => Effect5.sync(() => {
@@ -5036,8 +4160,6 @@ var MediaControllerRuntime = class {
                     track?.stop();
                     this.#screenEndedPending = false;
                     this.#publish();
-                    operation?.observe("observed", "stop_confirmation");
-                    operation?.succeed();
                   })
                 ),
                 Effect5.asVoid,
@@ -5053,9 +4175,16 @@ var MediaControllerRuntime = class {
           )
         )
       )
-    ).pipe(
-      Effect5.mapError(normalizeClientError),
-      Effect5.tapError(() => Effect5.sync(() => operation?.fail("screen_stop_failed")))
+    ).pipe(Effect5.mapError(normalizeClientError));
+  }
+  #clearScreenAudio(media) {
+    return foreign2(() => media.clearPreparedLocalTrack("screen_audio")).pipe(
+      Effect5.ensuring(
+        Effect5.sync(() => {
+          this.#screenAudioTrack?.stop();
+          this.#screenAudioTrack = null;
+        })
+      )
     );
   }
   #beginLocalPause(ports, source) {
@@ -5134,8 +4263,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 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)));
+    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)));
   }
   #assertActivePorts(ports, action) {
     if (this.#connection.getSnapshot().state === "live" && this.#ports?.sync === ports.sync && this.#ports.media === ports.media) return;
@@ -5151,6 +4280,8 @@ var MediaControllerRuntime = class {
     if (this.#ports?.media !== ports?.media) this.#observedPublicationIds.clear();
     this.#ports = ports;
     if (!ports) {
+      this.#screenAudioTrack?.stop();
+      this.#screenAudioTrack = null;
       for (const track of this.#tracks.values()) track.stop();
       this.#tracks.clear();
       this.#screenEndedPending = false;
@@ -5174,7 +4305,7 @@ var MediaControllerRuntime = class {
   }
   #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;
+      publication.track.enabled = snapshot.media?.items.some((item) => item.participantId === publication.participantId && item.source === (publication.source === "screen_audio" ? "screen" : publication.source) && item.enabled) ?? false;
     }
   }
   #applyForcedMediaState(ports, snapshot) {
@@ -5195,8 +4326,7 @@ var MediaControllerRuntime = class {
   #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;
+      this.#clearForcedIntent(source);
     }
     const track = this.#tracks.get(source);
     if (track) track.enabled = false;
@@ -5205,6 +4335,11 @@ var MediaControllerRuntime = class {
     if (pendingEnable) ports.media.setLocalSourceIntent?.(source, true);
     this.#publish();
   }
+  #clearForcedIntent(source) {
+    this.#intentRevisions.set(source, (this.#intentRevisions.get(source) ?? 0) + 1);
+    if (source !== "screen") this.#intent[source] = false;
+    else if (this.#screenAudioTrack) this.#screenAudioTrack.enabled = false;
+  }
   #hasPendingEnable(source) {
     const revision = this.#pendingEnables.get(source);
     return revision !== void 0 && revision === this.#intentRevisions.get(source);
@@ -5258,21 +4393,24 @@ var MediaControllerRuntime = class {
     }
     this.#publish();
   }
+  #handleScreenAudioEnded(track, ports) {
+    this.#fork(
+      this.#serialize(
+        "screen",
+        Effect5.suspend(() => {
+          if (this.#screenAudioTrack !== track || this.#ports !== ports) return Effect5.void;
+          return this.#clearScreenAudio(ports.media).pipe(Effect5.ensuring(Effect5.sync(() => this.#publish())));
+        })
+      ).pipe(Effect5.ignore)
+    );
+  }
   #handleScreenEnded(track = this.#tracks.get("screen")) {
     if (!track || this.#tracks.get("screen") !== track) return;
     if (this.#connection.getSnapshot().state === "reconnecting") {
       this.#screenEndedPending = true;
       return;
     }
-    const operation = this.#diagnostics?.startOperation("screen.unexpected_end");
-    operation?.observe("observed", "track_end");
-    this.#fork(
-      this.#stopScreen().pipe(
-        Effect5.tap(() => Effect5.sync(() => operation?.succeed())),
-        Effect5.tapError(() => Effect5.sync(() => operation?.fail("screen_stop_failed"))),
-        Effect5.ignore
-      )
-    );
+    this.#fork(this.#stopScreen().pipe(Effect5.ignore));
   }
   #publish() {
     const current = this.#store.getSnapshot();
@@ -5284,7 +4422,17 @@ var MediaControllerRuntime = class {
       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 });
+    const media = Object.freeze({
+      ...current.media,
+      local,
+      remote,
+      screenShare: {
+        ...local.screen,
+        hasAudio: Boolean(this.#screenAudioTrack?.readyState === "live" && snapshot?.localTracks.some((track) => track.source === "screen_audio" && track.enabled && track.track.readyState === "live")),
+        ...local.screen.track ? { capture: screenShareCapture(local.screen.track) } : {}
+      },
+      incomingRequests: this.#requests
+    });
     if (!sameMediaSlice(current.media, media)) this.#store.updateMedia(media);
   }
 };
@@ -5348,7 +4496,10 @@ function activeLocalMediaState(connectionState) {
 function sameMediaSlice(left, right) {
   if (left.selection !== right.selection || !sameDevices(left.devices, right.devices)) return false;
   for (const source of MEDIA_SOURCES) if (!sameLocalMedia(left.local[source], right.local[source])) return false;
-  return sameLocalMedia(left.screenShare, right.screenShare) && sameRemoteMedia(left.remote, right.remote) && sameRequests(left.incomingRequests, right.incomingRequests);
+  return sameScreenShare(left.screenShare, right.screenShare) && sameRemoteMedia(left.remote, right.remote) && sameRequests(left.incomingRequests, right.incomingRequests);
+}
+function sameScreenShare(left, right) {
+  return sameLocalMedia(left, right) && left.hasAudio === right.hasAudio && left.capture?.surface === right.capture?.surface && left.capture?.label === right.capture?.label;
 }
 function sameLocalMedia(left, right) {
   return left.source === right.source && left.state === right.state && left.track === right.track;
@@ -5375,8 +4526,8 @@ function sameDeviceList(left, right) {
 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 });
-  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 });
+  const failure2 = describeMediaCaptureError(cause);
+  return new ConnectionError({ ...failure2, action, message: action === "startScreenShare" ? "Screen sharing could not start. Check screen recording permission and try again in a supported browser or app." : failure2.message }, { cause });
 }
 function isPermissionDenied(cause) {
   return describeMediaCaptureError(cause).code === "permission_denied";
@@ -5395,7 +4546,7 @@ function canApplyForcedMediaState(snapshot) {
 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";
+import { Schema as Schema4 } from "effect";
 var OFFLINE_ACTION_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 function browserOfflineActionsStorage() {
   if (typeof window === "undefined") return void 0;
@@ -5405,28 +4556,29 @@ function browserOfflineActionsStorage() {
     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 attachment = Schema4.Struct({ attachmentId: Schema4.String, fileName: Schema4.String, mimeType: ChatAttachmentMimeTypeSchema, byteLength: Schema4.Number });
+var StoredOfflineAction = Schema4.Struct({
+  id: Schema4.String,
+  kind: Schema4.Literals(["chat_message", "chat_reaction", "hand_raise", "hand_lower"]),
+  text: Schema4.NullOr(Schema4.String),
+  queuedAt: Schema4.Number,
+  clientMessageId: Schema4.optional(Schema4.String),
+  attachments: Schema4.optional(Schema4.Array(attachment)),
+  reaction: Schema4.optional(Schema4.Struct({ messageId: UuidSchema, emoji: ReactionSchema, on: Schema4.Boolean }))
 });
-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 StoredOfflineActions = Schema4.Struct({
+  version: Schema4.Literal(1),
+  subject: Schema4.Struct({ tenantId: Schema4.String, spaceId: Schema4.String, episodeId: Schema4.String, participantId: Schema4.String, participantGeneration: Schema4.Number }),
+  actions: Schema4.Array(StoredOfflineAction)
 });
-var decodeOfflineActions = Schema3.decodeUnknownSync(StoredOfflineActions);
+var decodeOfflineActions = Schema4.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 validStoredAction = (action, now) => (action.kind !== "chat_reaction" || action.reaction !== void 0) && 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);
@@ -5576,7 +4728,7 @@ var OfflineActionsRuntime = class {
       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"),
+            try: () => action.kind === "chat_reaction" && action.reaction ? sync.reactToChatMessage(action.reaction).then(() => void 0) : 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()
           })
         );
@@ -5667,55 +4819,54 @@ var CAPABILITIES = new Set(V1_CAPABILITIES);
 var EMPTY_PARTICIPANTS = Object.freeze({ roster: Object.freeze([]), admissionQueue: Object.freeze([]) });
 var ParticipantsControllerService = class extends Context8.Service()("@chalk/client/ParticipantsController") {
 };
-var makeParticipantsController = (connection, store, diagnostics, offline) => Effect7.acquireRelease(
-  Effect7.sync(() => new ParticipantsControllerRuntime(connection, store, diagnostics, offline)),
+var makeParticipantsController = (connection, store, offline) => Effect7.acquireRelease(
+  Effect7.sync(() => new ParticipantsControllerRuntime(connection, store, offline)),
   (controller) => Effect7.sync(() => controller.dispose())
 );
 var ParticipantsControllerRuntime = class {
   #connection;
   #store;
-  #diagnostics;
   #offline;
   #unsubscribePorts = null;
   #unsubscribe = null;
-  constructor(connection, store, diagnostics, offline) {
+  #unsubscribeMedia = null;
+  constructor(connection, store, offline) {
     this.#offline = offline;
     this.#connection = connection;
     this.#store = store;
-    this.#diagnostics = diagnostics;
     this.#unsubscribePorts = connection.subscribePorts((ports) => this.#bind(ports));
   }
-  assignRole = (participantId, roleName) => this.#command("moderation.role.change", ["capability_decision", "command_commit"], () => {
+  assignRole = (participantId, roleName) => this.#command(() => {
     assertIdentifier(participantId, "participant ID");
     assertName(roleName, "role");
     return ({ sync }) => foreign3(() => sync.assignRole(participantId, roleName));
   });
-  mute = (participantId) => this.#command("moderation.microphone.disable", ["capability_decision", "command_commit", "target_delivery"], () => {
+  mute = (participantId) => this.#command(() => {
     assertIdentifier(participantId, "participant ID");
     return ({ sync }) => foreign3(() => sync.muteParticipant(participantId));
   });
-  stopVideo = (participantId) => this.#command("moderation.camera.disable", ["capability_decision", "command_commit", "target_delivery"], () => {
+  stopVideo = (participantId) => this.#command(() => {
     assertIdentifier(participantId, "participant ID");
     return ({ sync }) => foreign3(() => sync.stopParticipantCamera(participantId));
   });
-  stopScreenShare = (participantId) => this.#command("moderation.screen.disable", ["capability_decision", "command_commit", "target_delivery"], () => {
+  stopScreenShare = (participantId) => this.#command(() => {
     assertIdentifier(participantId, "participant ID");
     return ({ sync }) => foreign3(() => sync.stopParticipantScreenShare(participantId));
   });
-  requestMedia = (participantId, kind) => this.#command("media_request.request", ["capability_decision", "command_commit", "target_result"], () => {
+  requestMedia = (participantId, kind) => this.#command(() => {
     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(Effect7.map(directed));
   });
-  remove = (participantId) => this.#command("moderation.remove", ["capability_decision", "command_commit", "target_delivery"], () => {
+  remove = (participantId) => this.#command(() => {
     assertIdentifier(participantId, "participant ID");
     return ({ sync }) => foreign3(() => sync.removeParticipant(participantId));
   });
-  admit = (requestId) => this.#command("admission.admit", ["policy_decision", "authoritative_commit", "participant_result"], () => {
+  admit = (requestId) => this.#command(() => {
     assertIdentifier(requestId, "admission request ID");
     return ({ sync }) => foreign3(() => sync.admit(requestId));
   });
-  deny = (requestId) => this.#command("admission.deny", ["policy_decision", "authoritative_commit", "participant_result"], () => {
+  deny = (requestId) => this.#command(() => {
     assertIdentifier(requestId, "admission request ID");
     return ({ sync }) => foreign3(() => sync.deny(requestId));
   });
@@ -5723,50 +4874,50 @@ var ParticipantsControllerRuntime = class {
   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"], () => {
+  renameSelf = (displayName) => this.#command(() => {
     assertName(displayName, "display name");
     return ({ sync }) => foreign3(() => sync.setDisplayName(displayName));
   });
   dispose() {
     this.#unsubscribePorts?.();
     this.#unsubscribe?.();
+    this.#unsubscribeMedia?.();
+    this.#unsubscribeMedia = null;
     this.#unsubscribePorts = null;
     this.#unsubscribe = null;
   }
-  #command(name, checkpoints, operation) {
-    const diagnostic = this.#diagnostics?.startOperation(name);
+  #command(operation) {
     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();
-        })
-      ),
-      Effect7.tapError(() => Effect7.sync(() => diagnostic?.fail("command_failed")))
+      Effect7.mapError(normalizeClientError)
     );
   }
   #bind(ports) {
     this.#unsubscribe?.();
+    this.#unsubscribeMedia?.();
     this.#unsubscribe = null;
+    this.#unsubscribeMedia = null;
     if (!ports) {
       this.#publish(null, {});
       return;
     }
-    this.#unsubscribe = ports.sync.subscribe((snapshot) => this.#publish(snapshot, ports.sync.getParticipantCollaborationCapabilities()));
-    this.#publish(ports.sync.getSnapshot(), ports.sync.getParticipantCollaborationCapabilities());
-  }
-  #publish(snapshot, collaborationCapabilities) {
-    const participants = participantsFor(snapshot, collaborationCapabilities);
+    const publish = () => this.#publish(ports.sync.getSnapshot(), ports.sync.getParticipantCollaborationCapabilities(), ports.media.getSnapshot());
+    this.#unsubscribe = ports.sync.subscribe(publish);
+    this.#unsubscribeMedia = ports.media.subscribe(publish);
+    publish();
+  }
+  #publish(snapshot, collaborationCapabilities, media) {
+    const audioParticipants = new Set(media?.remoteTracks.filter((track) => track.source === "screen_audio" && track.track.readyState === "live").map((track) => track.participantId));
+    if (snapshot?.participantId && media?.localTracks.some((track) => track.source === "screen_audio" && track.enabled && track.track.readyState === "live")) audioParticipants.add(snapshot.participantId);
+    const projected = participantsFor(snapshot, collaborationCapabilities);
+    const participants = Object.freeze({
+      ...projected,
+      roster: Object.freeze(projected.roster.map((participant) => Object.freeze({ ...participant, media: Object.freeze({ ...participant.media, screenShareHasAudio: participant.media.screenShare === "active" && audioParticipants.has(participant.participantId) }) })))
+    });
     const self = selfFor(snapshot, participants.roster);
     const current = this.#store.getSnapshot();
     if (!sameParticipants(current.participants, participants)) this.#store.updateParticipants(participants);
@@ -5868,7 +5019,7 @@ function sameParticipantProfile(left, right) {
   return left.participantId === right.participantId && left.displayName === right.displayName && left.role === right.role && left.handRaised === right.handRaised && sameValues(left.eligibleRoles, right.eligibleRoles) && sameValues(left.capabilities, right.capabilities);
 }
 function sameParticipantMedia(left, right) {
-  return left.media.microphone === right.media.microphone && left.media.camera === right.media.camera && left.media.screenShare === right.media.screenShare;
+  return left.media.microphone === right.media.microphone && left.media.camera === right.media.camera && left.media.screenShare === right.media.screenShare && left.media.screenShareHasAudio === right.media.screenShareHasAudio;
 }
 function sameParticipantPresence(left, right) {
   return left.presence.state === right.presence.state && left.presence.speaking === right.presence.speaking && left.presence.activeSpeaker === right.presence.activeSpeaker;
@@ -5886,17 +5037,17 @@ function sameValues(left, right) {
 // src/space-client/reactions-controller.ts
 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 REACTIONS = new Set(CHALK_REACTIONS);
 var ReactionsControllerService = class extends Context9.Service()("@chalk/client/ReactionsController") {
 };
-var makeReactionsController = (connection, store, diagnostics) => Effect8.gen(function* () {
+var makeReactionsController = (connection, store) => Effect8.gen(function* () {
   const clock = yield* Clock4.Clock;
   const scope = yield* Effect8.scope;
   const context = yield* Effect8.context();
   const fork = (effect) => {
     void Effect8.runForkWith(context)(Effect8.forkIn(effect, scope).pipe(Effect8.asVoid));
   };
-  const controller = new ReactionsControllerRuntime(connection, store, clock.currentTimeMillisUnsafe, fork, diagnostics);
+  const controller = new ReactionsControllerRuntime(connection, store, clock.currentTimeMillisUnsafe, fork);
   yield* Effect8.addFinalizer(() => Effect8.sync(() => controller.dispose()));
   return controller;
 });
@@ -5905,41 +5056,32 @@ var ReactionsControllerRuntime = class {
   #store;
   #now;
   #fork;
-  #diagnostics;
   #active = /* @__PURE__ */ new Map();
   #expiryGenerations = /* @__PURE__ */ new Map();
   #unsubscribePorts = null;
   #unsubscribe = null;
-  constructor(connection, store, now, fork, diagnostics) {
+  constructor(connection, store, now, fork) {
     this.#connection = connection;
     this.#store = store;
     this.#now = now;
     this.#fork = fork;
-    this.#diagnostics = diagnostics;
     this.#unsubscribePorts = connection.subscribePorts((ports) => this.#bind(ports));
   }
   send = (emoji) => {
-    const operation = this.#diagnostics?.startOperation("reaction.send");
     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(
-      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();
         })
       ),
-      Effect8.mapError(normalizeClientError),
-      Effect8.tapError(() => Effect8.sync(() => operation?.fail("send_failed")))
+      Effect8.mapError(normalizeClientError)
     );
   };
   dispose() {
@@ -6017,30 +5159,24 @@ function sameReactions(left, right) {
 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)),
+var makeRecordingController = (connection, store) => Effect9.acquireRelease(
+  Effect9.sync(() => new RecordingControllerRuntime(connection, store)),
   (controller) => Effect9.sync(() => controller.dispose())
 );
 var RecordingControllerRuntime = class {
   #connection;
   #store;
-  #diagnostics;
   #subscriptions = { ports: null, recording: null };
-  constructor(connection, store, diagnostics) {
+  constructor(connection, store) {
     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)
   );
@@ -6064,16 +5200,11 @@ var RecordingControllerRuntime = class {
     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);
+  #command(authorize, execute) {
     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)))
+      Effect9.mapError(normalizeClientError)
     );
   }
   #bind(ports) {
@@ -6194,11 +5325,11 @@ var ControllerEffectsService = class extends Context12.Service()("@chalk/client/
 };
 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, 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 media = yield* makeMediaController(input.connection, input.store, input.mediaDeviceSelection);
+  const chat = yield* makeChatController({ connection: input.connection, store: input.store, createTransport: input.featureFactories?.createChatFileTransport, apiBaseUrl: input.apiBaseUrl, fetch: input.fetch, offline: offlineActions });
+  const participants = yield* makeParticipantsController(input.connection, input.store, offlineActions);
+  const reactions = yield* makeReactionsController(input.connection, input.store);
+  const recording = yield* makeRecordingController(input.connection, input.store);
   const whiteboard = yield* makeWhiteboardController(input.connection, input.store, input.featureFactories?.createWhiteboardClient);
   return { media, offline: offlineActions, chat, participants, reactions, recording, whiteboard };
 });
@@ -6254,775 +5385,21 @@ function requireDeviceId(deviceId) {
   throw new SpaceClientError({ code: "media.request_invalid", recoverable: false, message: "A media device ID is required" });
 }
 
-// src/space-client/episode-diagnostic-runtime.ts
-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;
-var DEFAULT_QUEUE_EVENTS = 128;
-var DEFAULT_QUEUE_BYTES = 128 * 1024;
-var DEFAULT_QUEUE_AGE_MS = 60 * 1e3;
-var DEFAULT_BATCH_EVENTS = 25;
-var DEFAULT_BATCH_BYTES = 32 * 1024;
-var DEFAULT_RETRY_ATTEMPTS = 3;
-var DEFAULT_RETRY_DELAY_MS = 500;
-var TERMINAL_CHECKPOINT_OVERRIDES = { "chat.send": "sender_receipt", "chat.retry": "sender_receipt", "reaction.send": "sender_result" };
-var EpisodeDiagnosticRuntime = class {
-  #apiBaseUrl;
-  #instanceId;
-  #createId;
-  #fetch;
-  #now;
-  #setTimeout;
-  #clearTimeout;
-  #exporter;
-  #journeyId;
-  #traceparent;
-  #tracestate;
-  #maxRingEvents;
-  #maxRingBytes;
-  #maxRingAgeMs;
-  #maxQueueEvents;
-  #maxQueueBytes;
-  #maxQueueAgeMs;
-  #maxBatchEvents;
-  #maxBatchBytes;
-  #maxRetryAttempts;
-  #retryDelayMs;
-  #release;
-  #ring = [];
-  #queue = [];
-  #quarantine = [];
-  #ringBytes = 0;
-  #queueBytes = 0;
-  #quarantineBytes = 0;
-  #sequence = 0;
-  #credential = null;
-  #credentialEpoch = 0;
-  #captureEnabled = false;
-  #timer;
-  #retryTimer;
-  #retryResolve = null;
-  #activeExportController = null;
-  #flushing = false;
-  #disposed = false;
-  #pendingGapCount = 0;
-  #pendingGapReason = "client_queue_overflow";
-  constructor(options) {
-    this.#apiBaseUrl = normalizedBaseUrl(options.apiBaseUrl);
-    this.#createId = options.createId;
-    this.#instanceId = safeId(options.createId());
-    this.#fetch = options.fetch ?? globalThis.fetch;
-    this.#now = options.now ?? Date.now;
-    this.#setTimeout = options.setTimeout ?? ((callback, milliseconds) => globalThis.setTimeout(callback, milliseconds));
-    this.#clearTimeout = options.clearTimeout ?? ((handle) => globalThis.clearTimeout(handle));
-    this.#exporter = options.exporter ?? ((request) => this.#export(request));
-    this.#maxRingEvents = positive(options.maxRingEvents, DEFAULT_RING_EVENTS);
-    this.#maxRingBytes = positive(options.maxRingBytes, DEFAULT_RING_BYTES);
-    this.#maxRingAgeMs = positive(options.maxRingAgeMs, DEFAULT_RING_AGE_MS);
-    this.#maxQueueEvents = positive(options.maxQueueEvents, DEFAULT_QUEUE_EVENTS);
-    this.#maxQueueBytes = positive(options.maxQueueBytes, DEFAULT_QUEUE_BYTES);
-    this.#maxQueueAgeMs = positive(options.maxQueueAgeMs, DEFAULT_QUEUE_AGE_MS);
-    this.#maxBatchEvents = positive(options.maxBatchEvents, DEFAULT_BATCH_EVENTS);
-    this.#maxBatchBytes = positive(options.maxBatchBytes, DEFAULT_BATCH_BYTES);
-    this.#maxRetryAttempts = positive(options.maxRetryAttempts, DEFAULT_RETRY_ATTEMPTS);
-    this.#retryDelayMs = positive(options.retryDelayMs, DEFAULT_RETRY_DELAY_MS);
-    this.#release = safeRelease(options.release);
-    this.#journeyId = safeCorrelation(options.journeyId) ?? safeId(options.createId());
-    const trace = createTraceContext(options.traceparent, options.tracestate);
-    this.#traceparent = trace.traceparent;
-    this.#tracestate = trace.tracestate;
-  }
-  rotateCredential(credential) {
-    try {
-      if (this.#disposed) return;
-      if (credential === null) {
-        this.#disableCapture();
-        return;
-      }
-      if (!validCredential(credential, this.#now())) {
-        this.#disableCapture();
-        return;
-      }
-      if (this.#credential && credential.generation < this.#credential.generation) return;
-      this.#credential = Object.freeze({ ...credential });
-      this.#captureEnabled = true;
-      this.#emitPendingGap();
-      this.#scheduleFlush(0);
-    } catch {
-    }
-  }
-  context(operationRef) {
-    return {
-      journeyId: this.#journeyId,
-      traceparent: this.#traceparent,
-      ...this.#tracestate ? { tracestate: this.#tracestate } : {},
-      ...operationRef ? { producerOperationRef: operationRef } : {}
-    };
-  }
-  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;
-    if (credentialGeneration === void 0) return void 0;
-    const credentialEpoch = this.#credentialEpoch;
-    const ref = safeId(producerOperationRef ?? this.#createId());
-    const trace = createTraceContext(reconnectBoundary(name) ? void 0 : this.#traceparent, this.#tracestate);
-    const correlation = { journeyId: this.#journeyId, traceId: trace.traceId, spanId: trace.spanId, ...correlationInput };
-    this.observe({ name, phase: "intent", state: "started", operationRef: ref, parentOperationRef, checkpoint: firstCheckpoint(name), attributes, correlation });
-    let ended = false;
-    const active2 = () => this.#enabled() && this.#credentialEpoch === credentialEpoch && this.#credential?.generation === credentialGeneration;
-    const terminal = (state, terminalAttributes) => {
-      if (ended || !active2()) return;
-      ended = true;
-      this.observe({ name, phase: state, state, operationRef: ref, parentOperationRef, checkpoint: terminalCheckpoint(name), attributes: terminalAttributes, correlation });
-    };
-    return Object.freeze({
-      ref,
-      observe: (phase, checkpoint, observedAttributes) => {
-        if (active2()) this.observe({ name, phase, state: "observed", operationRef: ref, parentOperationRef, checkpoint, attributes: observedAttributes, correlation });
-      },
-      succeed: (terminalAttributes) => terminal("succeeded", terminalAttributes),
-      fail: (reason) => terminal("failed", reason ? { reason: safeReason(reason) } : void 0),
-      notObservable: (checkpoint, reason) => {
-        if (active2()) this.observe({ name, phase: "not_observable", state: "not_observable", operationRef: ref, parentOperationRef, checkpoint, attributes: reason ? { reason: safeReason(reason) } : void 0, correlation });
-      }
-    });
-  }
-  observe(input) {
-    try {
-      if (!this.#enabled()) return;
-      this.#pruneExpired();
-      this.#emitPendingGap();
-      this.#enqueue(this.#draft(input));
-      this.#scheduleFlush(0);
-    } catch {
-      this.#pendingGapCount = Math.min(Number.MAX_SAFE_INTEGER, this.#pendingGapCount + 1);
-      this.#pendingGapReason = "client_event_rejected";
-    }
-  }
-  observePromise(operation, promise) {
-    if (!operation) return promise;
-    void promise.then(
-      () => operation.succeed(),
-      () => operation.fail("operation_failed")
-    );
-    return promise;
-  }
-  dispose() {
-    this.#disposed = true;
-    this.#disableCapture();
-    this.#flushing = false;
-    this.#clearBuffers();
-  }
-  /** Internal deterministic proof seam; it is not exported by the package. */
-  inspect() {
-    return Object.freeze({
-      ring: Object.freeze(this.#ring.map(({ event }) => event)),
-      queue: Object.freeze(this.#queue.map(({ event }) => event)),
-      quarantine: Object.freeze(this.#quarantine.map(({ event }) => event)),
-      dropped: this.#pendingGapCount,
-      credentialGeneration: this.#credential?.generation ?? null
-    });
-  }
-  #draft(input) {
-    return parseDiagnosticEventDraft2(
-      buildDraftInput(input, {
-        eventId: safeId(this.#createId()),
-        producerSequence: ++this.#sequence,
-        occurredAt: new Date(this.#now()).toISOString(),
-        journeyId: this.#journeyId,
-        traceparent: this.#traceparent,
-        release: this.#release
-      })
-    );
-  }
-  #enqueue(event) {
-    const buffered = { event, bytes: encodedEventSize(event), observedAt: this.#now(), credentialGeneration: this.#credential?.generation ?? 0 };
-    this.#ring.push(buffered);
-    this.#ringBytes += buffered.bytes;
-    while (this.#ring.length > this.#maxRingEvents || this.#ringBytes > this.#maxRingBytes) {
-      const removed = this.#ring.shift();
-      if (removed) this.#ringBytes -= removed.bytes;
-    }
-    this.#queue.push(buffered);
-    this.#queueBytes += buffered.bytes;
-    while (this.#queue.length > this.#maxQueueEvents || this.#queueBytes > this.#maxQueueBytes) {
-      const removed = this.#queue.shift();
-      if (removed) {
-        this.#queueBytes -= removed.bytes;
-        this.#pendingGapCount += 1;
-        this.#pendingGapReason = "client_queue_overflow";
-      }
-    }
-  }
-  #emitPendingGap() {
-    if (this.#pendingGapCount === 0 || !this.#enabled()) return;
-    const dropped = this.#pendingGapCount;
-    const reason = this.#pendingGapReason;
-    this.#pendingGapCount = 0;
-    try {
-      this.#enqueue(this.#draft({ name: "coverage.gap", phase: "observed", state: "observed", attributes: { reason, count: dropped } }));
-    } catch {
-      this.#pendingGapCount = dropped;
-    }
-  }
-  #pruneExpired() {
-    const now = this.#now();
-    while (this.#ring[0] && now - this.#ring[0].observedAt > this.#maxRingAgeMs) {
-      this.#ringBytes -= this.#ring.shift().bytes;
-    }
-    while (this.#queue[0] && now - this.#queue[0].observedAt > this.#maxQueueAgeMs) {
-      this.#queueBytes -= this.#queue.shift().bytes;
-      this.#pendingGapCount += 1;
-      this.#pendingGapReason = "client_queue_expired";
-    }
-  }
-  #scheduleFlush(delay) {
-    if (this.#timer !== void 0 || this.#flushing || !this.#deliveryCredential() || this.#queue.length === 0) return;
-    this.#timer = this.#setTimeout(() => {
-      this.#timer = void 0;
-      void this.#flush();
-    }, delay);
-  }
-  async #flush() {
-    if (this.#flushing || !this.#enabled()) return;
-    this.#pruneExpired();
-    this.#emitPendingGap();
-    if (!this.#deliveryCredential() || this.#queue.length === 0) return;
-    const batch = takeBatch(this.#queue, this.#maxBatchEvents, this.#maxBatchBytes);
-    if (batch.length === 0) return;
-    this.#flushing = true;
-    await this.#deliverBatch(batch);
-    this.#flushing = false;
-    this.#scheduleFlush(0);
-  }
-  async #deliverBatch(batch) {
-    let result;
-    let attempted = false;
-    let cancelled = false;
-    for (let attempt = 1; attempt <= this.#maxRetryAttempts; attempt += 1) {
-      const delivery = await this.#deliverAttempt(batch, attempt);
-      if (delivery.attempted) attempted = true;
-      if (delivery.result) {
-        result = delivery.result;
-        break;
-      }
-      if (delivery.cancelled) {
-        cancelled = true;
-        break;
-      }
-    }
-    this.#finishDelivery(batch, { result, attempted, cancelled });
-  }
-  async #deliverAttempt(batch, attempt) {
-    const credential = this.#deliveryCredential();
-    if (!credential) return { attempted: false, cancelled: true };
-    const controller = new AbortController();
-    this.#activeExportController = controller;
-    try {
-      return { result: await this.#exportBatch(batch, credential, controller.signal), attempted: true, cancelled: false };
-    } catch {
-      return { attempted: true, cancelled: await this.#cancelledAfterFailure(attempt) };
-    } finally {
-      if (this.#activeExportController === controller) this.#activeExportController = null;
-    }
-  }
-  async #cancelledAfterFailure(attempt) {
-    if (this.#captureEnabled && this.#credential && attempt < this.#maxRetryAttempts) return !await this.#waitRetry(this.#retryDelayMs * attempt);
-    return !this.#captureEnabled || !this.#credential || this.#disposed;
-  }
-  async #exportBatch(batch, credential, signal) {
-    return await this.#exporter({
-      endpoint: new URL(credential.intakePath, this.#apiBaseUrl).toString(),
-      token: credential.token,
-      signal,
-      body: { version: 1, producer: { id: "sdk", instanceId: this.#instanceId, generation: credential.generation }, events: batch.map(({ event }) => event) }
-    }) ?? { accepted: batch.map(({ event }) => event.eventId), duplicates: [], conflicts: [] };
-  }
-  #finishDelivery(batch, delivery) {
-    if (this.#disposed || delivery.cancelled) return;
-    if (delivery.result) {
-      this.#quarantineBatch(batch, new Set(delivery.result.conflicts));
-      this.#removeBatch(batch);
-      return;
-    }
-    if (!delivery.attempted) return;
-    this.#removeBatch(batch);
-    this.#pendingGapCount += batch.length;
-    this.#pendingGapReason = "delivery_retry_exhausted";
-    this.#emitPendingGap();
-  }
-  async #export(request) {
-    if (!this.#fetch) throw new TypeError("Fetch is unavailable");
-    const response = await this.#fetch(request.endpoint, {
-      method: "POST",
-      headers: { authorization: `Bearer ${request.token}`, "content-type": "application/json" },
-      body: JSON.stringify(request.body),
-      keepalive: true,
-      signal: request.signal
-    });
-    if (!response.ok) throw new TypeError(`Diagnostic intake rejected the batch with HTTP ${response.status}`);
-    const result = await response.json();
-    const delivery = parseIntakeResponse(result, new Set(request.body.events.map((event) => event.eventId)));
-    if (!delivery) throw new TypeError("Diagnostic intake returned an invalid durable acknowledgement");
-    return delivery;
-  }
-  #removeBatch(batch) {
-    const ids = new Set(batch.map(({ event }) => event.eventId));
-    for (let index = this.#queue.length - 1; index >= 0; index -= 1) {
-      const queued = this.#queue[index];
-      if (!queued || !ids.has(queued.event.eventId)) continue;
-      this.#queue.splice(index, 1);
-      this.#queueBytes -= queued.bytes;
-    }
-  }
-  #quarantineBatch(batch, conflicts) {
-    for (const event of batch) {
-      if (!conflicts.has(event.event.eventId)) continue;
-      this.#quarantine.push(event);
-      this.#quarantineBytes += event.bytes;
-    }
-    while (this.#quarantine.length > this.#maxRingEvents || this.#quarantineBytes > this.#maxRingBytes) {
-      const removed = this.#quarantine.shift();
-      if (removed) this.#quarantineBytes -= removed.bytes;
-    }
-  }
-  #enabled() {
-    if (this.#disposed || !this.#captureEnabled || !this.#credential) return false;
-    if (validCredential(this.#credential, this.#now())) return true;
-    this.#disableCapture();
-    return false;
-  }
-  #deliveryCredential() {
-    return this.#enabled() ? this.#credential : null;
-  }
-  #cancelTimer() {
-    if (this.#timer !== void 0) this.#clearTimeout(this.#timer);
-    this.#timer = void 0;
-  }
-  #disableCapture() {
-    this.#credentialEpoch += 1;
-    this.#credential = null;
-    this.#captureEnabled = false;
-    this.#cancelTimer();
-    this.#activeExportController?.abort();
-    this.#activeExportController = null;
-    if (this.#retryTimer !== void 0) this.#clearTimeout(this.#retryTimer);
-    this.#retryTimer = void 0;
-    this.#retryResolve?.();
-    this.#retryResolve = null;
-  }
-  #waitRetry(milliseconds) {
-    if (this.#disposed || !this.#captureEnabled || !this.#credential) return Promise.resolve(false);
-    return new Promise((resolve) => {
-      let settled = false;
-      const finish = (value) => {
-        if (settled) return;
-        settled = true;
-        this.#retryTimer = void 0;
-        this.#retryResolve = null;
-        resolve(value);
-      };
-      this.#retryResolve = () => finish(false);
-      this.#retryTimer = this.#setTimeout(() => finish(true), milliseconds);
-    });
-  }
-  #clearBuffers() {
-    this.#ring.length = 0;
-    this.#queue.length = 0;
-    this.#quarantine.length = 0;
-    this.#ringBytes = 0;
-    this.#queueBytes = 0;
-    this.#quarantineBytes = 0;
-    this.#pendingGapCount = 0;
-    this.#pendingGapReason = "client_queue_overflow";
-  }
-};
-function takeBatch(queue, maxEvents, maxBytes) {
-  const batch = [];
-  let bytes = 0;
-  for (const event of queue) {
-    if (batch.length >= maxEvents || batch.length > 0 && bytes + event.bytes > maxBytes) break;
-    batch.push(event);
-    bytes += event.bytes;
-  }
-  return batch;
-}
-function firstCheckpoint(name) {
-  return getActionContract(name)?.checkpoints[0]?.key;
-}
-function terminalCheckpoint(name) {
-  return TERMINAL_CHECKPOINT_OVERRIDES[name] ?? requiredTerminalCheckpoint(getActionContract(name)?.checkpoints);
-}
-function requiredTerminalCheckpoint(checkpoints) {
-  if (!checkpoints) return void 0;
-  for (let index = checkpoints.length - 1; index >= 0; index -= 1) {
-    const checkpoint = checkpoints[index];
-    if (checkpoint?.class === "required") return checkpoint.key;
-  }
-  return checkpoints[checkpoints.length - 1]?.key;
-}
-function reconnectBoundary(name) {
-  return name === "participant.reconnect" || name === "sync.reconnect" || name === "recovery.sync.retry" || name === "recovery.media.retry";
-}
-function compactCorrelation(correlation) {
-  return Object.fromEntries(Object.entries(correlation).filter(([, value]) => value !== void 0));
-}
-function correlationFromInput(input) {
-  if (!input) return {};
-  return compactCorrelation({
-    journeyId: safeCorrelation(input.journeyId),
-    traceId: safeCorrelation(input.traceId),
-    spanId: safeCorrelation(input.spanId),
-    requestId: safeCorrelation(input.requestId),
-    commandId: safeCorrelation(input.commandId),
-    retryGroupRef: safeCorrelation(input.retryGroupRef),
-    attempt: typeof input.attempt === "number" && Number.isSafeInteger(input.attempt) && input.attempt >= 0 ? input.attempt : void 0,
-    providerId: input.provider?.storage === "hmac" ? safeCorrelation(input.provider.value) : void 0
-  });
-}
-function validCredential(credential, now) {
-  return validEpisodeDiagnosticCredential(credential, now);
-}
-function safeId(value) {
-  const bounded = value.replace(/[^A-Za-z0-9._:@+/=-]/gu, "_").slice(0, 128);
-  return bounded.length > 0 && /^[A-Za-z0-9]/u.test(bounded) ? bounded : `sdk_${Date.now()}`;
-}
-function safeCorrelation(value) {
-  return value && /^[A-Za-z0-9][A-Za-z0-9._:@+/=-]{0,127}$/u.test(value) ? value : void 0;
-}
-function safeReason(value) {
-  return value.replace(/[^a-z0-9_.-]/giu, "_").slice(0, 64) || "unknown";
-}
-function safeRelease(value) {
-  const id = safeCorrelation(value?.id);
-  const sourceCommit = safeCorrelation(value?.sourceCommit);
-  return id ? Object.freeze({ id, ...sourceCommit ? { sourceCommit } : {} }) : void 0;
-}
-function positive(value, fallback) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : fallback;
-}
-function normalizedBaseUrl(value) {
-  const parsed = new URL(value);
-  parsed.pathname = trimTrailingPathSlashes(parsed.pathname);
-  parsed.search = "";
-  parsed.hash = "";
-  return stripTrailingUrlSlash(parsed.toString());
-}
-function parseIntakeResponse(value, expected) {
-  const response = intakeResponse(value);
-  if (!response) return null;
-  const accepted = intakeIds(response.accepted, expected, true);
-  const duplicates = intakeIds(response.duplicates, expected, true);
-  const conflicts = intakeIds(response.conflicts, expected, false);
-  if (!accepted || !duplicates || !conflicts) return null;
-  return completeDelivery({ accepted, duplicates, conflicts }, expected);
-}
-function buildDraftInput(input, context) {
-  const contract = getActionContract(input.name);
-  const checkpoint = input.checkpoint ?? contract?.checkpoints[0]?.key;
-  const trace = parseTraceparent(context.traceparent);
-  const correlation = compactCorrelation({ journeyId: context.journeyId, traceId: trace?.traceId, spanId: trace?.spanId, ...correlationFromInput(input.correlation) });
-  return {
-    version: 1,
-    eventId: context.eventId,
-    ...eventReferences(input),
-    producerSequence: context.producerSequence,
-    occurredAt: context.occurredAt,
-    source: "sdk",
-    name: input.name,
-    phase: input.phase,
-    state: input.state,
-    expectation: expectationFor(contract, checkpoint),
-    correlation: optionalCorrelation(correlation),
-    release: context.release,
-    attributes: redactDiagnosticAttributes2(input.attributes).attributes
-  };
-}
-function eventReferences(input) {
-  return { producerOperationRef: optionalSafeId(input.operationRef), parentProducerOperationRef: optionalSafeId(input.parentOperationRef) };
-}
-function optionalSafeId(value) {
-  return value === void 0 ? void 0 : safeId(value);
-}
-function expectationFor(contract, checkpoint) {
-  const checkpointContract = contract?.checkpoints.find((candidate) => candidate.key === checkpoint);
-  return contract && checkpoint && checkpointContract ? { name: contract.operation, version: contract.expectationVersion, checkpoint, checkpointClass: checkpointContract.class } : void 0;
-}
-function optionalCorrelation(correlation) {
-  return Object.keys(correlation).length > 0 ? correlation : void 0;
-}
-function trimTrailingPathSlashes(value) {
-  return value.replace(/\/+$/u, "");
-}
-function stripTrailingUrlSlash(value) {
-  return value.endsWith("/") ? value.slice(0, -1) : value;
-}
-function intakeResponse(value) {
-  if (!isRecord3(value) || typeof value.diagnosticReference !== "string" || !Number.isSafeInteger(value.committedCursor)) return null;
-  const accepted = legacyEmptyAcknowledgement(value.accepted);
-  const duplicates = legacyEmptyAcknowledgement(value.duplicates);
-  const conflicts = legacyEmptyAcknowledgement(value.conflicts);
-  if (accepted === null || duplicates === null || conflicts === null) return null;
-  return { accepted, duplicates, conflicts };
-}
-function legacyEmptyAcknowledgement(value) {
-  if (value === null) return [];
-  return Array.isArray(value) ? value : null;
-}
-function completeDelivery(delivery, expected) {
-  const all = [...delivery.accepted, ...delivery.duplicates, ...delivery.conflicts];
-  return all.length === expected.size && new Set(all).size === expected.size ? Object.freeze(delivery) : null;
-}
-function intakeIds(items, expected, cursorRequired) {
-  const ids = [];
-  for (const item of items) {
-    if (!isRecord3(item) || typeof item.eventId !== "string" || !expected.has(item.eventId)) return null;
-    if (cursorRequired && !Number.isSafeInteger(item.cursor)) return null;
-    if (!cursorRequired && item.code !== "fingerprint_mismatch") return null;
-    ids.push(item.eventId);
-  }
-  return ids;
-}
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-// src/space-client/episode-diagnostic-registry.ts
-var connectionDiagnostics = /* @__PURE__ */ new WeakMap();
-var dependencyDiagnostics = /* @__PURE__ */ new WeakMap();
-var syncDiagnostics = /* @__PURE__ */ new WeakMap();
-function registerEpisodeDiagnosticConnection(connection, diagnostics) {
-  connectionDiagnostics.set(connection, diagnostics);
-}
-function unregisterEpisodeDiagnosticConnection(connection, diagnostics) {
-  if (diagnostics === void 0 || connectionDiagnostics.get(connection) === diagnostics) connectionDiagnostics.delete(connection);
-}
-function registerEpisodeDiagnosticDependencies(dependencies, diagnostics) {
-  dependencyDiagnostics.set(dependencies, diagnostics);
-}
-function episodeDiagnosticsForDependencies(dependencies) {
-  return dependencyDiagnostics.get(dependencies);
-}
-function unregisterEpisodeDiagnosticDependencies(dependencies, diagnostics) {
-  if (diagnostics === void 0 || dependencyDiagnostics.get(dependencies) === diagnostics) dependencyDiagnostics.delete(dependencies);
-}
-function registerEpisodeDiagnosticSyncClient(client, diagnostics) {
-  syncDiagnostics.set(client, diagnostics);
-  return client;
-}
-function unregisterEpisodeDiagnosticSyncClient(client, diagnostics) {
-  if (diagnostics === void 0 || syncDiagnostics.get(client) === diagnostics) syncDiagnostics.delete(client);
-}
-
-// src/space-client/episode-diagnostic-render-registry.ts
-var REGISTRY = /* @__PURE__ */ Symbol.for("@chalk/private/episode-diagnostic-render-registry/v1");
-var renderOwners = /* @__PURE__ */ new WeakMap();
-var completedTracksByRuntime = /* @__PURE__ */ new WeakMap();
-function registerEpisodeDiagnosticTrack(track, source, diagnostics) {
-  try {
-    if (completedTracksByRuntime.get(track)?.has(diagnostics) || renderOwners.get(track) === diagnostics) return;
-    const registry = renderRegistry();
-    let observed = false;
-    renderOwners.set(track, diagnostics);
-    registry.set(track, (observation) => {
-      if (observed) return;
-      observed = true;
-      const completed = completedTracksByRuntime.get(track) ?? /* @__PURE__ */ new WeakSet();
-      completed.add(diagnostics);
-      completedTracksByRuntime.set(track, completed);
-      const name = source === "screen" ? "screen.start" : "camera.publish";
-      if (observation === "first_frame") {
-        diagnostics.observe({ name, phase: "first_frame", state: "observed", checkpoint: source === "screen" ? "remote_first_frame" : "terminal", attributes: { direction: "remote", media_kind: source } });
-      } else {
-        diagnostics.observe({ name, phase: "not_observable", state: "not_observable", checkpoint: source === "screen" ? "remote_first_frame" : "terminal", attributes: { direction: "remote", media_kind: source, reason: "platform_render_unobservable" } });
-      }
-      registry.delete(track);
-      renderOwners.delete(track);
-    });
-  } catch {
-  }
-}
-function unregisterEpisodeDiagnosticTrack(track, diagnostics) {
-  try {
-    if (diagnostics !== void 0 && renderOwners.get(track) !== diagnostics) return;
-    renderRegistry().delete(track);
-    renderOwners.delete(track);
-  } catch {
-  }
-}
-function renderRegistry() {
-  const target = globalThis;
-  target[REGISTRY] ??= /* @__PURE__ */ new WeakMap();
-  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 Context13.Service()("@chalk/client/SpaceClientCore") {
 };
 var makeSpaceClientCoreLayer = (options, platform = {}) => {
-  const apiBaseUrl = normalizedBaseUrl2(platform.apiBaseUrl ?? options.baseUrl ?? "https://api.chalkmeet.com");
+  const apiBaseUrl = normalizedBaseUrl(platform.apiBaseUrl ?? options.baseUrl ?? "https://api.chalkmeet.com");
   const syncUrl = platform.syncUrl ?? defaultSyncUrl(apiBaseUrl);
   const baseDependencies = { ...createDefaultConnectionDependencies({ apiBaseURL: apiBaseUrl, syncURL: syncUrl, whiteboardURL: platform.whiteboardUrl }), ...platform.dependencies };
-  const episodeDiagnostics = new EpisodeDiagnosticRuntime({
-    apiBaseUrl,
-    createId: platform.randomUUID ?? baseDependencies.createId ?? (() => globalThis.crypto.randomUUID()),
-    fetch: platform.fetch,
-    now: baseDependencies.clock.now,
-    setTimeout: baseDependencies.clock.setTimeout,
-    clearTimeout: baseDependencies.clock.clearTimeout,
-    release: { id: "chalk-client@4.1.17" }
-  });
-  const diagnosticSyncClients = /* @__PURE__ */ new Set();
-  const dependencies = {
-    ...baseDependencies,
-    createSyncClient: (input) => {
-      const syncClient = baseDependencies.createSyncClient(input);
-      diagnosticSyncClients.add(syncClient);
-      return registerEpisodeDiagnosticSyncClient(syncClient, episodeDiagnostics);
-    }
-  };
-  registerEpisodeDiagnosticDependencies(dependencies, episodeDiagnostics);
-  syncClientsByDependencies.set(dependencies, diagnosticSyncClients);
+  const dependencies = baseDependencies;
   const lifecycle = makeConnectionLifecycleLayer({
-    access: (request) => resolveAccessGrant({ request, diagnostics: episodeDiagnostics, options, platform }),
+    access: async (request) => requireParsedAccessGrant(await fetchAccessGrant2({ request, options, platform })),
     apiBaseURL: apiBaseUrl,
     syncURL: syncUrl,
     syncStartupTimeoutMs: platform.syncStartupTimeoutMs,
     initialMicrophoneEnabled: platform.initialMicrophoneEnabled,
     initialCameraEnabled: platform.initialCameraEnabled,
-    telemetry: platform.telemetry,
-    recordRtcSummary: platform.recordRtcSummary,
-    recordReconnect: platform.recordReconnect,
     dependencies,
     diagnostics: {
       onEvent: (event) => {
@@ -7042,10 +5419,8 @@ var makeSpaceClientCoreLayerFromServices = (options, platform = {}) => Layer13.e
     const space = options.space.trim();
     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 apiBaseUrl = normalizedBaseUrl(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({
       offlineActionsStorage: options.offlineActionsStorage,
       offlineActionsStorageKey: `chalk:offline-actions:${JSON.stringify([apiBaseUrl, space])}`,
@@ -7054,64 +5429,28 @@ var makeSpaceClientCoreLayerFromServices = (options, platform = {}) => Layer13.e
       store,
       mediaDeviceSelection: selection,
       featureFactories: dependencies,
-      fetch: platform.fetch,
-      episodeDiagnostics
+      fetch: platform.fetch
     });
     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
-        })
-      ),
+      Effect12.sync(() => new SpaceClientCore(lifecycle, selection, store, controllers)),
       (core) => Effect12.sync(() => core.dispose())
     );
   })
 );
 var SpaceClientCore = class {
   controllers;
-  feedback;
   #connection;
   #store;
-  #episodeDiagnostics;
-  #episodeDiagnosticDependencies;
-  #episodeDiagnosticSyncClients;
-  #episodeDiagnosticTracks = /* @__PURE__ */ new Map();
   #handlers = { participantJoined: /* @__PURE__ */ new Set(), participantLeft: /* @__PURE__ */ new Set(), episodeEnded: /* @__PURE__ */ new Set(), screenShareStarted: /* @__PURE__ */ new Set(), screenShareStopped: /* @__PURE__ */ new Set(), error: /* @__PURE__ */ new Set() };
   #disposed = false;
   #episodeEnded = false;
   #previous;
   #unsubscribeConnection = null;
   #unsubscribeStore = null;
-  #leaveOperation;
-  #participantJoinOperation;
-  #syncConnectOperation;
-  constructor(connection, _selection, store, controllers, episodeDiagnostics, episodeDiagnosticDependencies, episodeDiagnosticSyncClients, feedback) {
+  constructor(connection, _selection, store, controllers) {
     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());
@@ -7122,9 +5461,7 @@ var SpaceClientCore = class {
       const newlyEnded = snapshot.episodeEnded && !this.#episodeEnded;
       this.#episodeEnded = snapshot.episodeEnded ?? false;
       if (newlyEnded) this.#emit("episodeEnded", { episode });
-      this.#publishConnectionDiagnostics();
     });
-    this.#publishConnectionDiagnostics();
   }
   getSnapshot = () => this.#store.getSnapshot();
   get changes() {
@@ -7132,49 +5469,23 @@ var SpaceClientCore = class {
   }
   subscribe = (listener) => this.#store.subscribe(listener);
   join(options = {}) {
-    this.#participantJoinOperation = this.#episodeDiagnostics?.startOperation("participant.join");
-    this.#syncConnectOperation = this.#episodeDiagnostics?.startOperation("sync.connect");
     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();
-        })
-      ),
-      Effect12.tapError(
-        () => Effect12.sync(() => {
-          this.#participantJoinOperation?.fail("join_failed");
-          this.#syncConnectOperation?.fail("connect_failed");
-        })
-      ),
-      Effect12.catchTag("ConnectionLifecycleFailure", (failure3) => Effect12.fail(failure3.code === "episode_ended" ? new SpaceClientError({ code: "episode.ended", recoverable: failure3.recoverable, message: failure3.message }) : failure3)),
+      Effect12.catchTag("ConnectionLifecycleFailure", (failure2) => Effect12.fail(failure2.code === "episode_ended" ? new SpaceClientError({ code: "episode.ended", recoverable: failure2.recoverable, message: failure2.message }) : failure2)),
       Effect12.mapError(normalizeClientError)
     );
   }
   leave() {
-    this.#leaveOperation = this.#episodeDiagnostics?.startOperation("participant.leave");
-    return this.#connection.leave().pipe(
-      Effect12.tap(() => Effect12.sync(() => this.#leaveOperation?.succeed())),
-      Effect12.tapError(() => Effect12.sync(() => this.#leaveOperation?.fail("leave_failed"))),
-      Effect12.mapError(normalizeClientError)
-    );
+    return this.#connection.leave().pipe(Effect12.mapError(normalizeClientError));
   }
   endEpisode() {
-    return trackedEffect(this.#episodeDiagnostics, "episode.end.authorized", this.#connection.runCommand(({ sync }) => foreign6(() => sync.endEpisode()).pipe(Effect12.tap(() => this.#connection.confirmEpisodeEnded))).pipe(Effect12.tap(() => this.#connection.leave()))).pipe(
-      Effect12.asVoid,
-      Effect12.mapError(normalizeClientError)
-    );
+    return this.#connection.runCommand(({ sync }) => foreign6(() => sync.endEpisode()).pipe(Effect12.tap(() => this.#connection.confirmEpisodeEnded))).pipe(Effect12.tap(() => this.#connection.leave())).pipe(Effect12.asVoid, Effect12.mapError(normalizeClientError));
   }
   extendEpisode(minutes) {
-    return trackedEffect(
-      this.#episodeDiagnostics,
-      "episode.deadline.extend",
-      this.#connection.runCommand(({ sync }) => foreign6(() => sync.extendEpisode(minutes)))
-    ).pipe(Effect12.asVoid, Effect12.mapError(normalizeClientError));
+    return this.#connection.runCommand(({ sync }) => foreign6(() => sync.extendEpisode(minutes))).pipe(Effect12.asVoid, Effect12.mapError(normalizeClientError));
   }
   on(event, handler) {
     this.#handlers[event].add(handler);
@@ -7187,32 +5498,8 @@ var SpaceClientCore = class {
     this.#unsubscribeStore?.();
     this.#unsubscribeConnection = null;
     this.#unsubscribeStore = null;
-    this.feedback.dispose();
-    this.#disposeDiagnostics();
     this.#clearHandlers();
   }
-  #disposeDiagnostics() {
-    const diagnostics = this.#episodeDiagnostics;
-    if (!diagnostics) return;
-    this.#unregisterDiagnosticSyncClients(diagnostics);
-    this.#unregisterDiagnosticTracks(diagnostics);
-    this.#unregisterDiagnosticDependencies(diagnostics);
-    unregisterEpisodeDiagnosticConnection(this.#connection, diagnostics);
-    diagnostics.dispose();
-  }
-  #unregisterDiagnosticSyncClients(diagnostics) {
-    for (const syncClient of this.#episodeDiagnosticSyncClients ?? []) unregisterEpisodeDiagnosticSyncClient(syncClient, diagnostics);
-  }
-  #unregisterDiagnosticTracks(diagnostics) {
-    for (const { track } of this.#episodeDiagnosticTracks.values()) unregisterEpisodeDiagnosticTrack(track, diagnostics);
-    this.#episodeDiagnosticTracks.clear();
-  }
-  #unregisterDiagnosticDependencies(diagnostics) {
-    const dependencies = this.#episodeDiagnosticDependencies;
-    if (!dependencies) return;
-    unregisterEpisodeDiagnosticDependencies(dependencies, diagnostics);
-    syncClientsByDependencies.delete(dependencies);
-  }
   #clearHandlers() {
     for (const handlers of Object.values(this.#handlers)) handlers.clear();
   }
@@ -7221,38 +5508,8 @@ var SpaceClientCore = class {
     const next = this.#store.getSnapshot();
     if (previous === next) return;
     this.#previous = next;
-    if (this.#episodeDiagnostics) this.#syncDiagnosticTracks(next.media.remote, this.#episodeDiagnostics);
     this.#emitChanges(previous, next);
   }
-  #syncDiagnosticTracks(remote, diagnostics) {
-    const current = diagnosticTracksFor(remote);
-    for (const [key, previousTrack] of this.#episodeDiagnosticTracks) {
-      if (sameDiagnosticTrack(current.get(key), previousTrack)) continue;
-      this.#episodeDiagnosticTracks.delete(key);
-      this.#unregisterDiagnosticTrackIfUnused(previousTrack.track, diagnostics);
-    }
-    for (const [key, currentTrack] of current) {
-      if (sameDiagnosticTrack(this.#episodeDiagnosticTracks.get(key), currentTrack)) continue;
-      registerEpisodeDiagnosticTrack(currentTrack.track, currentTrack.source, diagnostics);
-      this.#episodeDiagnosticTracks.set(key, currentTrack);
-    }
-  }
-  #unregisterDiagnosticTrackIfUnused(track, diagnostics) {
-    for (const retained of this.#episodeDiagnosticTracks.values()) if (retained.track === track) return;
-    unregisterEpisodeDiagnosticTrack(track, diagnostics);
-  }
-  #publishConnectionDiagnostics() {
-    const snapshot = this.#connection.getSnapshot();
-    if (!this.#episodeDiagnostics || snapshot.state !== "live") return;
-    if (!this.#participantJoinOperation) {
-      this.#participantJoinOperation = this.#episodeDiagnostics.startOperation("participant.join");
-      this.#participantJoinOperation?.succeed({ status: "live" });
-    }
-    if (!this.#syncConnectOperation) {
-      this.#syncConnectOperation = this.#episodeDiagnostics.startOperation("sync.connect");
-      this.#syncConnectOperation?.succeed({ status: "live" });
-    }
-  }
   #emitChanges(previous, next) {
     this.#emitParticipantChanges(previous, next);
     this.#emitScreenShareChanges(previous, next);
@@ -7299,30 +5556,6 @@ function liveClock(dependencies) {
 function foreign6(operation) {
   return Effect12.tryPromise({ try: operation, catch: (cause) => cause });
 }
-function trackedEffect(diagnostics, name, effect) {
-  const operation = diagnostics?.startOperation(name);
-  return effect.pipe(
-    Effect12.tap(() => Effect12.sync(() => operation?.succeed())),
-    Effect12.tapError(() => Effect12.sync(() => operation?.fail("operation_failed")))
-  );
-}
-async function resolveAccessGrant(input) {
-  const { operationName: operationName2, reason } = diagnosticAccessOperation(input.request);
-  const operationBeforeRotation = input.diagnostics.activeContext() ? input.diagnostics.startOperation(operationName2, { reason }) : void 0;
-  try {
-    const grant = await requireParsedAccessGrant(await fetchAccessGrant2(input));
-    input.diagnostics.rotateCredential(grant.diagnostics ?? null);
-    (operationBeforeRotation ?? input.diagnostics.startOperation(operationName2, { reason }))?.succeed({ result: "bound" });
-    return grant;
-  } catch (cause) {
-    operationBeforeRotation?.fail("access_failed");
-    throw cause;
-  }
-}
-function diagnosticAccessOperation(request) {
-  const reason = request?.reason ?? "join";
-  return { operationName: reason === "join" ? "access.request" : "access.refresh", reason };
-}
 async function fetchAccessGrant2(input) {
   if (input.platform.connectionAccess) return input.platform.connectionAccess(input.request);
   return input.options.getAccess({ space: input.options.space.trim(), reason: accessReason(input.request?.reason), replaceMediaConnection: input.request?.replaceMediaConnection ?? false, signal: input.request?.signal });
@@ -7332,7 +5565,7 @@ function accessReason(reason) {
   if (reason === "scheduled_refresh") return "refresh";
   return "retry";
 }
-function normalizedBaseUrl2(value) {
+function normalizedBaseUrl(value) {
   const url = new URL(value);
   url.pathname = url.pathname.replace(/\/+$/u, "");
   url.search = "";
@@ -7343,6 +5576,7 @@ function defaultSyncUrl(apiBaseUrl) {
   const url = new URL(apiBaseUrl);
   url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
   if (url.hostname.startsWith("api.")) url.hostname = `sync.${url.hostname.slice(4)}`;
+  else if (url.hostname.endsWith(".chalkmeet.com")) url.hostname = url.hostname.replace(/^([^.]+-)api\./u, "$1sync.");
   url.pathname = "/v1/sync";
   return url.toString();
 }
@@ -7351,17 +5585,6 @@ function screenShares(snapshot) {
   if (snapshot.media.screenShare.state === "enabled" && snapshot.self.participantId) participants.add(snapshot.self.participantId);
   return participants;
 }
-function diagnosticTracksFor(remote) {
-  const tracks = /* @__PURE__ */ new Map();
-  for (const publication of remote) {
-    if (publication.source !== "camera" && publication.source !== "screen") continue;
-    tracks.set(`${publication.participantId}:${publication.source}:${publication.publicationId}`, { track: publication.track, source: publication.source });
-  }
-  return tracks;
-}
-function sameDiagnosticTrack(left, right) {
-  return left?.track === right.track && left?.source === right.source;
-}
 
 // src/space-client/space-client.ts
 import { Effect as Effect14, ManagedRuntime } from "effect";
@@ -7382,7 +5605,6 @@ function toPromiseController(runtime, controller) {
 
 // src/space-client/space-client.ts
 var PromiseSpaceClient = class {
-  feedback;
   media;
   chat;
   participants;
@@ -7397,7 +5619,6 @@ var PromiseSpaceClient = class {
     this.#runtime = ManagedRuntime.make(makeSpaceClientCoreLayer(options, platform));
     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, resolveUrl, ...chatCommands } = chat;
@@ -7439,11 +5660,12 @@ export {
   makeConnectionPlatformLayer,
   makeFakeConnectionPlatformLayer,
   ChalkWhiteboardV1Error,
+  CHALK_REACTIONS,
   CHALK_CHAT_ATTACHMENT_LIMITS,
   CHALK_CHAT_ATTACHMENT_MIME_TYPES,
   ChalkChatFileError,
   createChalkChatFileHttpTransport,
-  createChalkWhiteboardV1FileHttpTransport,
+  createChalkWhiteboardV1FileDownloadTransport,
   encodeWhiteboardV1ClientFrame,
   decodeWhiteboardV1ServerFrame,
   InMemoryChalkWhiteboardV1PendingOperationStore,
@@ -7457,35 +5679,6 @@ 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,