@q9labsai/chalk-client 4.0.0

package/dist/chunk-5VXGLI3T.js

@@ -0,0 +1,3385 @@
+import {
+  syncTelemetryCorrelation
+} from "./chunk-PBSYXPNJ.js";
+
+// src/sync/canonical.ts
+var encoder = new TextEncoder();
+function canonicalJson(value) {
+  return serialize(value);
+}
+function canonicalJsonBytes(value) {
+  return canonicalJsonBytesFromUnknown(value);
+}
+function canonicalJsonBytesFromUnknown(value) {
+  return encoder.encode(serialize(value));
+}
+function serialize(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return `[${value.map(serialize).join(",")}]`;
+  if (typeof value === "object") return serializeObject(value);
+  return serializeScalar(value);
+}
+function serializeScalar(value) {
+  switch (typeof value) {
+    case "string":
+      return serializeString(value);
+    case "number":
+      return serializeNumber(value);
+    case "boolean":
+      return JSON.stringify(value);
+    default:
+      throw new TypeError("canonical JSON only supports JSON values");
+  }
+}
+function serializeString(value) {
+  assertWellFormedUnicode(value);
+  return JSON.stringify(value);
+}
+function serializeNumber(value) {
+  if (!Number.isFinite(value)) {
+    throw new TypeError("canonical JSON does not support non-finite numbers");
+  }
+  return JSON.stringify(value);
+}
+function serializeObject(value) {
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) throw new TypeError("canonical JSON only supports plain objects");
+  const keys = Object.keys(value).sort(compareUnicodeCodeUnits);
+  return `{${keys.map((key) => `${serialize(key)}:${serialize(Reflect.get(value, key))}`).join(",")}}`;
+}
+function compareUnicodeCodeUnits(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function assertWellFormedUnicode(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (!isSurrogate(code)) {
+      continue;
+    }
+    const next = value.charCodeAt(index + 1);
+    if (isSurrogatePair(code, next)) {
+      index += 1;
+      continue;
+    }
+    throw new TypeError("canonical JSON does not support unpaired UTF-16 surrogates");
+  }
+}
+function isSurrogate(code) {
+  return code >= 55296 && code <= 57343;
+}
+function isSurrogatePair(code, next) {
+  return code <= 56319 && next >= 56320 && next <= 57343;
+}
+
+// src/sync/errors.ts
+var SyncBrowserCapabilityError = class extends Error {
+  _tag = "SyncBrowserCapabilityError";
+  constructor(capability) {
+    super(`${capability} is unavailable in this runtime`);
+    this.name = "SyncBrowserCapabilityError";
+  }
+};
+var SyncReactNativeCapabilityError = class extends Error {
+  _tag = "SyncReactNativeCapabilityError";
+  constructor(capability) {
+    super(`React Native ${capability} is unavailable in this runtime`);
+    this.name = "SyncReactNativeCapabilityError";
+  }
+};
+
+// src/sync/browser.ts
+function createBrowserWebSocketFactory(WebSocketConstructor) {
+  return {
+    connect(url) {
+      const Constructor = WebSocketConstructor ?? globalThis.WebSocket;
+      if (!Constructor) {
+        throw new SyncBrowserCapabilityError("WebSocket");
+      }
+      return new BrowserSyncSocket(new Constructor(url));
+    }
+  };
+}
+function createBrowserSyncLifecycle(environment = browserLifecycleEnvironment()) {
+  return {
+    subscribe(listener) {
+      const online = () => listener("online");
+      const offline = () => listener("offline");
+      environment.window.addEventListener("online", online);
+      environment.window.addEventListener("offline", offline);
+      listener(environment.navigator?.onLine ?? true ? "online" : "offline");
+      return () => {
+        environment.window.removeEventListener("online", online);
+        environment.window.removeEventListener("offline", offline);
+      };
+    }
+  };
+}
+var BrowserSyncSocket = class {
+  #socket;
+  onopen = null;
+  onmessage = null;
+  onclose = null;
+  onerror = null;
+  constructor(socket) {
+    this.#socket = socket;
+    this.#socket.addEventListener("open", () => this.onopen?.());
+    this.#socket.addEventListener("message", (event) => this.onmessage?.({ data: event.data }));
+    this.#socket.addEventListener("close", (event) => this.onclose?.({ code: event.code }));
+    this.#socket.addEventListener("error", () => this.onerror?.());
+  }
+  send(data) {
+    this.#socket.send(data);
+  }
+  close(code, reason) {
+    this.#socket.close(code, reason);
+  }
+};
+function browserLifecycleEnvironment() {
+  if (typeof globalThis.window === "undefined" || typeof globalThis.navigator === "undefined") {
+    throw new SyncBrowserCapabilityError("browser lifecycle");
+  }
+  return { window: globalThis.window, navigator: globalThis.navigator };
+}
+
+// src/sync/react-native.ts
+function createReactNativeWebSocketFactory(WebSocketConstructor) {
+  return {
+    connect(url) {
+      if (WebSocketConstructor) {
+        return new ReactNativeSyncSocket(new WebSocketConstructor(url));
+      }
+      if (!globalThis.WebSocket) {
+        throw new SyncReactNativeCapabilityError("WebSocket");
+      }
+      return new BrowserFallbackSyncSocket(new globalThis.WebSocket(url));
+    }
+  };
+}
+function createReactNativeSyncLifecycle(environment) {
+  return {
+    subscribe(listener) {
+      const appState = environment.appState.addEventListener("change", (state) => listener(state === "active" ? "active" : "inactive"));
+      const network = environment.networkInfo?.addEventListener((state) => listener(isNetworkOnline(state) ? "online" : "offline"));
+      listener(environment.appState.currentState === "active" ? "active" : "inactive");
+      return () => {
+        unsubscribe(appState);
+        if (network) {
+          unsubscribe(network);
+        }
+      };
+    }
+  };
+}
+var ReactNativeSyncSocket = class {
+  #socket;
+  onopen = null;
+  onmessage = null;
+  onclose = null;
+  onerror = null;
+  constructor(socket) {
+    this.#socket = socket;
+    this.#socket.onopen = () => this.onopen?.();
+    this.#socket.onmessage = (event) => this.onmessage?.({ data: event.data });
+    this.#socket.onclose = (event) => this.onclose?.({ code: typeof event.code === "number" ? event.code : 1006 });
+    this.#socket.onerror = () => this.onerror?.();
+  }
+  send(data) {
+    this.#socket.send(data);
+  }
+  close(code, reason) {
+    this.#socket.close(code, reason);
+  }
+};
+var BrowserFallbackSyncSocket = class {
+  #socket;
+  onopen = null;
+  onmessage = null;
+  onclose = null;
+  onerror = null;
+  constructor(socket) {
+    this.#socket = socket;
+    this.#socket.addEventListener("open", () => this.onopen?.());
+    this.#socket.addEventListener("message", (event) => this.onmessage?.({ data: event.data }));
+    this.#socket.addEventListener("close", (event) => this.onclose?.({ code: event.code }));
+    this.#socket.addEventListener("error", () => this.onerror?.());
+  }
+  send(data) {
+    this.#socket.send(data);
+  }
+  close(code, reason) {
+    this.#socket.close(code, reason);
+  }
+};
+function isNetworkOnline(state) {
+  return state.isConnected !== false && state.isInternetReachable !== false;
+}
+function unsubscribe(subscription) {
+  if (typeof subscription === "function") {
+    subscription();
+  } else {
+    subscription.remove();
+  }
+}
+
+// src/generated/sync.ts
+import { Schema } from "effect";
+var SyncProtocolMetadata = {
+  version: 1,
+  protocol: {
+    field: "protocol",
+    value: 1,
+    transport: "websocket-json-text",
+    route: "/v1/sync"
+  },
+  directions: {
+    clientToServer: "client-to-server",
+    serverToClient: "server-to-client"
+  },
+  phases: [
+    {
+      id: "awaiting_hello",
+      accepts: ["hello", "ping"],
+      hello: {
+        transitionsTo: "recovering",
+        deadlineMs: 5e3
+      }
+    },
+    {
+      id: "recovering",
+      accepts: ["recovery_ack", "ping"],
+      recoveryComplete: {
+        transitionsTo: "live"
+      }
+    },
+    {
+      id: "live",
+      accepts: ["command", "live_target", "directed_request", "delivery_ack", "request_ack", "reaction_send", "chat_send", "chat_page_request", "chat_read_set", "ping"],
+      heartbeat: {
+        intervalMs: 2e4,
+        missedDeadlinesBeforeClose: 2
+      }
+    },
+    {
+      id: "terminal",
+      transitionsTo: "closed"
+    },
+    {
+      id: "draining",
+      transitionsTo: "closed"
+    }
+  ],
+  streams: {
+    control: {
+      required: true,
+      authority: "postgres",
+      version: "revision-and-digest",
+      cursor: "controlCursor",
+      recovery: ["snapshot", "bounded_exact_replay", "up_to_date", "terminal"]
+    },
+    media: {
+      required: true,
+      authority: "media-plane-observation",
+      version: "projection-id-and-exact-next-sequence",
+      cursor: null,
+      recovery: ["replace_latest_snapshot"]
+    },
+    presence: {
+      required: true,
+      authority: "sync-live-projection",
+      version: "projection-id-and-exact-next-sequence",
+      cursor: null,
+      recovery: ["replace_latest_snapshot"]
+    },
+    requests: {
+      required: true,
+      authority: "directed-live-delivery",
+      version: "none",
+      cursor: null,
+      recovery: ["none"]
+    }
+  },
+  correlation: {
+    optionalTopLevelFields: {
+      journey_id: {
+        kind: "string",
+        minBytes: 36,
+        maxBytes: 36,
+        format: "chalk-journey-id",
+        pattern: "^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
+      },
+      traceparent: {
+        kind: "string",
+        minBytes: 55,
+        maxBytes: 55,
+        format: "w3c-traceparent",
+        pattern: "^00-[0-9a-f]{32}-[0-9a-f]{16}-[0-9a-f]{2}$"
+      },
+      tracestate: {
+        kind: "string",
+        minBytes: 1,
+        maxBytes: 512,
+        format: "w3c-tracestate",
+        pattern: "^[a-z][a-z0-9_*\\-/]{0,255}=[\\x21-\\x2b\\x2d-\\x3c\\x3e-\\x7e]{1,256}(,[a-z][a-z0-9_*\\-/]{0,255}=[\\x21-\\x2b\\x2d-\\x3c\\x3e-\\x7e]{1,256})*$"
+      }
+    },
+    acceptedOn: {
+      hello: "client-to-server",
+      serverFrames: "server-to-client"
+    },
+    upgradeHeaders: ["x-chalk-journey-id", "traceparent", "tracestate"],
+    rule: "propagate_from_first_observed_layer_to_every_downstream_frame"
+  },
+  externalIntents: [
+    "admit_participant",
+    "deny_admission",
+    "admission_request_expired",
+    "mute_participant",
+    "stop_participant_camera",
+    "stop_participant_screen_share",
+    "remove_participant",
+    "start_recording",
+    "stop_recording",
+    "participant_leave",
+    "start_episode",
+    "extend_episode",
+    "end_episode",
+    "tenant_set_deadline",
+    "tenant_end_episode",
+    "maximum_duration_expired"
+  ],
+  limits: {
+    decodedInboundFrameBytes: 65536,
+    correlationReservedBytes: 1160,
+    tokenBytes: 8192,
+    commandIdMinBytes: 16,
+    commandIdMaxBytes: 64,
+    requestIdMinBytes: 16,
+    requestIdMaxBytes: 64,
+    decodedCommandPayloadBytes: 16384,
+    encodedLiveEventBytes: 32768,
+    replayPageMaxEvents: 128,
+    replayPageEncodedBytes: 262144,
+    completeReplayMaxEvents: 2048,
+    completeReplayEncodedBytes: 2097152,
+    snapshotEncodedBytes: 1048576,
+    projectionSnapshotEncodedBytes: 1048576,
+    projectionMaxItems: 1500,
+    directedRequestTtlMs: 3e4,
+    directedRequestsPerActorTarget: 4,
+    collaborationFrameBytes: 32768,
+    collaborationQueueMaxFrames: 256,
+    collaborationBurstMax: 8,
+    chatMessageUtf8Bytes: 16384,
+    chatMessageUnicodeScalars: 4e3,
+    chatAttachmentMaxItems: 5,
+    chatAttachmentFileNameUtf8Bytes: 255,
+    chatAttachmentMaxBytes: 26214400,
+    chatPageMaxMessages: 100,
+    chatPageEncodedBytes: 131072,
+    reactionTtlMs: 5e3,
+    reactionRateWindowMs: 1e4,
+    reactionRateMax: 10,
+    protocolErrorDetailBytes: 1024
+  },
+  collaboration: {
+    extension: "collaboration_v1",
+    capabilities: ["sendReaction", "sendChat"],
+    reactions: ["\u{1F44D}", "\u2764\uFE0F", "\u{1F602}", "\u{1F62E}", "\u{1F622}", "\u{1F389}"],
+    attachmentMimeTypes: [
+      "image/png",
+      "image/jpeg",
+      "image/gif",
+      "image/webp",
+      "application/pdf",
+      "text/plain",
+      "application/msword",
+      "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      "application/vnd.ms-excel",
+      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      "application/vnd.ms-powerpoint",
+      "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+      "application/vnd.oasis.opendocument.text",
+      "application/vnd.oasis.opendocument.spreadsheet",
+      "application/vnd.oasis.opendocument.presentation"
+    ],
+    chatCursor: {
+      exactFields: ["after_sequence", "retained_floor_sequence"],
+      afterSequence: "nullableUnsignedDecimal",
+      retainedFloorSequence: "nullableUnsignedDecimal"
+    },
+    helloExtension: {
+      exactFields: ["name", "chat_cursor"]
+    },
+    welcomeExtension: {
+      exactFields: ["name", "capabilities", "participant_capabilities", "chat_head_sequence", "retained_floor_sequence", "read_receipts"]
+    },
+    clientFrames: {
+      sendReaction: {
+        type: "reaction_send",
+        exactFields: ["type", "operation_id", "reaction"]
+      },
+      sendChat: {
+        type: "chat_send",
+        exactFields: ["type", "client_message_id", "text", "attachment_ids"]
+      },
+      readChatPage: {
+        type: "chat_page_request",
+        exactFields: ["type", "request_id", "direction", "cursor_sequence", "limit"],
+        directions: ["older", "newer"]
+      },
+      setChatRead: {
+        type: "chat_read_set",
+        exactFields: ["type", "request_id", "sequence"]
+      }
+    },
+    serverFrames: {
+      reaction: {
+        type: "reaction",
+        exactFields: ["type", "event_id", "participant_id", "display_name", "reaction", "occurred_at", "expires_at"]
+      },
+      reactionResult: {
+        type: "reaction_result",
+        acceptedFields: ["type", "operation_id", "outcome", "reaction"],
+        rejectedFields: ["type", "operation_id", "outcome", "error_code"],
+        outcomes: ["accepted", "rejected"]
+      },
+      chatMessage: {
+        type: "chat_message",
+        exactFields: ["type", "message_id", "client_message_id", "sequence", "participant_id", "display_name", "text", "attachments", "created_at"]
+      },
+      chatSendResult: {
+        type: "chat_send_result",
+        acceptedFields: ["type", "client_message_id", "outcome", "message"],
+        rejectedFields: ["type", "client_message_id", "outcome", "error_code"],
+        outcomes: ["accepted", "rejected"]
+      },
+      chatPage: {
+        type: "chat_page",
+        loadedFields: ["type", "request_id", "outcome", "messages", "has_more", "head_sequence", "retained_floor_sequence"],
+        resetFields: ["type", "request_id", "outcome", "retained_floor_sequence"],
+        outcomes: ["loaded", "cursor_reset"]
+      },
+      chatHead: {
+        type: "chat_head",
+        exactFields: ["type", "head_sequence", "retained_floor_sequence"]
+      },
+      chatReadReceipt: {
+        type: "chat_read_receipt",
+        exactFields: ["type", "participant_id", "participant_generation", "sequence", "read_at"]
+      },
+      chatReadResult: {
+        type: "chat_read_result",
+        acceptedFields: ["type", "request_id", "outcome", "participant_id", "participant_generation", "sequence", "read_at"],
+        rejectedFields: ["type", "request_id", "outcome", "error_code"],
+        outcomes: ["accepted", "rejected"]
+      }
+    },
+    errorCodes: ["capability_denied", "invalid_payload", "rate_limited", "overloaded", "episode_ended", "participant_stale", "client_message_id_conflict", "attachment_not_found", "attachment_not_ready", "attachment_already_claimed", "attachment_quota_exceeded", "dependency_unavailable"]
+  },
+  continuity: {
+    cursor: {
+      field: "streams.control.cursor",
+      resume: "events_after_cursor_when_digest_matches",
+      stream: "control"
+    },
+    events: {
+      baseRevisionField: "base_revision",
+      revisionField: "revision",
+      rule: "revision_equals_base_revision_plus_one",
+      stream: "control"
+    },
+    snapshotFallback: {
+      when: ["cursor_missing", "cursor_future", "cursor_malformed", "cursor_expired", "cursor_unavailable", "cursor_same_revision_digest_mismatch"],
+      welcomeMode: "snapshot"
+    },
+    replay: {
+      pageAcknowledgement: "recovery_ack",
+      pageCompletion: "recovery_complete_after_acknowledged_head",
+      liveEventsAfter: "recovery_complete",
+      maxEvents: 2048,
+      maxEncodedBytes: 2097152
+    }
+  },
+  idempotency: {
+    key: "command_id",
+    outcomes: ["committed", "satisfied", "rejected"],
+    scope: "participant",
+    duplicate: "reuses_original_semantic_outcome",
+    conflict: "preserves_original_receipt"
+  },
+  closeCodes: [
+    {
+      code: 1e3,
+      connection: "closed",
+      reasons: ["terminal event acknowledged", "terminal recovery drained"]
+    },
+    {
+      code: 1008,
+      connection: "closed",
+      reasons: ["invalid token", "policy violation"]
+    },
+    {
+      code: 1009,
+      connection: "closed",
+      reasons: ["malformed frame", "oversized frame"]
+    },
+    {
+      code: 1012,
+      connection: "closed",
+      reasons: ["service restart", "server draining", "terminal acknowledgement timeout"]
+    }
+  ]
+};
+var SyncProtocolLimits = SyncProtocolMetadata.limits;
+var SyncCloseCodes = SyncProtocolMetadata.closeCodes;
+var textEncoder = new TextEncoder();
+function encodedSyncFrameBytes(frame) {
+  return textEncoder.encode(JSON.stringify(frame)).byteLength;
+}
+function boundedUtf8String(maxBytes, minBytes = 0) {
+  return Schema.String.check(
+    Schema.makeFilter((value) => {
+      const bytes = textEncoder.encode(value).byteLength;
+      return bytes >= minBytes && bytes <= maxBytes ? void 0 : { path: [], issue: "must fit the UTF-8 byte bounds" };
+    })
+  );
+}
+function boundedFrame(maxBytes) {
+  return Schema.makeFilter((frame) => encodedSyncFrameBytes(frame) <= maxBytes ? void 0 : { path: [], issue: "must fit the encoded byte limit" });
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function exactObject(value, keys) {
+  return isObject(value) && Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+}
+var syncCorrelationKeys = ["journey_id", "traceparent", "tracestate"];
+function completeSyncCorrelation(value) {
+  return isObject(value) && syncCorrelationKeys.every((key) => Object.hasOwn(value, key));
+}
+function boundedServerFrame(maxBytes) {
+  return Schema.makeFilter((frame) => {
+    const budget = completeSyncCorrelation(frame) ? maxBytes : maxBytes - SyncProtocolLimits.correlationReservedBytes;
+    return encodedSyncFrameBytes(frame) <= budget ? void 0 : { path: [], issue: "must fit the encoded byte limit including correlation reserve" };
+  });
+}
+var syncJourneyIdPattern = new RegExp("^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$", "iu");
+var syncTraceparentPattern = new RegExp("^00-[0-9a-f]{32}-[0-9a-f]{16}-[0-9a-f]{2}$", "u");
+var syncTracestatePattern = new RegExp("^[a-z][a-z0-9_*\\-/]{0,255}=[\\x21-\\x2b\\x2d-\\x3c\\x3e-\\x7e]{1,256}(,[a-z][a-z0-9_*\\-/]{0,255}=[\\x21-\\x2b\\x2d-\\x3c\\x3e-\\x7e]{1,256})*$", "u");
+function boundedCorrelationString(value, minBytes, maxBytes) {
+  return typeof value === "string" && textEncoder.encode(value).byteLength >= minBytes && textEncoder.encode(value).byteLength <= maxBytes;
+}
+function validSyncCorrelation(value) {
+  if (!isObject(value)) return false;
+  const journeyId = value.journey_id;
+  const traceparent = value.traceparent;
+  const tracestate = value.tracestate;
+  return (journeyId === void 0 || boundedCorrelationString(journeyId, 36, 36) && syncJourneyIdPattern.test(journeyId) && !/^0{8}-0{4}-0{4}-0{4}-0{12}$/u.test(journeyId)) && (traceparent === void 0 || boundedCorrelationString(traceparent, 55, 55) && syncTraceparentPattern.test(traceparent) && !/^00-0{32}-[0-9a-f]{16}-[0-9a-f]{2}$/u.test(traceparent) && !/^00-[0-9a-f]{32}-0{16}-[0-9a-f]{2}$/u.test(traceparent)) && (tracestate === void 0 || boundedCorrelationString(tracestate, 1, 512) && syncTracestatePattern.test(tracestate));
+}
+function exactObjectWithCorrelation(value, keys) {
+  return validSyncCorrelation(value) && isObject(value) && Object.keys(value).length >= keys.length && keys.every((key) => Object.hasOwn(value, key)) && Object.keys(value).every((key) => keys.includes(key) || syncCorrelationKeys.includes(key));
+}
+function serverExactKeys(keys) {
+  return Schema.makeFilter((value) => exactObjectWithCorrelation(value, keys) ? void 0 : { path: [], issue: "must not contain unknown or missing fields" });
+}
+function exactKeys(keys) {
+  return Schema.makeFilter((value) => exactObject(value, keys) ? void 0 : { path: [], issue: "must not contain unknown or missing fields" });
+}
+function uniqueStrings(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string") && new Set(value).size === value.length;
+}
+function sameStrings(left, right) {
+  return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function strictCursor(value) {
+  return exactObject(value, ["revision", "state_schema_version", "state_digest"]);
+}
+function strictCommand(value) {
+  if (!exactObject(value, ["type", "command_id", "name", "payload"]) || !isObject(value.payload)) return false;
+  switch (value.name) {
+    case "set_hand_raised":
+      return exactObject(value.payload, ["raised"]);
+    case "set_display_name":
+      return exactObject(value.payload, ["display_name"]);
+    case "set_admission_policy":
+      return exactObject(value.payload, ["policy"]);
+    case "assign_roles":
+      return exactObject(value.payload, ["participant_id", "role"]);
+    default:
+      return false;
+  }
+}
+function strictCollaborationsHelloExtension(value) {
+  return exactObject(value, ["name", "chat_cursor"]) && value.name === "collaboration_v1" && exactObject(value.chat_cursor, ["after_sequence", "retained_floor_sequence"]);
+}
+function strictHello(value) {
+  const base = exactObjectWithCorrelation(value, ["type", "protocol", "token", "streams"]);
+  const extended = exactObjectWithCorrelation(value, ["type", "protocol", "token", "streams", "extensions"]) && Array.isArray(value.extensions) && value.extensions.length === 1 && strictCollaborationsHelloExtension(value.extensions[0]);
+  if (!base && !extended || !exactObject(value.streams, ["control", "media", "presence", "requests"])) return false;
+  const streams = value.streams;
+  return exactObject(streams.control, ["cursor"]) && (streams.control.cursor === null || strictCursor(streams.control.cursor)) && exactObject(streams.media, ["cursor"]) && streams.media.cursor === null && exactObject(streams.presence, ["cursor"]) && streams.presence.cursor === null && exactObject(streams.requests, ["cursor"]) && streams.requests.cursor === null;
+}
+function strictChatMessage(value) {
+  return exactObjectWithCorrelation(value, ["type", "message_id", "client_message_id", "sequence", "participant_id", "display_name", "text", "attachments", "created_at"]) && Array.isArray(value.attachments) && value.attachments.every(strictChatAttachment);
+}
+function strictChatAttachment(value) {
+  return exactObject(value, ["attachment_id", "file_name", "mime_type", "byte_length"]);
+}
+function strictReaction(value) {
+  return exactObjectWithCorrelation(value, ["type", "event_id", "participant_id", "display_name", "reaction", "occurred_at", "expires_at"]);
+}
+function strictOperation(value) {
+  if (!exactObject(value, ["type", "command_id", "name", "payload"]) || !isObject(value.payload)) return false;
+  switch (value.name) {
+    case "admit_participant":
+      return exactObject(value.payload, ["admission_request_id"]);
+    case "deny_admission":
+      return exactObject(value.payload, ["admission_request_id"]);
+    case "mute_participant":
+      return exactObject(value.payload, ["participant_id"]);
+    case "stop_participant_camera":
+      return exactObject(value.payload, ["participant_id"]);
+    case "stop_participant_screen_share":
+      return exactObject(value.payload, ["participant_id"]);
+    case "remove_participant":
+      return exactObject(value.payload, ["participant_id"]);
+    case "start_recording":
+      return exactObject(value.payload, ["recording_id"]);
+    case "stop_recording":
+      return exactObject(value.payload, ["recording_id"]);
+    case "participant_leave":
+      return exactObject(value.payload, []);
+    case "start_episode":
+      return exactObject(value.payload, []);
+    case "extend_episode":
+      return exactObject(value.payload, ["extension_seconds"]);
+    case "end_episode":
+      return exactObject(value.payload, []);
+    default:
+      return false;
+  }
+}
+function strictClientFrame(value) {
+  if (!isObject(value)) return false;
+  switch (value.type) {
+    case "hello":
+      return strictHello(value);
+    case "command":
+      return strictCommand(value);
+    case "operation":
+      return strictOperation(value);
+    case "live_target":
+      return exactObject(value, ["type", "operation_id", "name", "enabled"]);
+    case "directed_request":
+      return exactObject(value, ["type", "request_id", "name", "target_participant_id"]);
+    case "request_ack":
+      return exactObject(value, ["type", "request_id"]);
+    case "reaction_send":
+      return exactObject(value, ["type", "operation_id", "reaction"]);
+    case "chat_send":
+      return exactObject(value, ["type", "client_message_id", "text", "attachment_ids"]);
+    case "chat_page_request":
+      return exactObject(value, ["type", "request_id", "direction", "cursor_sequence", "limit"]);
+    case "chat_read_set":
+      return exactObject(value, ["type", "request_id", "sequence"]);
+    case "delivery_ack":
+      return exactObject(value, ["type", "stream", "revision", "state_digest"]);
+    case "recovery_ack":
+      return exactObject(value, ["type", "recovery_id", "revision", "state_digest"]);
+    case "ping":
+      return exactObject(value, ["type"]);
+    default:
+      return false;
+  }
+}
+function strictSnapshot(value) {
+  if (!exactObject(value, ["control_revision", "state_schema_version", "state_digest", "status", "admission_policy", "deadline_at_ms", "deadline_generation", "role_capabilities", "recording", "participants", "admission_requests"]) || !isObject(value.role_capabilities) || value.recording !== null && !exactObject(value.recording, ["recording_id", "status", "failure_code"]) || !Array.isArray(value.participants) || !value.participants.every((participant) => exactObject(participant, ["participant_id", "display_name", "hand_raised", "admission_revision", "role", "capabilities"])) || !Array.isArray(value.admission_requests) || !value.admission_requests.every((request) => exactObject(request, ["admission_request_id", "participant_id", "display_name", "role", "expires_at_ms"])))
+    return false;
+  const roleCapabilities = value.role_capabilities;
+  if (!isObject(roleCapabilities) || Object.keys(roleCapabilities).length === 0 || !Object.values(roleCapabilities).every((capabilities) => Array.isArray(capabilities) && uniqueStrings(capabilities) && capabilities.length <= 23)) return false;
+  if (value.recording !== null && value.recording.status === "failed" !== (value.recording.failure_code !== null)) return false;
+  const participantIds = /* @__PURE__ */ new Set();
+  for (const participant of value.participants) {
+    if (typeof participant.role !== "string" || participantIds.has(participant.participant_id) || !sameStrings(participant.capabilities, roleCapabilities[participant.role])) return false;
+    participantIds.add(participant.participant_id);
+  }
+  const requestIds = /* @__PURE__ */ new Set();
+  const candidateIds = /* @__PURE__ */ new Set();
+  for (const request of value.admission_requests) {
+    if (typeof request.role !== "string" || !Object.prototype.hasOwnProperty.call(roleCapabilities, request.role) || requestIds.has(request.admission_request_id) || candidateIds.has(request.participant_id) || participantIds.has(request.participant_id)) return false;
+    requestIds.add(request.admission_request_id);
+    candidateIds.add(request.participant_id);
+  }
+  if (value.status === "ended") return value.participants.length === 0 && value.admission_requests.length === 0 && value.recording === null;
+  return true;
+}
+function strictEvent(value) {
+  if (!isObject(value.payload)) return false;
+  const common = ["type", "stream", "name", "event_id", "base_revision", "revision", "schema_version", "resulting_state_digest", "payload"];
+  switch (value.name) {
+    case "participant_joined":
+      return exactObject(value.payload, ["participant_id", "display_name", "role", "admission_revision"]) && exactObjectWithCorrelation(value, [...common, "lifecycle_intent_id"]);
+    case "participant_left":
+      return exactObject(value.payload, ["participant_id", "reason"]) && exactObjectWithCorrelation(value, [...common, "external_operation_id"]);
+    case "episode_started":
+      return exactObject(value.payload, ["episode_id"]) && exactObjectWithCorrelation(value, [...common, "lifecycle_intent_id"]);
+    case "episode_ended":
+      return exactObject(value.payload, ["reason"]) && exactObjectWithCorrelation(value, [...common, "external_operation_id"]);
+    case "hand_raised":
+      return exactObject(value.payload, ["participant_id"]) && exactObjectWithCorrelation(value, [...common, "command_id"]);
+    case "hand_lowered":
+      return exactObject(value.payload, ["participant_id"]) && exactObjectWithCorrelation(value, [...common, "command_id"]);
+    case "participant_display_name_changed":
+      return exactObject(value.payload, ["participant_id", "display_name"]) && exactObjectWithCorrelation(value, [...common, "command_id"]);
+    case "admission_policy_changed":
+      return exactObject(value.payload, ["policy"]) && exactObjectWithCorrelation(value, [...common, "command_id"]);
+    case "role_assigned":
+      return exactObject(value.payload, ["participant_id", "role"]) && exactObjectWithCorrelation(value, [...common, "command_id"]);
+    case "deadline_changed":
+      return exactObject(value.payload, ["deadline_at_ms", "deadline_generation"]) && exactObjectWithCorrelation(value, [...common, "external_operation_id"]);
+    case "admission_requested":
+      return exactObject(value.payload, ["admission_request_id", "participant_id", "display_name", "role", "expires_at_ms"]) && exactObjectWithCorrelation(value, [...common, "lifecycle_intent_id"]);
+    case "admission_denied":
+      return exactObject(value.payload, ["admission_request_id"]) && exactObjectWithCorrelation(value, [...common, "external_operation_id"]);
+    case "admission_expired":
+      return exactObject(value.payload, ["admission_request_id"]) && exactObjectWithCorrelation(value, [...common, "external_operation_id"]);
+    case "participant_microphone_stopped":
+      return exactObject(value.payload, ["participant_id"]) && exactObjectWithCorrelation(value, [...common, "external_operation_id"]);
+    case "participant_camera_stopped":
+      return exactObject(value.payload, ["participant_id"]) && exactObjectWithCorrelation(value, [...common, "external_operation_id"]);
+    case "participant_screen_share_stopped":
+      return exactObject(value.payload, ["participant_id"]) && exactObjectWithCorrelation(value, [...common, "external_operation_id"]);
+    case "recording_status_changed":
+      return exactObject(value.payload, ["recording_id", "status", "failure_code"]) && exactObjectWithCorrelation(value, [...common, "external_operation_id"]);
+    default:
+      return false;
+  }
+}
+function strictProjectionItem(value, stream) {
+  if (stream === "media") return exactObject(value, ["participant_id", "source", "enabled", "publication_id"]);
+  if (stream === "presence") return exactObject(value, ["participant_id", "state", "speaking", "active_speaker"]);
+  return false;
+}
+function strictProjection(value) {
+  if (value.type === "projection_snapshot") return exactObjectWithCorrelation(value, ["type", "stream", "projection_id", "sequence", "items"]) && Array.isArray(value.items) && value.items.every((item) => strictProjectionItem(item, value.stream));
+  return exactObjectWithCorrelation(value, ["type", "stream", "projection_id", "sequence", "item"]) && strictProjectionItem(value.item, value.stream);
+}
+function strictWelcome(value) {
+  const base = ["type", "protocol", "participant_id", "participant_generation", "recovery_id", "head", "mode"];
+  const extension = Array.isArray(value.extensions) && value.extensions.length === 1 ? value.extensions[0] : void 0;
+  const extensionValid = isObject(extension) && extension.name === "collaboration_v1" && exactObject(extension, ["name", "capabilities", "participant_capabilities", "chat_head_sequence", "retained_floor_sequence", "read_receipts"]) && Array.isArray(extension.read_receipts);
+  const fields = extensionValid ? [...base, "extensions"] : base;
+  if (!strictCursor(value.head)) return false;
+  if (value.mode === "snapshot") return exactObjectWithCorrelation(value, [...fields, "snapshot"]) && strictSnapshot(value.snapshot);
+  if (value.mode === "terminal") return exactObjectWithCorrelation(value, [...fields, "reason"]);
+  return (value.mode === "replay" || value.mode === "up_to_date") && exactObjectWithCorrelation(value, fields);
+}
+function serverFrameWithinLimit(value) {
+  if (!isObject(value)) return false;
+  const limit = value.type === "welcome" && value.mode === "snapshot" ? SyncProtocolLimits.snapshotEncodedBytes : value.type === "replay_page" ? SyncProtocolLimits.replayPageEncodedBytes : value.type === "event" ? SyncProtocolLimits.encodedLiveEventBytes : value.type === "projection_snapshot" ? SyncProtocolLimits.projectionSnapshotEncodedBytes : value.type === "projection_event" ? SyncProtocolLimits.encodedLiveEventBytes : value.type === "reaction" ? SyncProtocolLimits.collaborationFrameBytes : value.type === "chat_message" ? SyncProtocolLimits.collaborationFrameBytes : value.type === "chat_page" && value.outcome === "loaded" ? SyncProtocolLimits.chatPageEncodedBytes : void 0;
+  if (limit === void 0) return true;
+  const budget = completeSyncCorrelation(value) ? limit : limit - SyncProtocolLimits.correlationReservedBytes;
+  return encodedSyncFrameBytes(value) <= budget;
+}
+function strictServerFrame(value) {
+  if (!isObject(value) || !validSyncCorrelation(value)) return false;
+  switch (value.type) {
+    case "welcome":
+      return strictWelcome(value);
+    case "replay_page":
+      return exactObjectWithCorrelation(value, ["type", "recovery_id", "first_revision", "last_revision", "events"]) && Array.isArray(value.events) && value.events.every((event) => isObject(event) && strictEvent(event));
+    case "recovery_complete":
+      return exactObjectWithCorrelation(value, ["type", "recovery_id", "head"]) && strictCursor(value.head);
+    case "event":
+      return strictEvent(value);
+    case "ack":
+      return value.outcome === "committed" ? exactObjectWithCorrelation(value, ["type", "command_id", "delivery", "outcome", "event_id", "revision", "state_digest"]) : value.outcome === "satisfied" ? exactObjectWithCorrelation(value, ["type", "command_id", "delivery", "outcome", "revision", "state_digest"]) : value.outcome === "rejected" ? exactObjectWithCorrelation(value, ["type", "command_id", "delivery", "outcome", "reason"]) : value.outcome === "command_id_conflict" && exactObjectWithCorrelation(value, ["type", "command_id", "delivery", "outcome", "reason"]);
+    case "projection_snapshot":
+    case "projection_event":
+      return strictProjection(value);
+    case "live_target_result":
+      return exactObjectWithCorrelation(value, ["type", "operation_id", "name", "outcome", "error_code"]);
+    case "directed_request":
+      return exactObjectWithCorrelation(value, ["type", "request_id", "name", "actor_participant_id", "expires_at_ms"]);
+    case "directed_request_result":
+      return exactObjectWithCorrelation(value, ["type", "request_id", "result"]);
+    case "reaction":
+      return strictReaction(value);
+    case "reaction_result":
+      return value.outcome === "accepted" ? exactObjectWithCorrelation(value, ["type", "operation_id", "outcome", "reaction"]) && strictReaction(value.reaction) : value.outcome === "rejected" && exactObjectWithCorrelation(value, ["type", "operation_id", "outcome", "error_code"]);
+    case "chat_message":
+      return strictChatMessage(value);
+    case "chat_send_result":
+      return value.outcome === "accepted" ? exactObjectWithCorrelation(value, ["type", "client_message_id", "outcome", "message"]) && strictChatMessage(value.message) : value.outcome === "rejected" && exactObjectWithCorrelation(value, ["type", "client_message_id", "outcome", "error_code"]);
+    case "chat_page":
+      return value.outcome === "loaded" ? exactObjectWithCorrelation(value, ["type", "request_id", "outcome", "messages", "has_more", "head_sequence", "retained_floor_sequence"]) && Array.isArray(value.messages) && value.messages.every(strictChatMessage) : value.outcome === "cursor_reset" && exactObjectWithCorrelation(value, ["type", "request_id", "outcome", "retained_floor_sequence"]);
+    case "chat_head":
+      return exactObjectWithCorrelation(value, ["type", "head_sequence", "retained_floor_sequence"]);
+    case "chat_read_receipt":
+      return exactObjectWithCorrelation(value, ["type", "participant_id", "participant_generation", "sequence", "read_at"]);
+    case "chat_read_result":
+      return value.outcome === "accepted" ? exactObjectWithCorrelation(value, ["type", "request_id", "outcome", "participant_id", "participant_generation", "sequence", "read_at"]) : value.outcome === "rejected" && exactObjectWithCorrelation(value, ["type", "request_id", "outcome", "error_code"]);
+    case "retryable_error":
+      return exactObjectWithCorrelation(value, ["type", "command_id", "code"]);
+    case "error":
+      return exactObjectWithCorrelation(value, ["type", "code", "detail"]);
+    case "pong":
+      return exactObjectWithCorrelation(value, ["type"]);
+    default:
+      return false;
+  }
+}
+var NonNegativeIntegerSchema = Schema.Number.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0));
+var PositiveIntegerSchema = Schema.Number.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(1));
+var UuidSchema = Schema.String.check(Schema.makeFilter((value) => /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.test(value) ? void 0 : { path: [], issue: "must be an RFC 4122 UUID" }));
+var JourneyIdSchema = UuidSchema.check(Schema.makeFilter((value) => !/^0{8}-0{4}-0{4}-0{4}-0{12}$/u.test(value) ? void 0 : { path: [], issue: "must be a non-zero Chalk journey UUID" }));
+var TraceparentSchema = boundedUtf8String(55, 55).check(
+  Schema.makeFilter((value) => /^00-[0-9a-f]{32}-[0-9a-f]{16}-[0-9a-f]{2}$/u.test(value) && !/^00-0{32}-[0-9a-f]{16}-[0-9a-f]{2}$/u.test(value) && !/^00-[0-9a-f]{32}-0{16}-[0-9a-f]{2}$/u.test(value) ? void 0 : { path: [], issue: "must be a valid non-zero W3C traceparent" })
+);
+var TracestateSchema = boundedUtf8String(512, 1).check(
+  Schema.makeFilter((value) => new RegExp("^[a-z][a-z0-9_*\\-/]{0,255}=[\\x21-\\x2b\\x2d-\\x3c\\x3e-\\x7e]{1,256}(,[a-z][a-z0-9_*\\-/]{0,255}=[\\x21-\\x2b\\x2d-\\x3c\\x3e-\\x7e]{1,256})*$", "u").test(value) ? void 0 : { path: [], issue: "must be a valid bounded W3C tracestate" })
+);
+var SyncCorrelationFieldsSchema = Schema.Struct({ journey_id: Schema.optional(JourneyIdSchema), traceparent: Schema.optional(TraceparentSchema), tracestate: Schema.optional(TracestateSchema) });
+var HelloCorrelationFields = { journey_id: Schema.optional(JourneyIdSchema), traceparent: Schema.optional(TraceparentSchema), tracestate: Schema.optional(TracestateSchema) };
+var ServerCorrelationFields = { ...HelloCorrelationFields };
+var StateDigestSchema = Schema.String.check(Schema.makeFilter((value) => /^[0-9a-f]{64}$/u.test(value) ? void 0 : { path: [], issue: "must be a lowercase hexadecimal SHA-256 digest" }));
+var UnsignedDecimalSchema = Schema.String.check(Schema.makeFilter((value) => /^(?:0|[1-9][0-9]*)$/u.test(value) ? void 0 : { path: [], issue: "must be an unsigned decimal integer" }));
+var CommandIdSchema = boundedUtf8String(64).check(Schema.makeFilter((value) => textEncoder.encode(value).byteLength >= 16 ? void 0 : { path: [], issue: "must meet the command ID minimum byte length" }));
+var RequestIdSchema = boundedUtf8String(64).check(Schema.makeFilter((value) => textEncoder.encode(value).byteLength >= 16 ? void 0 : { path: [], issue: "must meet the request ID minimum byte length" }));
+var ControlCursorSchema = Schema.Struct({ revision: NonNegativeIntegerSchema, state_schema_version: PositiveIntegerSchema, state_digest: StateDigestSchema }).check(exactKeys(["revision", "state_schema_version", "state_digest"]));
+var CapabilitySchema = Schema.Union([
+  Schema.Literal("publishAudio"),
+  Schema.Literal("publishVideo"),
+  Schema.Literal("publishScreen"),
+  Schema.Literal("subscribe"),
+  Schema.Literal("raiseHand"),
+  Schema.Literal("renameSelf"),
+  Schema.Literal("sendChat"),
+  Schema.Literal("sendReaction"),
+  Schema.Literal("drawWhiteboard"),
+  Schema.Literal("manageWhiteboard"),
+  Schema.Literal("manageAdmission"),
+  Schema.Literal("assignRoles"),
+  Schema.Literal("muteOthers"),
+  Schema.Literal("stopVideoOthers"),
+  Schema.Literal("stopScreenOthers"),
+  Schema.Literal("requestMediaOthers"),
+  Schema.Literal("removeParticipant"),
+  Schema.Literal("manageRecording"),
+  Schema.Literal("startEpisode"),
+  Schema.Literal("extendEpisode"),
+  Schema.Literal("endEpisode"),
+  Schema.Literal("manageMembers"),
+  Schema.Literal("clearSpaceContent")
+]);
+var RoleSchema = boundedUtf8String(64, 1).check(Schema.makeFilter((value) => value === value.trim() ? void 0 : { path: [], issue: "role names must not have surrounding whitespace" }));
+var TerminalRecoveryReasonSchema = Schema.Union([Schema.Literal("episode_ended"), Schema.Literal("participant_inactive"), Schema.Literal("stale_participant_generation")]);
+var RejectionReasonSchema = Schema.Union([
+  Schema.Literal("episode_ended"),
+  Schema.Literal("participant_inactive"),
+  Schema.Literal("stale_participant_generation"),
+  Schema.Literal("capability_denied"),
+  Schema.Literal("invalid_state"),
+  Schema.Literal("invalid_target"),
+  Schema.Literal("role_not_eligible"),
+  Schema.Literal("screen_share_in_use"),
+  Schema.Literal("recording_in_progress"),
+  Schema.Literal("command_id_conflict"),
+  Schema.Literal("external_operation_failed")
+]);
+var RetryableErrorCodeSchema = Schema.Union([Schema.Literal("overloaded"), Schema.Literal("server_draining"), Schema.Literal("dependency_unavailable"), Schema.Literal("decision_unavailable"), Schema.Literal("external_operation_pending")]);
+var ProtocolErrorCodeSchema = Schema.Union([Schema.Literal("protocol_error"), Schema.Literal("invalid_frame"), Schema.Literal("unsupported_protocol")]);
+var ParticipantSchema = Schema.Struct({
+  participant_id: UuidSchema,
+  display_name: boundedUtf8String(256, 1),
+  hand_raised: Schema.Boolean,
+  admission_revision: PositiveIntegerSchema,
+  role: RoleSchema,
+  capabilities: Schema.Array(CapabilitySchema).check(
+    Schema.isMaxLength(23),
+    Schema.makeFilter((capabilities) => uniqueStrings(capabilities) ? void 0 : { path: [], issue: "must contain unique capabilities" })
+  )
+}).check(exactKeys(["participant_id", "display_name", "hand_raised", "admission_revision", "role", "capabilities"]));
+var AdmissionRequestSchema = Schema.Struct({ admission_request_id: UuidSchema, participant_id: UuidSchema, display_name: boundedUtf8String(256, 1), role: RoleSchema, expires_at_ms: PositiveIntegerSchema }).check(
+  exactKeys(["admission_request_id", "participant_id", "display_name", "role", "expires_at_ms"])
+);
+var UniqueCapabilityArraySchema = Schema.Array(CapabilitySchema).check(
+  Schema.isMaxLength(23),
+  Schema.makeFilter((capabilities) => uniqueStrings(capabilities) ? void 0 : { path: [], issue: "must contain unique capabilities" })
+);
+var RoleCapabilitiesSchema = Schema.Record(RoleSchema, UniqueCapabilityArraySchema);
+var RecordingSchema = Schema.Struct({ recording_id: UuidSchema, status: Schema.Union([Schema.Literal("starting"), Schema.Literal("recording"), Schema.Literal("stopping"), Schema.Literal("stopped"), Schema.Literal("failed")]), failure_code: Schema.NullOr(boundedUtf8String(96, 1)) }).check(
+  exactKeys(["recording_id", "status", "failure_code"]),
+  Schema.makeFilter((recording) => recording.status === "failed" === (recording.failure_code !== null) ? void 0 : { path: ["failure_code"], issue: "must be non-null exactly when recording status is failed" })
+);
+var SnapshotSchema = Schema.Struct({
+  control_revision: NonNegativeIntegerSchema,
+  state_schema_version: PositiveIntegerSchema,
+  state_digest: StateDigestSchema,
+  status: Schema.Union([Schema.Literal("active"), Schema.Literal("ended")]),
+  admission_policy: Schema.Union([Schema.Literal("open"), Schema.Literal("knock"), Schema.Literal("members_only")]),
+  deadline_at_ms: PositiveIntegerSchema,
+  deadline_generation: PositiveIntegerSchema,
+  role_capabilities: RoleCapabilitiesSchema,
+  recording: Schema.NullOr(RecordingSchema),
+  participants: Schema.Array(ParticipantSchema).check(Schema.isMaxLength(500)),
+  admission_requests: Schema.Array(AdmissionRequestSchema).check(Schema.isMaxLength(500))
+}).check(
+  Schema.makeFilter((snapshot) => strictSnapshot(snapshot) ? void 0 : { path: [], issue: "must satisfy durable control snapshot invariants" }),
+  boundedFrame(1048576)
+);
+var NullCursorStreamSchema = Schema.Struct({ cursor: Schema.Null }).check(exactKeys(["cursor"]));
+var StreamsSchema = Schema.Struct({ control: Schema.Struct({ cursor: Schema.NullOr(ControlCursorSchema) }).check(exactKeys(["cursor"])), media: NullCursorStreamSchema, presence: NullCursorStreamSchema, requests: NullCursorStreamSchema });
+var HelloFrameSchema = Schema.Struct({ type: Schema.Literal("hello"), protocol: Schema.Literal(1), token: boundedUtf8String(8192), streams: StreamsSchema, ...HelloCorrelationFields }).check(boundedFrame(65536));
+var ChatCursorSchema = Schema.Struct({ after_sequence: Schema.NullOr(UnsignedDecimalSchema), retained_floor_sequence: Schema.NullOr(UnsignedDecimalSchema) }).check(exactKeys(["after_sequence", "retained_floor_sequence"]));
+var CollaborationHelloExtensionSchema = Schema.Struct({ name: Schema.Literal("collaboration_v1"), chat_cursor: ChatCursorSchema }).check(exactKeys(["name", "chat_cursor"]));
+var ExtendedHelloFrameSchema = Schema.Struct({ type: Schema.Literal("hello"), protocol: Schema.Literal(1), token: boundedUtf8String(8192), streams: StreamsSchema, extensions: Schema.Tuple([CollaborationHelloExtensionSchema]), ...HelloCorrelationFields }).check(boundedFrame(65536));
+var DeliveryAckFrameSchema = Schema.Struct({ type: Schema.Literal("delivery_ack"), stream: Schema.Literal("control"), revision: PositiveIntegerSchema, state_digest: StateDigestSchema });
+var RecoveryAckFrameSchema = Schema.Struct({ type: Schema.Literal("recovery_ack"), recovery_id: UuidSchema, revision: NonNegativeIntegerSchema, state_digest: StateDigestSchema });
+var SetHandRaisedCommandFrameSchema = Schema.Struct({ type: Schema.Literal("command"), command_id: CommandIdSchema, name: Schema.Literal("set_hand_raised"), payload: Schema.Struct({ raised: Schema.Boolean }) }).check(boundedFrame(65536));
+var SetDisplayNameCommandFrameSchema = Schema.Struct({
+  type: Schema.Literal("command"),
+  command_id: CommandIdSchema,
+  name: Schema.Literal("set_display_name"),
+  payload: Schema.Struct({ display_name: boundedUtf8String(256, 1).check(Schema.makeFilter((value) => value.length > 0 && value === value.trim() ? void 0 : { path: [], issue: "must be non-empty without surrounding whitespace" })) })
+}).check(boundedFrame(65536));
+var SetAdmissionPolicyCommandFrameSchema = Schema.Struct({
+  type: Schema.Literal("command"),
+  command_id: CommandIdSchema,
+  name: Schema.Literal("set_admission_policy"),
+  payload: Schema.Struct({ policy: Schema.Union([Schema.Literal("open"), Schema.Literal("knock"), Schema.Literal("members_only")]) })
+}).check(boundedFrame(65536));
+var AssignRolesCommandFrameSchema = Schema.Struct({
+  type: Schema.Literal("command"),
+  command_id: CommandIdSchema,
+  name: Schema.Literal("assign_roles"),
+  payload: Schema.Struct({ participant_id: UuidSchema, role: boundedUtf8String(64, 1).check(Schema.makeFilter((value) => value.length > 0 && value === value.trim() ? void 0 : { path: [], issue: "must be non-empty without surrounding whitespace" })) })
+}).check(boundedFrame(65536));
+var AdmitParticipantOperationFrameSchema = Schema.Struct({ type: Schema.Literal("operation"), command_id: CommandIdSchema, name: Schema.Literal("admit_participant"), payload: Schema.Struct({ admission_request_id: UuidSchema }) }).check(boundedFrame(65536));
+var DenyAdmissionOperationFrameSchema = Schema.Struct({ type: Schema.Literal("operation"), command_id: CommandIdSchema, name: Schema.Literal("deny_admission"), payload: Schema.Struct({ admission_request_id: UuidSchema }) }).check(boundedFrame(65536));
+var MuteParticipantOperationFrameSchema = Schema.Struct({ type: Schema.Literal("operation"), command_id: CommandIdSchema, name: Schema.Literal("mute_participant"), payload: Schema.Struct({ participant_id: UuidSchema }) }).check(boundedFrame(65536));
+var StopParticipantCameraOperationFrameSchema = Schema.Struct({ type: Schema.Literal("operation"), command_id: CommandIdSchema, name: Schema.Literal("stop_participant_camera"), payload: Schema.Struct({ participant_id: UuidSchema }) }).check(boundedFrame(65536));
+var StopParticipantScreenShareOperationFrameSchema = Schema.Struct({ type: Schema.Literal("operation"), command_id: CommandIdSchema, name: Schema.Literal("stop_participant_screen_share"), payload: Schema.Struct({ participant_id: UuidSchema }) }).check(boundedFrame(65536));
+var RemoveParticipantOperationFrameSchema = Schema.Struct({ type: Schema.Literal("operation"), command_id: CommandIdSchema, name: Schema.Literal("remove_participant"), payload: Schema.Struct({ participant_id: UuidSchema }) }).check(boundedFrame(65536));
+var StartRecordingOperationFrameSchema = Schema.Struct({ type: Schema.Literal("operation"), command_id: CommandIdSchema, name: Schema.Literal("start_recording"), payload: Schema.Struct({ recording_id: UuidSchema }) }).check(boundedFrame(65536));
+var StopRecordingOperationFrameSchema = Schema.Struct({ type: Schema.Literal("operation"), command_id: CommandIdSchema, name: Schema.Literal("stop_recording"), payload: Schema.Struct({ recording_id: UuidSchema }) }).check(boundedFrame(65536));
+var ParticipantLeaveOperationFrameSchema = Schema.Struct({ type: Schema.Literal("operation"), command_id: CommandIdSchema, name: Schema.Literal("participant_leave"), payload: Schema.Struct({}) }).check(boundedFrame(65536));
+var StartEpisodeOperationFrameSchema = Schema.Struct({ type: Schema.Literal("operation"), command_id: CommandIdSchema, name: Schema.Literal("start_episode"), payload: Schema.Struct({}) }).check(boundedFrame(65536));
+var ExtendEpisodeOperationFrameSchema = Schema.Struct({ type: Schema.Literal("operation"), command_id: CommandIdSchema, name: Schema.Literal("extend_episode"), payload: Schema.Struct({ extension_seconds: PositiveIntegerSchema }) }).check(boundedFrame(65536));
+var EndEpisodeOperationFrameSchema = Schema.Struct({ type: Schema.Literal("operation"), command_id: CommandIdSchema, name: Schema.Literal("end_episode"), payload: Schema.Struct({}) }).check(boundedFrame(65536));
+var LiveTargetNameSchema = Schema.Union([Schema.Literal("set_microphone_enabled"), Schema.Literal("set_camera_enabled"), Schema.Literal("set_screen_share_enabled")]);
+var LiveTargetFrameSchema = Schema.Struct({ type: Schema.Literal("live_target"), operation_id: RequestIdSchema, name: LiveTargetNameSchema, enabled: Schema.Boolean });
+var DirectedRequestNameSchema = Schema.Union([Schema.Literal("request_unmute"), Schema.Literal("request_start_camera")]);
+var DirectedRequestSendFrameSchema = Schema.Struct({ type: Schema.Literal("directed_request"), request_id: RequestIdSchema, name: DirectedRequestNameSchema, target_participant_id: UuidSchema });
+var RequestAckFrameSchema = Schema.Struct({ type: Schema.Literal("request_ack"), request_id: RequestIdSchema });
+var ReactionSchema = Schema.Union([Schema.Literal("\u{1F44D}"), Schema.Literal("\u2764\uFE0F"), Schema.Literal("\u{1F602}"), Schema.Literal("\u{1F62E}"), Schema.Literal("\u{1F622}"), Schema.Literal("\u{1F389}")]);
+var ReactionSendFrameSchema = Schema.Struct({ type: Schema.Literal("reaction_send"), operation_id: RequestIdSchema, reaction: ReactionSchema }).check(boundedFrame(SyncProtocolLimits.collaborationFrameBytes));
+var ChatTextSchema = boundedUtf8String(16384).check(Schema.makeFilter((value) => Array.from(value).length <= 4e3 ? void 0 : { path: ["text"], issue: "must fit the Unicode scalar limit" }));
+var ChatAttachmentMimeTypeSchema = Schema.Union([
+  Schema.Literal("image/png"),
+  Schema.Literal("image/jpeg"),
+  Schema.Literal("image/gif"),
+  Schema.Literal("image/webp"),
+  Schema.Literal("application/pdf"),
+  Schema.Literal("text/plain"),
+  Schema.Literal("application/msword"),
+  Schema.Literal("application/vnd.openxmlformats-officedocument.wordprocessingml.document"),
+  Schema.Literal("application/vnd.ms-excel"),
+  Schema.Literal("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"),
+  Schema.Literal("application/vnd.ms-powerpoint"),
+  Schema.Literal("application/vnd.openxmlformats-officedocument.presentationml.presentation"),
+  Schema.Literal("application/vnd.oasis.opendocument.text"),
+  Schema.Literal("application/vnd.oasis.opendocument.spreadsheet"),
+  Schema.Literal("application/vnd.oasis.opendocument.presentation")
+]);
+var ChatAttachmentIdSchema = Schema.Array(UuidSchema).check(
+  Schema.isMaxLength(SyncProtocolLimits.chatAttachmentMaxItems),
+  Schema.makeFilter((ids) => uniqueStrings(ids) ? void 0 : { path: ["attachment_ids"], issue: "must contain unique attachment IDs" })
+);
+var ChatSendFrameSchema = Schema.Struct({ type: Schema.Literal("chat_send"), client_message_id: RequestIdSchema, text: ChatTextSchema, attachment_ids: ChatAttachmentIdSchema }).check(
+  Schema.makeFilter((frame) => frame.text.length > 0 || frame.attachment_ids.length > 0 ? void 0 : { path: [], issue: "must contain text or at least one attachment" }),
+  boundedFrame(SyncProtocolLimits.collaborationFrameBytes)
+);
+var ChatReadSetFrameSchema = Schema.Struct({ type: Schema.Literal("chat_read_set"), request_id: RequestIdSchema, sequence: UnsignedDecimalSchema }).check(boundedFrame(SyncProtocolLimits.collaborationFrameBytes));
+var ChatPageDirectionSchema = Schema.Union([Schema.Literal("older"), Schema.Literal("newer")]);
+var ChatPageRequestFrameSchema = Schema.Struct({ type: Schema.Literal("chat_page_request"), request_id: RequestIdSchema, direction: ChatPageDirectionSchema, cursor_sequence: Schema.NullOr(UnsignedDecimalSchema), limit: PositiveIntegerSchema }).check(
+  Schema.makeFilter((frame) => frame.limit <= SyncProtocolLimits.chatPageMaxMessages ? void 0 : { path: ["limit"], issue: "must fit the chat page limit" }),
+  boundedFrame(SyncProtocolLimits.collaborationFrameBytes)
+);
+var ParticipantJoinedLifecycleIntentIdEventVariantSchema = Schema.Struct({
+  type: Schema.Literal("event"),
+  stream: Schema.Literal("control"),
+  name: Schema.Literal("participant_joined"),
+  event_id: UuidSchema,
+  base_revision: NonNegativeIntegerSchema,
+  revision: PositiveIntegerSchema,
+  schema_version: PositiveIntegerSchema,
+  resulting_state_digest: StateDigestSchema,
+  payload: Schema.Struct({
+    participant_id: UuidSchema,
+    display_name: boundedUtf8String(256, 1),
+    role: boundedUtf8String(64, 1).check(Schema.makeFilter((value) => value.length > 0 && value === value.trim() ? void 0 : { path: [], issue: "must be non-empty without surrounding whitespace" })),
+    admission_revision: PositiveIntegerSchema
+  }),
+  lifecycle_intent_id: UuidSchema,
+  ...ServerCorrelationFields
+}).check(
+  Schema.makeFilter((frame) => frame.revision === frame.base_revision + 1 ? void 0 : { path: ["revision"], issue: "revision must equal base_revision + 1" }),
+  boundedFrame(32768)
+);
+var ParticipantLeftExternalOperationIdEventVariantSchema = Schema.Struct({
+  type: Schema.Literal("event"),
+  stream: Schema.Literal("control"),
+  name: Schema.Literal("participant_left"),
+  event_id: UuidSchema,
+  base_revision: NonNegativeIntegerSchema,
+  revision: PositiveIntegerSchema,
+  schema_version: PositiveIntegerSchema,
+  resulting_state_digest: StateDigestSchema,
+  payload: Schema.Struct({ participant_id: UuidSchema, reason: Schema.Union([Schema.Literal("left"), Schema.Literal("removed")]) }),
+  external_operation_id: UuidSchema,
+  ...ServerCorrelationFields
+}).check(
+  Schema.makeFilter((frame) => frame.revision === frame.base_revision + 1 ? void 0 : { path: ["revision"], issue: "revision must equal base_revision + 1" }),
+  boundedFrame(32768)
+);
+var EpisodeStartedLifecycleIntentIdEventVariantSchema = Schema.Struct({
+  type: Schema.Literal("event"),
+  stream: Schema.Literal("control"),
+  name: Schema.Literal("episode_started"),
+  event_id: UuidSchema,
+  base_revision: NonNegativeIntegerSchema,
+  revision: PositiveIntegerSchema,
+  schema_version: PositiveIntegerSchema,
+  resulting_state_digest: StateDigestSchema,
+  payload: Schema.Struct({ episode_id: UuidSchema }),
+  lifecycle_intent_id: UuidSchema,
+  ...ServerCorrelationFields
+}).check(
+  Schema.makeFilter((frame) => frame.revision === frame.base_revision + 1 ? void 0 : { path: ["revision"], issue: "revision must equal base_revision + 1" }),
+  boundedFrame(32768)
+);
+var EpisodeEndedExternalOperationIdEventVariantSchema = Schema.Struct({
+  type: Schema.Literal("event"),
+  stream: Schema.Literal("control"),
+  name: Schema.Literal("episode_ended"),
+  event_id: UuidSchema,
+  base_revision: NonNegativeIntegerSchema,
+  revision: PositiveIntegerSchema,
+  schema_version: PositiveIntegerSchema,
+  resulting_state_digest: StateDigestSchema,
+  payload: Schema.Struct({ reason: Schema.Union([Schema.Literal("ended_by_participant"), Schema.Literal("tenant_recovery"), Schema.Literal("maximum_duration")]) }),
+  external_operation_id: UuidSchema,
+  ...ServerCorrelationFields
+}).check(
+  Schema.makeFilter((frame) => frame.revision === frame.base_revision + 1 ? void 0 : { path: ["revision"], issue: "revision must equal base_revision + 1" }),
+  boundedFrame(32768)
+);
+var HandRaisedCommandIdEventVariantSchema = Schema.Struct({
+  type: Schema.Literal("event"),
+  stream: Schema.Literal("control"),
+  name: Schema.Literal("hand_raised"),
+  event_id: UuidSchema,
+  base_revision: NonNegativeIntegerSchema,
+  revision: PositiveIntegerSchema,
+  schema_version: PositiveIntegerSchema,
+  resulting_state_digest: StateDigestSchema,
+  payload: Schema.Struct({ participant_id: UuidSchema }),
+  command_id: CommandIdSchema,
+  ...ServerCorrelationFields
+}).check(
+  Schema.makeFilter((frame) => frame.revision === frame.base_revision + 1 ? void 0 : { path: ["revision"], issue: "revision must equal base_revision + 1" }),
+  boundedFrame(32768)
+);
+var HandLoweredCommandIdEventVariantSchema = Schema.Struct({
+  type: Schema.Literal("event"),
+  stream: Schema.Literal("control"),
+  name: Schema.Literal("hand_lowered"),
+  event_id: UuidSchema,
+  base_revision: NonNegativeIntegerSchema,
+  revision: PositiveIntegerSchema,
+  schema_version: PositiveIntegerSchema,
+  resulting_state_digest: StateDigestSchema,
+  payload: Schema.Struct({ participant_id: UuidSchema }),
+  command_id: CommandIdSchema,
+  ...ServerCorrelationFields
+}).check(
+  Schema.makeFilter((frame) => frame.revision === frame.base_revision + 1 ? void 0 : { path: ["revision"], issue: "revision must equal base_revision + 1" }),
+  boundedFrame(32768)
+);
+var ParticipantDisplayNameChangedCommandIdEventVariantSchema = Schema.Struct({
+  type: Schema.Literal("event"),
+  stream: Schema.Literal("control"),
+  name: Schema.Literal("participant_display_name_changed"),
+  event_id: UuidSchema,
+  base_revision: NonNegativeIntegerSchema,
+  revision: PositiveIntegerSchema,
+  schema_version: PositiveIntegerSchema,
+  resulting_state_digest: StateDigestSchema,
+  payload: Schema.Struct({ participant_id: UuidSchema, display_name: boundedUtf8String(256, 1) }),
+  command_id: CommandIdSchema,
+  ...ServerCorrelationFields
+}).check(
+  Schema.makeFilter((frame) => frame.revision === frame.base_revision + 1 ? void 0 : { path: ["revision"], issue: "revision must equal base_revision + 1" }),
+  boundedFrame(32768)
+);
+var AdmissionPolicyChangedCommandIdEventVariantSchema = Schema.Struct({
+  type: Schema.Literal("event"),
+  stream: Schema.Literal("control"),
+  name: Schema.Literal("admission_policy_changed"),
+  event_id: UuidSchema,
+  base_revision: NonNegativeIntegerSchema,
+  revision: PositiveIntegerSchema,
+  schema_version: PositiveIntegerSchema,
+  resulting_state_digest: StateDigestSchema,
+  payload: Schema.Struct({ policy: Schema.Union([Schema.Literal("open"), Schema.Literal("knock"), Schema.Literal("members_only")]) }),
+  command_id: CommandIdSchema,
+  ...ServerCorrelationFields
+}).check(
+  Schema.makeFilter((frame) => frame.revision === frame.base_revision + 1 ? void 0 : { path: ["revision"], issue: "revision must equal base_revision + 1" }),
+  boundedFrame(32768)
+);
+var RoleAssignedCommandIdEventVariantSchema = Schema.Struct({
+  type: Schema.Literal("event"),
+  stream: Schema.Literal("control"),
+  name: Schema.Literal("role_assigned"),
+  event_id: UuidSchema,
+  base_revision: NonNegativeIntegerSchema,
+  revision: PositiveIntegerSchema,
+  schema_version: PositiveIntegerSchema,
+  resulting_state_digest: StateDigestSchema,
+  payload: Schema.Struct({ participant_id: UuidSchema, role: boundedUtf8String(64, 1).check(Schema.makeFilter((value) => value.length > 0 && value === value.trim() ? void 0 : { path: [], issue: "must be non-empty without surrounding whitespace" })) }),
+  command_id: CommandIdSchema,
+  ...ServerCorrelationFields
+}).check(
+  Schema.makeFilter((frame) => frame.revision === frame.base_revision + 1 ? void 0 : { path: ["revision"], issue: "revision must equal base_revision + 1" }),
+  boundedFrame(32768)
+);
+var DeadlineChangedExternalOperationIdEventVariantSchema = Schema.Struct({
+  type: Schema.Literal("event"),
+  stream: Schema.Literal("control"),
+  name: Schema.Literal("deadline_changed"),
+  event_id: UuidSchema,
+  base_revision: NonNegativeIntegerSchema,
+  revision: PositiveIntegerSchema,
+  schema_version: PositiveIntegerSchema,
+  resulting_state_digest: StateDigestSchema,
+  payload: Schema.Struct({ deadline_at_ms: PositiveIntegerSchema, deadline_generation: PositiveIntegerSchema }),
+  external_operation_id: UuidSchema,
+  ...ServerCorrelationFields
+}).check(
+  Schema.makeFilter((frame) => frame.revision === frame.base_revision + 1 ? void 0 : { path: ["revision"], issue: "revision must equal base_revision + 1" }),
+  boundedFrame(32768)
+);
+var AdmissionRequestedLifecycleIntentIdEventVariantSchema = Schema.Struct({
+  type: Schema.Literal("event"),
+  stream: Schema.Literal("control"),
+  name: Schema.Literal("admission_requested"),
+  event_id: UuidSchema,
+  base_revision: NonNegativeIntegerSchema,
+  revision: PositiveIntegerSchema,
+  schema_version: PositiveIntegerSchema,
+  resulting_state_digest: StateDigestSchema,
+  payload: Schema.Struct({
+    admission_request_id: UuidSchema,
+    participant_id: UuidSchema,
+    display_name: boundedUtf8String(256, 1),
+    role: boundedUtf8String(64, 1).check(Schema.makeFilter((value) => value.length > 0 && value === value.trim() ? void 0 : { path: [], issue: "must be non-empty without surrounding whitespace" })),
+    expires_at_ms: PositiveIntegerSchema
+  }),
+  lifecycle_intent_id: UuidSchema,
+  ...ServerCorrelationFields
+}).check(
+  Schema.makeFilter((frame) => frame.revision === frame.base_revision + 1 ? void 0 : { path: ["revision"], issue: "revision must equal base_revision + 1" }),
+  boundedFrame(32768)
+);
+var AdmissionDeniedExternalOperationIdEventVariantSchema = Schema.Struct({
+  type: Schema.Literal("event"),
+  stream: Schema.Literal("control"),
+  name: Schema.Literal("admission_denied"),
+  event_id: UuidSchema,
+  base_revision: NonNegativeIntegerSchema,
+  revision: PositiveIntegerSchema,
+  schema_version: PositiveIntegerSchema,
+  resulting_state_digest: StateDigestSchema,
+  payload: Schema.Struct({ admission_request_id: UuidSchema }),
+  external_operation_id: UuidSchema,
+  ...ServerCorrelationFields
+}).check(
+  Schema.makeFilter((frame) => frame.revision === frame.base_revision + 1 ? void 0 : { path: ["revision"], issue: "revision must equal base_revision + 1" }),
+  boundedFrame(32768)
+);
+var AdmissionExpiredExternalOperationIdEventVariantSchema = Schema.Struct({
+  type: Schema.Literal("event"),
+  stream: Schema.Literal("control"),
+  name: Schema.Literal("admission_expired"),
+  event_id: UuidSchema,
+  base_revision: NonNegativeIntegerSchema,
+  revision: PositiveIntegerSchema,
+  schema_version: PositiveIntegerSchema,
+  resulting_state_digest: StateDigestSchema,
+  payload: Schema.Struct({ admission_request_id: UuidSchema }),
+  external_operation_id: UuidSchema,
+  ...ServerCorrelationFields
+}).check(
+  Schema.makeFilter((frame) => frame.revision === frame.base_revision + 1 ? void 0 : { path: ["revision"], issue: "revision must equal base_revision + 1" }),
+  boundedFrame(32768)
+);
+var ParticipantMicrophoneStoppedExternalOperationIdEventVariantSchema = Schema.Struct({
+  type: Schema.Literal("event"),
+  stream: Schema.Literal("control"),
+  name: Schema.Literal("participant_microphone_stopped"),
+  event_id: UuidSchema,
+  base_revision: NonNegativeIntegerSchema,
+  revision: PositiveIntegerSchema,
+  schema_version: PositiveIntegerSchema,
+  resulting_state_digest: StateDigestSchema,
+  payload: Schema.Struct({ participant_id: UuidSchema }),
+  external_operation_id: UuidSchema,
+  ...ServerCorrelationFields
+}).check(
+  Schema.makeFilter((frame) => frame.revision === frame.base_revision + 1 ? void 0 : { path: ["revision"], issue: "revision must equal base_revision + 1" }),
+  boundedFrame(32768)
+);
+var ParticipantCameraStoppedExternalOperationIdEventVariantSchema = Schema.Struct({
+  type: Schema.Literal("event"),
+  stream: Schema.Literal("control"),
+  name: Schema.Literal("participant_camera_stopped"),
+  event_id: UuidSchema,
+  base_revision: NonNegativeIntegerSchema,
+  revision: PositiveIntegerSchema,
+  schema_version: PositiveIntegerSchema,
+  resulting_state_digest: StateDigestSchema,
+  payload: Schema.Struct({ participant_id: UuidSchema }),
+  external_operation_id: UuidSchema,
+  ...ServerCorrelationFields
+}).check(
+  Schema.makeFilter((frame) => frame.revision === frame.base_revision + 1 ? void 0 : { path: ["revision"], issue: "revision must equal base_revision + 1" }),
+  boundedFrame(32768)
+);
+var ParticipantScreenShareStoppedExternalOperationIdEventVariantSchema = Schema.Struct({
+  type: Schema.Literal("event"),
+  stream: Schema.Literal("control"),
+  name: Schema.Literal("participant_screen_share_stopped"),
+  event_id: UuidSchema,
+  base_revision: NonNegativeIntegerSchema,
+  revision: PositiveIntegerSchema,
+  schema_version: PositiveIntegerSchema,
+  resulting_state_digest: StateDigestSchema,
+  payload: Schema.Struct({ participant_id: UuidSchema }),
+  external_operation_id: UuidSchema,
+  ...ServerCorrelationFields
+}).check(
+  Schema.makeFilter((frame) => frame.revision === frame.base_revision + 1 ? void 0 : { path: ["revision"], issue: "revision must equal base_revision + 1" }),
+  boundedFrame(32768)
+);
+var RecordingStatusChangedExternalOperationIdEventVariantSchema = Schema.Struct({
+  type: Schema.Literal("event"),
+  stream: Schema.Literal("control"),
+  name: Schema.Literal("recording_status_changed"),
+  event_id: UuidSchema,
+  base_revision: NonNegativeIntegerSchema,
+  revision: PositiveIntegerSchema,
+  schema_version: PositiveIntegerSchema,
+  resulting_state_digest: StateDigestSchema,
+  payload: Schema.Struct({ recording_id: UuidSchema, status: Schema.Union([Schema.Literal("starting"), Schema.Literal("recording"), Schema.Literal("stopping"), Schema.Literal("stopped"), Schema.Literal("failed")]), failure_code: Schema.NullOr(boundedUtf8String(96, 1)) }),
+  external_operation_id: UuidSchema,
+  ...ServerCorrelationFields
+}).check(
+  Schema.makeFilter((frame) => frame.revision === frame.base_revision + 1 ? void 0 : { path: ["revision"], issue: "revision must equal base_revision + 1" }),
+  boundedFrame(32768)
+);
+var ParticipantJoinedEventFrameSchema = ParticipantJoinedLifecycleIntentIdEventVariantSchema;
+var ParticipantLeftEventFrameSchema = ParticipantLeftExternalOperationIdEventVariantSchema;
+var EpisodeStartedEventFrameSchema = EpisodeStartedLifecycleIntentIdEventVariantSchema;
+var EpisodeEndedEventFrameSchema = EpisodeEndedExternalOperationIdEventVariantSchema;
+var HandRaisedEventFrameSchema = HandRaisedCommandIdEventVariantSchema;
+var HandLoweredEventFrameSchema = HandLoweredCommandIdEventVariantSchema;
+var ParticipantDisplayNameChangedEventFrameSchema = ParticipantDisplayNameChangedCommandIdEventVariantSchema;
+var AdmissionPolicyChangedEventFrameSchema = AdmissionPolicyChangedCommandIdEventVariantSchema;
+var RoleAssignedEventFrameSchema = RoleAssignedCommandIdEventVariantSchema;
+var DeadlineChangedEventFrameSchema = DeadlineChangedExternalOperationIdEventVariantSchema;
+var AdmissionRequestedEventFrameSchema = AdmissionRequestedLifecycleIntentIdEventVariantSchema;
+var AdmissionDeniedEventFrameSchema = AdmissionDeniedExternalOperationIdEventVariantSchema;
+var AdmissionExpiredEventFrameSchema = AdmissionExpiredExternalOperationIdEventVariantSchema;
+var ParticipantMicrophoneStoppedEventFrameSchema = ParticipantMicrophoneStoppedExternalOperationIdEventVariantSchema;
+var ParticipantCameraStoppedEventFrameSchema = ParticipantCameraStoppedExternalOperationIdEventVariantSchema;
+var ParticipantScreenShareStoppedEventFrameSchema = ParticipantScreenShareStoppedExternalOperationIdEventVariantSchema;
+var RecordingStatusChangedEventFrameSchema = RecordingStatusChangedExternalOperationIdEventVariantSchema;
+var EventFrameSchema = Schema.Union([
+  ParticipantJoinedEventFrameSchema,
+  ParticipantLeftEventFrameSchema,
+  EpisodeStartedEventFrameSchema,
+  EpisodeEndedEventFrameSchema,
+  HandRaisedEventFrameSchema,
+  HandLoweredEventFrameSchema,
+  ParticipantDisplayNameChangedEventFrameSchema,
+  AdmissionPolicyChangedEventFrameSchema,
+  RoleAssignedEventFrameSchema,
+  DeadlineChangedEventFrameSchema,
+  AdmissionRequestedEventFrameSchema,
+  AdmissionDeniedEventFrameSchema,
+  AdmissionExpiredEventFrameSchema,
+  ParticipantMicrophoneStoppedEventFrameSchema,
+  ParticipantCameraStoppedEventFrameSchema,
+  ParticipantScreenShareStoppedEventFrameSchema,
+  RecordingStatusChangedEventFrameSchema
+]);
+var CollaborationCapabilitySchema = Schema.Union([Schema.Literal("sendReaction"), Schema.Literal("sendChat")]);
+var CollaborationCapabilitiesSchema = Schema.Array(CollaborationCapabilitySchema).check(
+  Schema.isMaxLength(2),
+  Schema.makeFilter((capabilities) => uniqueStrings(capabilities) ? void 0 : { path: [], issue: "must contain unique collaboration capabilities" })
+);
+var ChatReadReceiptSchema = Schema.Struct({ participant_id: UuidSchema, participant_generation: PositiveIntegerSchema, sequence: UnsignedDecimalSchema, read_at: boundedUtf8String(64, 1) }).check(exactKeys(["participant_id", "participant_generation", "sequence", "read_at"]));
+var CollaborationWelcomeExtensionSchema = Schema.Struct({
+  name: Schema.Literal("collaboration_v1"),
+  capabilities: CollaborationCapabilitiesSchema,
+  participant_capabilities: Schema.Record(UuidSchema, CollaborationCapabilitiesSchema),
+  chat_head_sequence: Schema.NullOr(UnsignedDecimalSchema),
+  retained_floor_sequence: Schema.NullOr(UnsignedDecimalSchema),
+  read_receipts: Schema.Array(ChatReadReceiptSchema).check(Schema.isMaxLength(500))
+}).check(exactKeys(["name", "capabilities", "participant_capabilities", "chat_head_sequence", "retained_floor_sequence", "read_receipts"]));
+var WelcomeBase = { type: Schema.Literal("welcome"), protocol: Schema.Literal(1), participant_id: UuidSchema, participant_generation: PositiveIntegerSchema, recovery_id: UuidSchema, head: ControlCursorSchema };
+var ExtendedWelcomeBase = { ...WelcomeBase, extensions: Schema.Tuple([CollaborationWelcomeExtensionSchema]) };
+var WelcomeSnapshotFrameSchema = Schema.Struct({ ...WelcomeBase, mode: Schema.Literal("snapshot"), snapshot: SnapshotSchema, ...ServerCorrelationFields }).check(boundedServerFrame(SyncProtocolLimits.snapshotEncodedBytes));
+var WelcomeReplayFrameSchema = Schema.Struct({ ...WelcomeBase, mode: Schema.Literal("replay"), ...ServerCorrelationFields });
+var WelcomeUpToDateFrameSchema = Schema.Struct({ ...WelcomeBase, mode: Schema.Literal("up_to_date"), ...ServerCorrelationFields });
+var WelcomeTerminalFrameSchema = Schema.Struct({ ...WelcomeBase, mode: Schema.Literal("terminal"), reason: TerminalRecoveryReasonSchema, ...ServerCorrelationFields });
+var ExtendedWelcomeSnapshotFrameSchema = Schema.Struct({ ...ExtendedWelcomeBase, mode: Schema.Literal("snapshot"), snapshot: SnapshotSchema, ...ServerCorrelationFields }).check(boundedServerFrame(SyncProtocolLimits.snapshotEncodedBytes));
+var ExtendedWelcomeReplayFrameSchema = Schema.Struct({ ...ExtendedWelcomeBase, mode: Schema.Literal("replay"), ...ServerCorrelationFields });
+var ExtendedWelcomeUpToDateFrameSchema = Schema.Struct({ ...ExtendedWelcomeBase, mode: Schema.Literal("up_to_date"), ...ServerCorrelationFields });
+var ExtendedWelcomeTerminalFrameSchema = Schema.Struct({ ...ExtendedWelcomeBase, mode: Schema.Literal("terminal"), reason: TerminalRecoveryReasonSchema, ...ServerCorrelationFields });
+var WelcomeFrameSchema = Schema.Union([
+  ExtendedWelcomeSnapshotFrameSchema,
+  ExtendedWelcomeReplayFrameSchema,
+  ExtendedWelcomeUpToDateFrameSchema,
+  ExtendedWelcomeTerminalFrameSchema,
+  WelcomeSnapshotFrameSchema,
+  WelcomeReplayFrameSchema,
+  WelcomeUpToDateFrameSchema,
+  WelcomeTerminalFrameSchema
+]);
+var ReplayPageFrameSchema = Schema.Struct({
+  type: Schema.Literal("replay_page"),
+  recovery_id: UuidSchema,
+  first_revision: PositiveIntegerSchema,
+  last_revision: PositiveIntegerSchema,
+  events: Schema.Array(EventFrameSchema).check(Schema.isMaxLength(SyncProtocolLimits.replayPageMaxEvents)),
+  ...ServerCorrelationFields
+}).check(
+  Schema.makeFilter((frame) => {
+    const first = frame.events[0];
+    const last = frame.events.at(-1);
+    const budget = completeSyncCorrelation(frame) ? SyncProtocolLimits.replayPageEncodedBytes : SyncProtocolLimits.replayPageEncodedBytes - SyncProtocolLimits.correlationReservedBytes;
+    return encodedSyncFrameBytes(frame) <= budget && first !== void 0 && last !== void 0 && first.revision === frame.first_revision && last.revision === frame.last_revision && frame.events.every((event, index) => index === 0 || event.base_revision === frame.events[index - 1].revision) ? void 0 : { path: [], issue: "must declare one bounded contiguous replay page" };
+  })
+);
+var RecoveryCompleteFrameSchema = Schema.Struct({ type: Schema.Literal("recovery_complete"), recovery_id: UuidSchema, head: ControlCursorSchema, ...ServerCorrelationFields });
+var AckDeliverySchema = Schema.Union([Schema.Literal("original"), Schema.Literal("duplicate")]);
+var CommittedAckFrameSchema = Schema.Struct({ type: Schema.Literal("ack"), command_id: CommandIdSchema, delivery: AckDeliverySchema, outcome: Schema.Literal("committed"), event_id: UuidSchema, revision: PositiveIntegerSchema, state_digest: StateDigestSchema, ...ServerCorrelationFields });
+var SatisfiedAckFrameSchema = Schema.Struct({ type: Schema.Literal("ack"), command_id: CommandIdSchema, delivery: AckDeliverySchema, outcome: Schema.Literal("satisfied"), revision: NonNegativeIntegerSchema, state_digest: StateDigestSchema, ...ServerCorrelationFields });
+var RejectedAckFrameSchema = Schema.Struct({ type: Schema.Literal("ack"), command_id: CommandIdSchema, delivery: AckDeliverySchema, outcome: Schema.Literal("rejected"), reason: RejectionReasonSchema, ...ServerCorrelationFields });
+var CommandIdConflictAckFrameSchema = Schema.Struct({ type: Schema.Literal("ack"), command_id: CommandIdSchema, delivery: AckDeliverySchema, outcome: Schema.Literal("command_id_conflict"), reason: Schema.Literal("command_id_conflict"), ...ServerCorrelationFields });
+var MediaProjectionItemSchema = Schema.Struct({ participant_id: UuidSchema, source: Schema.Union([Schema.Literal("microphone"), Schema.Literal("camera"), Schema.Literal("screen")]), enabled: Schema.Boolean, publication_id: Schema.NullOr(boundedUtf8String(256, 1)) }).check(
+  Schema.makeFilter((item) => item.enabled === (item.publication_id !== null) ? void 0 : { path: [], issue: "enabled must equal whether publication_id is non-null" })
+);
+var PresenceProjectionItemSchema = Schema.Struct({ participant_id: UuidSchema, state: Schema.Union([Schema.Literal("connected"), Schema.Literal("disconnected")]), speaking: Schema.Boolean, active_speaker: Schema.Boolean }).check(
+  Schema.makeFilter((item) => item.state !== "disconnected" || !item.speaking && !item.active_speaker ? void 0 : { path: [], issue: "disconnected presence cannot be speaking or active speaker" })
+);
+var MediaProjectionSnapshotFrameSchema = Schema.Struct({
+  type: Schema.Literal("projection_snapshot"),
+  stream: Schema.Literal("media"),
+  projection_id: UuidSchema,
+  sequence: Schema.Literal(0),
+  items: Schema.Array(MediaProjectionItemSchema).check(Schema.isMaxLength(1500)),
+  ...ServerCorrelationFields
+}).check(boundedServerFrame(SyncProtocolLimits.projectionSnapshotEncodedBytes));
+var PresenceProjectionSnapshotFrameSchema = Schema.Struct({
+  type: Schema.Literal("projection_snapshot"),
+  stream: Schema.Literal("presence"),
+  projection_id: UuidSchema,
+  sequence: Schema.Literal(0),
+  items: Schema.Array(PresenceProjectionItemSchema).check(Schema.isMaxLength(500)),
+  ...ServerCorrelationFields
+}).check(boundedServerFrame(SyncProtocolLimits.projectionSnapshotEncodedBytes));
+var MediaProjectionEventFrameSchema = Schema.Struct({ type: Schema.Literal("projection_event"), stream: Schema.Literal("media"), projection_id: UuidSchema, sequence: PositiveIntegerSchema, item: MediaProjectionItemSchema, ...ServerCorrelationFields }).check(
+  boundedServerFrame(SyncProtocolLimits.encodedLiveEventBytes)
+);
+var PresenceProjectionEventFrameSchema = Schema.Struct({ type: Schema.Literal("projection_event"), stream: Schema.Literal("presence"), projection_id: UuidSchema, sequence: PositiveIntegerSchema, item: PresenceProjectionItemSchema, ...ServerCorrelationFields }).check(
+  boundedServerFrame(SyncProtocolLimits.encodedLiveEventBytes)
+);
+var ProjectionFrameSchema = Schema.Union([MediaProjectionSnapshotFrameSchema, PresenceProjectionSnapshotFrameSchema, MediaProjectionEventFrameSchema, PresenceProjectionEventFrameSchema]);
+var LiveTargetOutcomeSchema = Schema.Union([Schema.Literal("confirmed"), Schema.Literal("satisfied"), Schema.Literal("retryable_failure"), Schema.Literal("terminal_failure"), Schema.Literal("ambiguous")]);
+var LiveTargetResultFrameSchema = Schema.Struct({
+  type: Schema.Literal("live_target_result"),
+  operation_id: RequestIdSchema,
+  name: LiveTargetNameSchema,
+  outcome: LiveTargetOutcomeSchema,
+  error_code: Schema.NullOr(boundedUtf8String(SyncProtocolLimits.protocolErrorDetailBytes, 1)),
+  ...ServerCorrelationFields
+});
+var DirectedRequestDeliverFrameSchema = Schema.Struct({ type: Schema.Literal("directed_request"), request_id: RequestIdSchema, name: DirectedRequestNameSchema, actor_participant_id: UuidSchema, expires_at_ms: PositiveIntegerSchema, ...ServerCorrelationFields });
+var DirectedRequestResultSchema = Schema.Union([Schema.Literal("delivered"), Schema.Literal("target_unavailable"), Schema.Literal("expired"), Schema.Literal("rejected"), Schema.Literal("rate_limited")]);
+var DirectedRequestResultFrameSchema = Schema.Struct({ type: Schema.Literal("directed_request_result"), request_id: RequestIdSchema, result: DirectedRequestResultSchema, ...ServerCorrelationFields });
+var ReactionEventFrameSchema = Schema.Struct({
+  type: Schema.Literal("reaction"),
+  event_id: UuidSchema,
+  participant_id: UuidSchema,
+  display_name: boundedUtf8String(256, 1),
+  reaction: ReactionSchema,
+  occurred_at: boundedUtf8String(64, 1),
+  expires_at: boundedUtf8String(64, 1),
+  ...ServerCorrelationFields
+}).check(boundedFrame(SyncProtocolLimits.collaborationFrameBytes));
+var CollaborationErrorCodeSchema = Schema.Union([
+  Schema.Literal("capability_denied"),
+  Schema.Literal("invalid_payload"),
+  Schema.Literal("rate_limited"),
+  Schema.Literal("overloaded"),
+  Schema.Literal("episode_ended"),
+  Schema.Literal("participant_stale"),
+  Schema.Literal("client_message_id_conflict"),
+  Schema.Literal("attachment_not_found"),
+  Schema.Literal("attachment_not_ready"),
+  Schema.Literal("attachment_already_claimed"),
+  Schema.Literal("attachment_quota_exceeded"),
+  Schema.Literal("dependency_unavailable")
+]);
+var AcceptedReactionResultFrameSchema = Schema.Struct({ type: Schema.Literal("reaction_result"), operation_id: RequestIdSchema, outcome: Schema.Literal("accepted"), reaction: ReactionEventFrameSchema, ...ServerCorrelationFields });
+var RejectedReactionResultFrameSchema = Schema.Struct({ type: Schema.Literal("reaction_result"), operation_id: RequestIdSchema, outcome: Schema.Literal("rejected"), error_code: CollaborationErrorCodeSchema, ...ServerCorrelationFields });
+var ReactionResultFrameSchema = Schema.Union([AcceptedReactionResultFrameSchema, RejectedReactionResultFrameSchema]);
+var ChatAttachmentSchema = Schema.Struct({ attachment_id: UuidSchema, file_name: boundedUtf8String(SyncProtocolLimits.chatAttachmentFileNameUtf8Bytes, 1), mime_type: ChatAttachmentMimeTypeSchema, byte_length: PositiveIntegerSchema }).check(
+  Schema.makeFilter((attachment) => attachment.byte_length <= SyncProtocolLimits.chatAttachmentMaxBytes ? void 0 : { path: ["byte_length"], issue: "must fit the attachment byte limit" }),
+  exactKeys(["attachment_id", "file_name", "mime_type", "byte_length"])
+);
+var ChatMessageFrameSchema = Schema.Struct({
+  type: Schema.Literal("chat_message"),
+  message_id: UuidSchema,
+  client_message_id: RequestIdSchema,
+  sequence: UnsignedDecimalSchema,
+  participant_id: UuidSchema,
+  display_name: boundedUtf8String(256, 1),
+  text: ChatTextSchema,
+  attachments: Schema.Array(ChatAttachmentSchema).check(Schema.isMaxLength(SyncProtocolLimits.chatAttachmentMaxItems)),
+  created_at: boundedUtf8String(64, 1),
+  ...ServerCorrelationFields
+}).check(
+  Schema.makeFilter((frame) => frame.text.length > 0 || frame.attachments.length > 0 ? void 0 : { path: [], issue: "must contain text or at least one attachment" }),
+  boundedFrame(SyncProtocolLimits.collaborationFrameBytes)
+);
+var AnyChatMessageFrameSchema = ChatMessageFrameSchema;
+var AcceptedChatSendResultFrameSchema = Schema.Struct({ type: Schema.Literal("chat_send_result"), client_message_id: RequestIdSchema, outcome: Schema.Literal("accepted"), message: ChatMessageFrameSchema, ...ServerCorrelationFields });
+var RejectedChatSendResultFrameSchema = Schema.Struct({ type: Schema.Literal("chat_send_result"), client_message_id: RequestIdSchema, outcome: Schema.Literal("rejected"), error_code: CollaborationErrorCodeSchema, ...ServerCorrelationFields });
+var ChatSendResultFrameSchema = Schema.Union([AcceptedChatSendResultFrameSchema, RejectedChatSendResultFrameSchema]);
+var LoadedChatPageFrameSchema = Schema.Struct({
+  type: Schema.Literal("chat_page"),
+  request_id: RequestIdSchema,
+  outcome: Schema.Literal("loaded"),
+  messages: Schema.Array(AnyChatMessageFrameSchema).check(Schema.isMaxLength(SyncProtocolLimits.chatPageMaxMessages)),
+  has_more: Schema.Boolean,
+  head_sequence: Schema.NullOr(UnsignedDecimalSchema),
+  retained_floor_sequence: Schema.NullOr(UnsignedDecimalSchema),
+  ...ServerCorrelationFields
+}).check(boundedServerFrame(SyncProtocolLimits.chatPageEncodedBytes));
+var ResetChatPageFrameSchema = Schema.Struct({ type: Schema.Literal("chat_page"), request_id: RequestIdSchema, outcome: Schema.Literal("cursor_reset"), retained_floor_sequence: UnsignedDecimalSchema, ...ServerCorrelationFields });
+var ChatPageFrameSchema = Schema.Union([LoadedChatPageFrameSchema, ResetChatPageFrameSchema]);
+var ChatHeadFrameSchema = Schema.Struct({ type: Schema.Literal("chat_head"), head_sequence: Schema.NullOr(UnsignedDecimalSchema), retained_floor_sequence: Schema.NullOr(UnsignedDecimalSchema), ...ServerCorrelationFields });
+var ChatReadReceiptFrameSchema = Schema.Struct({ type: Schema.Literal("chat_read_receipt"), participant_id: UuidSchema, participant_generation: PositiveIntegerSchema, sequence: UnsignedDecimalSchema, read_at: boundedUtf8String(64, 1), ...ServerCorrelationFields }).check(
+  serverExactKeys(["type", "participant_id", "participant_generation", "sequence", "read_at"])
+);
+var AcceptedChatReadResultFrameSchema = Schema.Struct({
+  type: Schema.Literal("chat_read_result"),
+  request_id: RequestIdSchema,
+  outcome: Schema.Literal("accepted"),
+  participant_id: UuidSchema,
+  participant_generation: PositiveIntegerSchema,
+  sequence: UnsignedDecimalSchema,
+  read_at: boundedUtf8String(64, 1),
+  ...ServerCorrelationFields
+});
+var RejectedChatReadResultFrameSchema = Schema.Struct({ type: Schema.Literal("chat_read_result"), request_id: RequestIdSchema, outcome: Schema.Literal("rejected"), error_code: CollaborationErrorCodeSchema, ...ServerCorrelationFields });
+var ChatReadResultFrameSchema = Schema.Union([AcceptedChatReadResultFrameSchema, RejectedChatReadResultFrameSchema]);
+var RetryableErrorFrameSchema = Schema.Struct({ type: Schema.Literal("retryable_error"), command_id: CommandIdSchema, code: RetryableErrorCodeSchema, ...ServerCorrelationFields });
+var ErrorFrameSchema = Schema.Struct({ type: Schema.Literal("error"), code: ProtocolErrorCodeSchema, detail: boundedUtf8String(1024), ...ServerCorrelationFields });
+var PingFrameSchema = Schema.Struct({ type: Schema.Literal("ping") });
+var PongFrameSchema = Schema.Struct({ type: Schema.Literal("pong"), ...ServerCorrelationFields });
+var SyncV1ClientFrameSchema = Schema.Unknown.check(Schema.makeFilter((frame) => strictClientFrame(frame) ? void 0 : { path: [], issue: "must not contain unknown or missing fields" })).pipe(
+  Schema.decodeTo(
+    Schema.Union([
+      ExtendedHelloFrameSchema,
+      HelloFrameSchema,
+      SetHandRaisedCommandFrameSchema,
+      SetDisplayNameCommandFrameSchema,
+      SetAdmissionPolicyCommandFrameSchema,
+      AssignRolesCommandFrameSchema,
+      AdmitParticipantOperationFrameSchema,
+      DenyAdmissionOperationFrameSchema,
+      MuteParticipantOperationFrameSchema,
+      StopParticipantCameraOperationFrameSchema,
+      StopParticipantScreenShareOperationFrameSchema,
+      RemoveParticipantOperationFrameSchema,
+      StartRecordingOperationFrameSchema,
+      StopRecordingOperationFrameSchema,
+      ParticipantLeaveOperationFrameSchema,
+      StartEpisodeOperationFrameSchema,
+      ExtendEpisodeOperationFrameSchema,
+      EndEpisodeOperationFrameSchema,
+      LiveTargetFrameSchema,
+      DirectedRequestSendFrameSchema,
+      RequestAckFrameSchema,
+      ReactionSendFrameSchema,
+      ChatSendFrameSchema,
+      ChatPageRequestFrameSchema,
+      ChatReadSetFrameSchema,
+      DeliveryAckFrameSchema,
+      RecoveryAckFrameSchema,
+      PingFrameSchema
+    ])
+  )
+).check(boundedFrame(SyncProtocolLimits.decodedInboundFrameBytes));
+var SyncV1ServerFrameSchema = Schema.Unknown.check(Schema.makeFilter((frame) => strictServerFrame(frame) ? void 0 : { path: [], issue: "must not contain unknown or missing fields" })).pipe(
+  Schema.decodeTo(
+    Schema.Union([
+      WelcomeFrameSchema,
+      ReplayPageFrameSchema,
+      RecoveryCompleteFrameSchema,
+      EventFrameSchema,
+      CommittedAckFrameSchema,
+      SatisfiedAckFrameSchema,
+      RejectedAckFrameSchema,
+      CommandIdConflictAckFrameSchema,
+      ProjectionFrameSchema,
+      LiveTargetResultFrameSchema,
+      DirectedRequestDeliverFrameSchema,
+      DirectedRequestResultFrameSchema,
+      ReactionEventFrameSchema,
+      ReactionResultFrameSchema,
+      ChatMessageFrameSchema,
+      ChatSendResultFrameSchema,
+      ChatPageFrameSchema,
+      ChatHeadFrameSchema,
+      ChatReadReceiptFrameSchema,
+      ChatReadResultFrameSchema,
+      RetryableErrorFrameSchema,
+      ErrorFrameSchema,
+      PongFrameSchema
+    ])
+  )
+).check(Schema.makeFilter((frame) => serverFrameWithinLimit(frame) ? void 0 : { path: [], issue: "must fit the encoded byte limit including correlation reserve" }));
+function encodeSyncFrame(frame) {
+  return JSON.stringify(frame);
+}
+
+// src/collaboration/wire.ts
+function reactionFromFrame(frame) {
+  return {
+    eventId: frame.event_id,
+    participantId: frame.participant_id,
+    displayName: frame.display_name,
+    reaction: frame.reaction,
+    occurredAt: frame.occurred_at,
+    expiresAt: frame.expires_at
+  };
+}
+function chatMessageFromFrame(frame) {
+  return {
+    messageId: frame.message_id,
+    clientMessageId: frame.client_message_id,
+    sequence: frame.sequence,
+    participantId: frame.participant_id,
+    displayName: frame.display_name,
+    text: frame.text,
+    createdAt: frame.created_at,
+    attachments: "attachments" in frame ? frame.attachments.map((attachment) => ({
+      attachmentId: attachment.attachment_id,
+      fileName: attachment.file_name,
+      mimeType: attachment.mime_type,
+      byteLength: attachment.byte_length
+    })) : []
+  };
+}
+function chatReadReceiptFromFrame(frame) {
+  return {
+    participantId: frame.participant_id,
+    participantGeneration: frame.participant_generation,
+    readThroughSequence: frame.sequence,
+    readAt: frame.read_at
+  };
+}
+
+// src/sync/v1-codec.ts
+import { Schema as Schema2 } from "effect";
+function encodeV1ClientFrame(frame) {
+  return encodeSyncFrame(Schema2.decodeUnknownSync(SyncV1ClientFrameSchema)(frame));
+}
+function decodeV1ServerFrame(wire) {
+  return Schema2.decodeUnknownSync(SyncV1ServerFrameSchema)(JSON.parse(wire));
+}
+function decodeV1ClientFrame(value) {
+  return Schema2.decodeUnknownSync(SyncV1ClientFrameSchema)(value);
+}
+
+// src/sync/v1-persistence.ts
+var InMemoryV1PendingTargetStore = class {
+  #commands = /* @__PURE__ */ new Map();
+  constructor(commands = []) {
+    for (const command of commands) this.#commands.set(command.commandId, structuredClone(command));
+  }
+  async load() {
+    return [...this.#commands.values()].map((command) => structuredClone(command)).sort(comparePending);
+  }
+  async put(command) {
+    this.#commands.set(command.commandId, structuredClone(command));
+  }
+  async remove(commandId) {
+    this.#commands.delete(commandId);
+  }
+};
+function compareV1PendingTargets(left, right) {
+  return comparePending(left, right);
+}
+function comparePending(left, right) {
+  return left.createdAt - right.createdAt || left.commandId.localeCompare(right.commandId);
+}
+
+// src/sync/v1-reducer.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+var encoder2 = new TextEncoder();
+var digestPrefix = encoder2.encode("chalk-sync-state-v1");
+var V1ReplicaError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "V1ReplicaError";
+  }
+};
+async function restoreV1Snapshot(snapshot) {
+  const state = snapshotToState(snapshot);
+  assertV1ControlSemantics(state);
+  await assertDigest(state);
+  return state;
+}
+async function applyV1Event(state, event) {
+  if (event.revision <= state.revision) throw new V1ReplicaError("duplicate control event requires retained client evidence");
+  if (state.status === "ended") throw new V1ReplicaError("ended control state cannot advance");
+  if (event.base_revision !== state.revision || event.revision !== state.revision + 1) throw new V1ReplicaError("control event is not exact-next");
+  if (event.schema_version !== state.stateSchemaVersion) throw new V1ReplicaError("control event schema version changed");
+  const next = reduceEvent(state, event);
+  const candidate = { ...next, revision: event.revision, stateDigest: event.resulting_state_digest };
+  assertV1ControlSemantics(candidate);
+  await assertDigest(candidate);
+  return candidate;
+}
+function optimisticV1Control(state, actorId, commands) {
+  return commands.reduce((current, command) => applyOptimistic(current, actorId, command), state);
+}
+function snapshotToState(snapshot) {
+  const roleCapabilities = Object.fromEntries(Object.entries(snapshot.role_capabilities).map(([role, capabilities]) => [role, [...capabilities]]));
+  return {
+    revision: snapshot.control_revision,
+    stateSchemaVersion: snapshot.state_schema_version,
+    stateDigest: snapshot.state_digest,
+    status: snapshot.status,
+    admissionPolicy: snapshot.admission_policy,
+    deadlineAtMs: snapshot.deadline_at_ms,
+    deadlineGeneration: snapshot.deadline_generation,
+    roleCapabilities,
+    recording: snapshot.recording && { recordingId: snapshot.recording.recording_id, status: snapshot.recording.status, failureCode: snapshot.recording.failure_code },
+    participants: snapshot.participants.map((participant) => ({
+      participantId: participant.participant_id,
+      displayName: participant.display_name,
+      handRaised: participant.hand_raised,
+      admissionRevision: participant.admission_revision,
+      role: participant.role,
+      // The canonical wire contract carries one requested/assigned role. Keep
+      // the former list-shaped alias for consumers that still render it.
+      eligibleRoles: [participant.role],
+      capabilities: [...participant.capabilities]
+    })),
+    admissionRequests: snapshot.admission_requests.map((request) => ({
+      admissionRequestId: request.admission_request_id,
+      participantId: request.participant_id,
+      displayName: request.display_name,
+      initialRole: request.role,
+      eligibleRoles: [request.role],
+      expiresAtMs: request.expires_at_ms
+    }))
+  };
+}
+function assertV1ControlSemantics(state) {
+  const participantIds = /* @__PURE__ */ new Set();
+  for (const participant of state.participants) {
+    if (participantIds.has(participant.participantId)) throw new V1ReplicaError("duplicate participant ID");
+    participantIds.add(participant.participantId);
+    const capabilities = state.roleCapabilities[participant.role];
+    if (!capabilities) throw new V1ReplicaError("participant role has no capability bundle");
+    if (!sameStrings2(participant.capabilities, capabilities)) throw new V1ReplicaError("participant capabilities do not match the durable role map");
+    if (participant.displayName !== participant.displayName.trim() || participant.displayName.length === 0) throw new V1ReplicaError("participant display name has surrounding whitespace");
+  }
+  if (state.status === "ended" && (state.participants.length !== 0 || state.admissionRequests.length !== 0 || state.recording !== null)) {
+    throw new V1ReplicaError("ended control state retains active Episode state");
+  }
+  const requestIds = /* @__PURE__ */ new Set();
+  const pendingParticipantIds = /* @__PURE__ */ new Set();
+  for (const request of state.admissionRequests) {
+    if (requestIds.has(request.admissionRequestId)) throw new V1ReplicaError("duplicate admission request ID");
+    if (pendingParticipantIds.has(request.participantId) || participantIds.has(request.participantId)) throw new V1ReplicaError("active and pending participant IDs overlap");
+    requestIds.add(request.admissionRequestId);
+    pendingParticipantIds.add(request.participantId);
+    if (request.displayName !== request.displayName.trim() || request.displayName.length === 0) throw new V1ReplicaError("admission display name has surrounding whitespace");
+  }
+  if (state.recording?.status === "failed" ? state.recording.failureCode === null : state.recording?.failureCode !== null && state.recording !== null) {
+    throw new V1ReplicaError("recording failure code does not match its status");
+  }
+}
+async function computeV1StateDigest(state) {
+  const version = new Uint8Array(4);
+  new DataView(version.buffer).setUint32(0, state.stateSchemaVersion, false);
+  const bytes = joinBytes(digestPrefix, version, canonicalJsonBytesFromUnknown(durableProjection(state)));
+  return Array.from(sha256(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function durableProjection(state) {
+  return {
+    admission_policy: state.admissionPolicy,
+    admission_requests: state.admissionRequests.map((request) => ({
+      admission_request_id: request.admissionRequestId,
+      display_name: request.displayName,
+      expires_at_ms: request.expiresAtMs,
+      participant_id: request.participantId,
+      role: request.initialRole
+    })),
+    control_revision: state.revision,
+    deadline_at_ms: state.deadlineAtMs,
+    deadline_generation: state.deadlineGeneration,
+    participants: [...state.participants].sort((left, right) => left.participantId.localeCompare(right.participantId)).map((participant) => ({
+      admission_revision: participant.admissionRevision,
+      capabilities: state.roleCapabilities[participant.role],
+      display_name: participant.displayName,
+      hand_raised: participant.handRaised,
+      participant_id: participant.participantId,
+      role: participant.role
+    })),
+    recording: state.recording && { failure_code: state.recording.failureCode, recording_id: state.recording.recordingId, status: state.recording.status },
+    role_capabilities: state.roleCapabilities,
+    state_schema_version: state.stateSchemaVersion,
+    status: state.status
+  };
+}
+async function assertDigest(state) {
+  if (await computeV1StateDigest(state) !== state.stateDigest) throw new V1ReplicaError("control state digest mismatch");
+}
+function reduceEvent(state, event) {
+  switch (event.name) {
+    case "participant_joined": {
+      if (state.participants.some((participant2) => participant2.participantId === event.payload.participant_id)) throw new V1ReplicaError("duplicate participant join");
+      const participant = participantFromJoin(state, event.payload);
+      return {
+        ...state,
+        participants: [...state.participants, participant],
+        admissionRequests: state.admissionRequests.filter((request) => request.participantId !== participant.participantId)
+      };
+    }
+    case "participant_left":
+      return removeParticipant(state, event.payload.participant_id);
+    case "episode_started":
+      return state;
+    case "episode_ended":
+      return { ...state, status: "ended", participants: [], admissionRequests: [], recording: null };
+    case "hand_raised":
+    case "hand_lowered":
+      return updateParticipant(state, event.payload.participant_id, (participant) => ({ ...participant, handRaised: event.name === "hand_raised" }));
+    case "participant_display_name_changed":
+      return updateParticipant(state, event.payload.participant_id, (participant) => ({ ...participant, displayName: event.payload.display_name }));
+    case "admission_policy_changed":
+      return { ...state, admissionPolicy: event.payload.policy };
+    case "role_assigned":
+      return updateParticipant(state, event.payload.participant_id, (participant) => withDerivedRole(state, participant, event.payload.role));
+    case "admission_requested":
+      return { ...state, admissionRequests: [...state.admissionRequests, admissionRequestFromEvent(event.payload)] };
+    case "admission_denied":
+    case "admission_expired":
+      return removeAdmissionRequest(state, event.payload.admission_request_id);
+    case "recording_status_changed":
+      return transitionRecording(state, event.payload);
+    case "deadline_changed":
+      if (event.payload.deadline_generation !== state.deadlineGeneration + 1) throw new V1ReplicaError("deadline generation is not exact-next");
+      return { ...state, deadlineAtMs: event.payload.deadline_at_ms, deadlineGeneration: event.payload.deadline_generation };
+    case "participant_microphone_stopped":
+    case "participant_camera_stopped":
+    case "participant_screen_share_stopped":
+      requireParticipant(state, event.payload.participant_id);
+      return state;
+  }
+}
+function applyOptimistic(state, actorId, command) {
+  switch (command.name) {
+    case "set_hand_raised":
+      return updateParticipant(state, actorId, (participant) => ({ ...participant, handRaised: command.payload.raised }), false);
+    case "set_display_name":
+      return updateParticipant(state, actorId, (participant) => ({ ...participant, displayName: command.payload.display_name }), false);
+    case "set_admission_policy":
+      return { ...state, admissionPolicy: command.payload.policy };
+    case "assign_roles":
+      return updateParticipant(state, command.payload.participant_id, (participant) => withDerivedRole(state, participant, command.payload.role), false);
+  }
+}
+function participantFromJoin(state, payload) {
+  const capabilities = state.roleCapabilities[payload.role];
+  if (!capabilities) throw new V1ReplicaError("participant join references an unknown role");
+  return {
+    participantId: payload.participant_id,
+    displayName: payload.display_name,
+    handRaised: false,
+    admissionRevision: payload.admission_revision,
+    role: payload.role,
+    eligibleRoles: [payload.role],
+    capabilities: [...capabilities]
+  };
+}
+function admissionRequestFromEvent(payload) {
+  return {
+    admissionRequestId: payload.admission_request_id,
+    participantId: payload.participant_id,
+    displayName: payload.display_name,
+    initialRole: payload.role,
+    eligibleRoles: [payload.role],
+    expiresAtMs: payload.expires_at_ms
+  };
+}
+function withDerivedRole(state, participant, role) {
+  const capabilities = state.roleCapabilities[role];
+  if (!capabilities) throw new V1ReplicaError("role assignment references an unknown role");
+  return { ...participant, role, capabilities: [...capabilities] };
+}
+function updateParticipant(state, participantId, update, required = true) {
+  let found = false;
+  const participants = state.participants.map((participant) => {
+    if (participant.participantId !== participantId) return participant;
+    found = true;
+    return update(participant);
+  });
+  if (required && !found) throw new V1ReplicaError("control event references an unknown participant");
+  return found ? { ...state, participants } : state;
+}
+function removeParticipant(state, participantId) {
+  const participants = state.participants.filter((participant) => participant.participantId !== participantId);
+  if (participants.length === state.participants.length) throw new V1ReplicaError("control event references an unknown participant");
+  return { ...state, participants };
+}
+function requireParticipant(state, participantId) {
+  const participant = state.participants.find((candidate) => candidate.participantId === participantId);
+  if (!participant) throw new V1ReplicaError("control event references an unknown participant");
+  return participant;
+}
+function removeAdmissionRequest(state, admissionRequestId) {
+  const admissionRequests = state.admissionRequests.filter((request) => request.admissionRequestId !== admissionRequestId);
+  if (admissionRequests.length === state.admissionRequests.length) throw new V1ReplicaError("control event references an unknown admission request");
+  return { ...state, admissionRequests };
+}
+function transitionRecording(state, payload) {
+  const current = state.recording;
+  if (payload.status === "starting") {
+    if (current !== null && current.status !== "stopped" && current.status !== "failed") throw new V1ReplicaError("Recording is already active");
+    return { ...state, recording: recordingFromPayload(payload) };
+  }
+  if (!current || current.recordingId !== payload.recording_id) throw new V1ReplicaError("Recording transition changed identity");
+  const allowed = current.status === "starting" && (payload.status === "recording" || payload.status === "failed") || current.status === "recording" && (payload.status === "stopping" || payload.status === "failed") || current.status === "stopping" && (payload.status === "stopped" || payload.status === "failed");
+  if (!allowed) throw new V1ReplicaError("illegal Recording status transition");
+  return { ...state, recording: recordingFromPayload(payload) };
+}
+function recordingFromPayload(payload) {
+  return { recordingId: payload.recording_id, status: payload.status, failureCode: payload.failure_code };
+}
+function joinBytes(...parts) {
+  const output = new Uint8Array(parts.reduce((total, part) => total + part.byteLength, 0));
+  let offset = 0;
+  for (const part of parts) {
+    output.set(part, offset);
+    offset += part.byteLength;
+  }
+  return output;
+}
+function sameStrings2(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+
+// src/sync/v1-client.ts
+var encoder3 = new TextEncoder();
+var MAX_IN_FLIGHT = 256;
+var MAX_PENDING_BYTES = 1024 * 1024;
+var MAX_PENDING_AGE_MS = 24 * 60 * 60 * 1e3;
+var MAX_REPLAY_EVENTS = SyncProtocolLimits.completeReplayMaxEvents;
+var MAX_REPLAY_BYTES = SyncProtocolLimits.completeReplayEncodedBytes;
+var MAX_RETRIES = 3;
+var MAX_LIVE_SERVER_RETRIES = 16;
+var LIVE_TARGET_RETRY_BUDGET_MS = 15e3;
+var MAX_LIVE_TARGET_RETRY_DELAY_MS = 1e3;
+var MAX_PROJECTION_EVENT_EVIDENCE = 256;
+var OPERATION_PENDING_POLL_INTERVAL_MS = 1e3;
+var CLIENT_RESTART_CLOSE_CODE = 4e3;
+var MAX_COLLABORATION_REQUESTS_IN_FLIGHT = 64;
+var V1SyncError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "V1SyncError";
+  }
+  code;
+};
+var V1SyncClient = class {
+  #options;
+  #store;
+  #listeners = /* @__PURE__ */ new Set();
+  #requestListeners = /* @__PURE__ */ new Set();
+  #collaborationListeners = /* @__PURE__ */ new Set();
+  #pendingTargets = /* @__PURE__ */ new Map();
+  #reservedCommandIds = /* @__PURE__ */ new Set();
+  #commands = /* @__PURE__ */ new Map();
+  #acknowledgements = /* @__PURE__ */ new Map();
+  #pendingRemovals = /* @__PURE__ */ new Map();
+  #controlHeads = /* @__PURE__ */ new Map();
+  #controlEvents = /* @__PURE__ */ new Map();
+  #liveTargets = /* @__PURE__ */ new Map();
+  #requests = /* @__PURE__ */ new Map();
+  #reactions = /* @__PURE__ */ new Map();
+  #chatSends = /* @__PURE__ */ new Map();
+  #chatPages = /* @__PURE__ */ new Map();
+  #chatReads = /* @__PURE__ */ new Map();
+  #commandRetryTimers = /* @__PURE__ */ new Map();
+  #liveRetryTimers = /* @__PURE__ */ new Map();
+  #liveDeadlineTimers = /* @__PURE__ */ new Map();
+  #pendingRemovalRetryTimers = /* @__PURE__ */ new Map();
+  #mediaEventEvidence = /* @__PURE__ */ new Map();
+  #presenceEventEvidence = /* @__PURE__ */ new Map();
+  #phase = { phase: "idle" };
+  #socket = null;
+  #control = null;
+  #media = null;
+  #presence = null;
+  #participantId = null;
+  #participantGeneration = null;
+  #recovery = null;
+  #started = false;
+  #startupGeneration = 0;
+  #connectionGeneration = 0;
+  #reconnectTimer;
+  #heartbeatTimer;
+  #missedHeartbeats = 0;
+  #unsubscribeLifecycle;
+  #inbound = Promise.resolve();
+  #transportAvailable = true;
+  #online = true;
+  #active = true;
+  #unsubscribeLocalMedia;
+  #unsubscribeRemoteMedia;
+  #localPublications = [];
+  #remotePublications = [];
+  #collaboration;
+  #participantCollaborationCapabilities = {};
+  #chatAfterSequence;
+  #requestedCollaborationVersion;
+  #localMedia = { microphone: "unknown", camera: "unknown", screen: "unknown" };
+  constructor(options) {
+    assertV1Url(options.url);
+    this.#options = options;
+    this.#store = options.pendingStore ?? new InMemoryV1PendingTargetStore();
+    const cursor = options.collaboration === false ? { afterSequence: null, retainedFloorSequence: null } : options.collaboration?.chatCursor ?? { afterSequence: null, retainedFloorSequence: null };
+    this.#chatAfterSequence = cursor.afterSequence;
+    this.#requestedCollaborationVersion = options.collaboration === false ? 0 : 1;
+    this.#collaboration = {
+      negotiated: false,
+      version: null,
+      capabilities: [],
+      chatHeadSequence: null,
+      retainedFloorSequence: cursor.retainedFloorSequence,
+      readReceipts: []
+    };
+  }
+  async start() {
+    if (this.#started) return;
+    this.#started = true;
+    const startupGeneration = ++this.#startupGeneration;
+    let stored;
+    try {
+      stored = await this.#store.load();
+    } catch (error) {
+      if (startupGeneration === this.#startupGeneration) {
+        this.#started = false;
+      }
+      throw error;
+    }
+    if (!this.#started || startupGeneration !== this.#startupGeneration) return;
+    const storedCommandIds = new Set(stored.map((pending) => pending.commandId));
+    for (const commandId of this.#pendingTargets.keys()) {
+      if (storedCommandIds.has(commandId) || this.#commands.has(commandId)) continue;
+      this.#pendingTargets.delete(commandId);
+    }
+    for (const commandId of this.#pendingRemovals.keys()) {
+      if (storedCommandIds.has(commandId)) continue;
+      this.#pendingRemovals.delete(commandId);
+      this.#clearPendingRemovalRetryTimer(commandId);
+    }
+    for (const pending of [...stored].sort(compareV1PendingTargets)) {
+      if (this.#pendingRemovals.has(pending.commandId)) {
+        void this.#removePersistedTarget(pending.commandId, pending);
+      } else if (this.#commands.has(pending.commandId)) {
+        this.#pendingTargets.set(pending.commandId, pending);
+      } else {
+        this.#pendingTargets.delete(pending.commandId);
+        this.#restorePending(pending);
+      }
+    }
+    this.#subscribeMediaPlane(this.#options.mediaPlane);
+    this.#unsubscribeLifecycle = this.#options.lifecycle?.subscribe((event) => this.#handleLifecycle(event));
+    this.#connect();
+  }
+  stop() {
+    this.#started = false;
+    this.#startupGeneration += 1;
+    this.#unsubscribeLifecycle?.();
+    this.#unsubscribeLifecycle = void 0;
+    this.#clearReconnect();
+    this.#clearHeartbeat();
+    this.#clearRetryTimers();
+    this.#clearPendingRemovalRetryTimers();
+    this.#unsubscribeMediaPlane();
+    this.#socket?.close(1e3, "client stopped");
+    this.#socket = null;
+    this.#phase = { phase: "stopped" };
+    this.#rejectEphemeral("client_stopped");
+    this.#rejectCollaboration("client_stopped");
+    this.#collaboration = { ...this.#collaboration, negotiated: false, version: null, capabilities: [], readReceipts: [] };
+    this.#participantCollaborationCapabilities = {};
+    this.#localPublications = [];
+    this.#remotePublications = [];
+    for (const source of ["microphone", "camera", "screen"]) this.#localMedia[source] = "unknown";
+    for (const deferred of this.#commands.values()) rejectDeferred(deferred, new V1SyncError("client_stopped", "client_stopped"));
+    this.#commands.clear();
+    this.#acknowledgements.clear();
+    this.#emit();
+  }
+  getSnapshot() {
+    const pendingCommands = [...this.#pendingTargets.values()].sort(compareV1PendingTargets).map((pending) => pending.command);
+    const optimisticControl = this.#control && this.#participantId ? optimisticV1Control(this.#control, this.#participantId, pendingCommands) : this.#control;
+    return {
+      connection: { ...this.#phase },
+      participantId: this.#participantId,
+      participantGeneration: this.#participantGeneration,
+      control: this.#control,
+      optimisticControl,
+      media: copyProjection(this.#media),
+      presence: copyProjection(this.#presence),
+      mediaPlane: { local: this.#localPublications.map(copyPublication), remote: this.#remotePublications.map(copyPublication) },
+      localMedia: { ...this.#localMedia },
+      pendingCommandCount: this.#pendingTargets.size
+    };
+  }
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    listener(this.getSnapshot());
+    return () => this.#listeners.delete(listener);
+  }
+  onDirectedRequest(listener) {
+    this.#requestListeners.add(listener);
+    return () => this.#requestListeners.delete(listener);
+  }
+  getCollaborationExtensionState() {
+    return { ...this.#collaboration, capabilities: [...this.#collaboration.capabilities], readReceipts: this.#collaboration.readReceipts.map((receipt) => ({ ...receipt })) };
+  }
+  getParticipantCollaborationCapabilities() {
+    return Object.fromEntries(Object.entries(this.#participantCollaborationCapabilities).map(([participantId, capabilities]) => [participantId, [...capabilities]]));
+  }
+  subscribeCollaboration(listener) {
+    this.#collaborationListeners.add(listener);
+    return () => this.#collaborationListeners.delete(listener);
+  }
+  sendReaction(reaction) {
+    this.#assertCollaborationReady("sendReaction");
+    this.#assertCollaborationCapacity();
+    const operationId = this.#nextCollaborationRequestId();
+    const frame = { type: "reaction_send", operation_id: operationId, reaction };
+    encodeV1ClientFrame(frame);
+    const promise = new Promise((resolve, reject) => this.#reactions.set(operationId, { resolve, reject, settled: false }));
+    this.#send(frame);
+    return promise;
+  }
+  sendChatMessage(input) {
+    this.#assertCollaborationReady("sendChat");
+    this.#assertCollaborationCapacity();
+    const clientMessageId = input.clientMessageId ?? this.#nextCollaborationRequestId();
+    this.#assertCollaborationRequestIdAvailable(clientMessageId);
+    const attachments = input.attachments ?? [];
+    const frame = { type: "chat_send", client_message_id: clientMessageId, text: input.text, attachment_ids: attachments.map((attachment) => attachment.attachmentId) };
+    encodeV1ClientFrame(frame);
+    const promise = new Promise((resolve, reject) => this.#chatSends.set(clientMessageId, { resolve, reject, settled: false }));
+    this.#send(frame);
+    return promise;
+  }
+  markChatRead(sequence) {
+    this.#assertCollaborationReady();
+    if (this.#collaboration.version !== 1) throw new V1SyncError("durable chat read receipts require collaboration_v1", "collaboration_unavailable");
+    this.#assertCollaborationCapacity();
+    const requestId = this.#nextCollaborationRequestId();
+    const frame = { type: "chat_read_set", request_id: requestId, sequence };
+    encodeV1ClientFrame(frame);
+    const promise = new Promise((resolve, reject) => this.#chatReads.set(requestId, { resolve, reject, settled: false }));
+    this.#send(frame);
+    return promise;
+  }
+  readChatPage(input) {
+    this.#assertCollaborationReady();
+    this.#assertCollaborationCapacity();
+    if (input.beforeSequence !== void 0 && input.afterSequence !== void 0) throw new V1SyncError("a chat page cannot declare both cursors", "invalid_payload");
+    const requestId = this.#nextCollaborationRequestId();
+    const frame = {
+      type: "chat_page_request",
+      request_id: requestId,
+      direction: input.afterSequence === void 0 ? "older" : "newer",
+      cursor_sequence: input.afterSequence ?? input.beforeSequence ?? null,
+      limit: input.limit
+    };
+    encodeV1ClientFrame(frame);
+    const promise = new Promise((resolve, reject) => this.#chatPages.set(requestId, { resolve, reject, settled: false }));
+    this.#send(frame);
+    return promise;
+  }
+  setHandRaised(raised, options) {
+    return this.#sendTarget({ name: "set_hand_raised", payload: { raised } }, options);
+  }
+  setDisplayName(displayName, options) {
+    return this.#sendTarget({ name: "set_display_name", payload: { display_name: displayName } }, options);
+  }
+  setAdmissionPolicy(policy, options) {
+    return this.#sendTarget({ name: "set_admission_policy", payload: { policy } }, options);
+  }
+  assignRole(participantId, role, options) {
+    return this.#sendTarget({ name: "assign_roles", payload: { participant_id: participantId, role } }, options);
+  }
+  admit(admissionRequestId, options) {
+    return this.#sendOperation("admit_participant", { admission_request_id: admissionRequestId }, options);
+  }
+  deny(admissionRequestId, options) {
+    return this.#sendOperation("deny_admission", { admission_request_id: admissionRequestId }, options);
+  }
+  muteParticipant(participantId, options) {
+    return this.#sendOperation("mute_participant", { participant_id: participantId }, options);
+  }
+  stopParticipantCamera(participantId, options) {
+    return this.#sendOperation("stop_participant_camera", { participant_id: participantId }, options);
+  }
+  stopParticipantScreenShare(participantId, options) {
+    return this.#sendOperation("stop_participant_screen_share", { participant_id: participantId }, options);
+  }
+  removeParticipant(participantId, options) {
+    return this.#sendOperation("remove_participant", { participant_id: participantId }, options);
+  }
+  startRecording(options) {
+    const recordingId = options?.recordingId ?? this.#nextRequestId();
+    return this.#sendOperation("start_recording", { recording_id: recordingId }, options).then((result) => ({ recordingId, result }));
+  }
+  stopRecording(recordingId, options) {
+    return this.#sendOperation("stop_recording", { recording_id: recordingId }, options);
+  }
+  leave(options) {
+    return this.#sendOperation("participant_leave", {}, options);
+  }
+  endEpisode(options) {
+    return this.#sendOperation("end_episode", {}, options);
+  }
+  extendEpisode(minutes, options) {
+    if (!Number.isSafeInteger(minutes) || minutes < 1) throw new V1SyncError("episode extension must be a positive whole number of minutes", "invalid_payload");
+    return this.#sendOperation("extend_episode", { extension_seconds: minutes * 60 }, options);
+  }
+  setMicrophoneEnabled(enabled, options) {
+    return this.#sendLiveTarget("set_microphone_enabled", "microphone", enabled, options);
+  }
+  setCameraEnabled(enabled, options) {
+    return this.#sendLiveTarget("set_camera_enabled", "camera", enabled, options);
+  }
+  setScreenShareEnabled(enabled, options) {
+    return this.#sendLiveTarget("set_screen_share_enabled", "screen", enabled, options);
+  }
+  requestUnmute(participantId, options) {
+    return this.#sendDirectedRequest("request_unmute", participantId, options);
+  }
+  requestStartCamera(participantId, options) {
+    return this.#sendDirectedRequest("request_start_camera", participantId, options);
+  }
+  async #sendTarget(command, options) {
+    this.#assertCapacity();
+    const commandId = options?.commandId ?? this.#nextCommandId();
+    if (this.#commands.has(commandId) || this.#pendingTargets.has(commandId) || this.#pendingRemovals.has(commandId) || this.#reservedCommandIds.has(commandId)) throw new V1SyncError("command ID is already pending", "command_id_conflict");
+    const frame = { type: "command", command_id: commandId, name: command.name, payload: command.payload };
+    encodeV1ClientFrame(frame);
+    const pending = { commandId, command, createdAt: this.#now(), bytes: encoder3.encode(JSON.stringify(frame)).byteLength };
+    if (this.#pendingBytes() + pending.bytes > (this.#options.maxPendingBytes ?? MAX_PENDING_BYTES)) throw new V1SyncError("pending target byte capacity exceeded", "capacity");
+    this.#reservedCommandIds.add(commandId);
+    try {
+      await this.#store.put(pending);
+      this.#pendingTargets.set(commandId, pending);
+      const promise = this.#registerCommand(commandId, frame, true, pending.createdAt);
+      this.#sendIfLive(frame);
+      this.#emit();
+      return promise;
+    } finally {
+      this.#reservedCommandIds.delete(commandId);
+    }
+  }
+  #sendOperation(name, payload, options) {
+    this.#assertCapacity();
+    const commandId = options?.commandId ?? this.#nextCommandId();
+    if (this.#commands.has(commandId) || this.#pendingTargets.has(commandId) || this.#pendingRemovals.has(commandId) || this.#reservedCommandIds.has(commandId)) throw new V1SyncError("command ID is already pending", "command_id_conflict");
+    const frame = { type: "operation", command_id: commandId, name, payload };
+    encodeV1ClientFrame(frame);
+    const promise = this.#registerCommand(commandId, frame, false, this.#now());
+    this.#sendIfLive(frame);
+    return promise;
+  }
+  #sendLiveTarget(name, source, enabled, options) {
+    this.#assertCapacity();
+    if (this.#phase.phase !== "live" || !this.#participantId) return Promise.reject(new V1SyncError("self-media targets require a live participant", "not_live"));
+    if (!this.#options.mediaPlane) return Promise.reject(new V1SyncError("a client MediaPlane adapter is required for self-media targets", "media_plane_unavailable"));
+    const operationId = options?.requestId ?? this.#nextRequestId();
+    if (this.#liveTargets.has(operationId) || this.#requests.has(operationId)) throw new V1SyncError("request ID is already pending", "request_id_conflict");
+    const frame = { type: "live_target", operation_id: operationId, name, enabled };
+    encodeV1ClientFrame(frame);
+    let deferred;
+    const promise = new Promise((resolve, reject) => {
+      deferred = {
+        resolve,
+        reject,
+        settled: false,
+        frame,
+        createdAt: this.#now(),
+        serverRetries: 0,
+        localRetries: 0,
+        localInFlight: false,
+        source,
+        enabled
+      };
+      this.#liveTargets.set(operationId, deferred);
+    });
+    const deadlineTimer = this.#clock().setTimeout(() => {
+      this.#liveDeadlineTimers.delete(operationId);
+      if (this.#liveTargets.get(operationId) === deferred) this.#failLiveTarget(operationId, deferred, new V1SyncError("self-media target confirmation timed out", "retry_exhausted"));
+    }, LIVE_TARGET_RETRY_BUDGET_MS);
+    this.#liveDeadlineTimers.set(operationId, deadlineTimer);
+    this.#localMedia[source] = "requesting";
+    this.#sendIfLive(frame);
+    this.#emit();
+    return promise;
+  }
+  #sendDirectedRequest(name, participantId, options) {
+    this.#assertCapacity();
+    if (this.#phase.phase !== "live") return Promise.reject(new V1SyncError("directed requests are live-only and are never queued for replay", "not_live"));
+    const requestId = options?.requestId ?? this.#nextRequestId();
+    if (this.#requests.has(requestId) || this.#liveTargets.has(requestId)) throw new V1SyncError("request ID is already pending", "request_id_conflict");
+    const frame = { type: "directed_request", request_id: requestId, name, target_participant_id: participantId };
+    encodeV1ClientFrame(frame);
+    const promise = new Promise((resolve, reject) => this.#requests.set(requestId, { resolve, reject, settled: false, frame }));
+    this.#send(frame);
+    return promise;
+  }
+  #registerCommand(commandId, frame, durableTarget, createdAt) {
+    if (this.#commands.has(commandId)) throw new V1SyncError("command ID is already pending", "command_id_conflict");
+    return new Promise((resolve, reject) => this.#commands.set(commandId, { resolve, reject, settled: false, frame, retries: 0, durableTarget, createdAt }));
+  }
+  #connect() {
+    if (!this.#started || !this.#transportAvailable || this.#socket) return;
+    this.#phase = { phase: "connecting" };
+    this.#emit();
+    const socket = this.#options.webSocket.connect(this.#options.url);
+    const connectionGeneration = ++this.#connectionGeneration;
+    this.#socket = socket;
+    socket.onopen = () => void this.#authenticate(socket);
+    socket.onmessage = (event) => {
+      this.#inbound = this.#inbound.then(() => this.#receive(socket, event.data));
+    };
+    socket.onclose = () => {
+      this.#clock().setTimeout(() => {
+        if (connectionGeneration !== this.#connectionGeneration) return;
+        this.#inbound = this.#inbound.then(() => this.#disconnected(socket));
+      }, 0);
+    };
+    socket.onerror = () => socket.close(CLIENT_RESTART_CLOSE_CODE, "transport error");
+  }
+  async #authenticate(socket) {
+    try {
+      const token = await this.#options.token();
+      if (socket !== this.#socket) return;
+      this.#phase = { phase: "recovering" };
+      const hello = {
+        type: "hello",
+        protocol: 1,
+        token,
+        streams: {
+          control: { cursor: this.#control && { revision: this.#control.revision, state_schema_version: this.#control.stateSchemaVersion, state_digest: this.#control.stateDigest } },
+          media: { cursor: null },
+          presence: { cursor: null },
+          requests: { cursor: null }
+        },
+        ...this.#options.telemetry ? syncTelemetryCorrelation(this.#options.telemetry) : {}
+      };
+      if (this.#requestedCollaborationVersion === 0) {
+        this.#send(hello);
+      } else {
+        const chat_cursor = {
+          after_sequence: this.#chatAfterSequence,
+          retained_floor_sequence: this.#collaboration.retainedFloorSequence
+        };
+        this.#send({ ...hello, extensions: [{ name: "collaboration_v1", chat_cursor }] });
+      }
+      this.#emit();
+    } catch {
+      socket.close(CLIENT_RESTART_CLOSE_CODE, "authentication failed");
+    }
+  }
+  async #receive(socket, data) {
+    if (socket !== this.#socket) return;
+    try {
+      if (typeof data !== "string" || encoder3.encode(data).byteLength > SyncProtocolLimits.snapshotEncodedBytes) throw new V1ReplicaError("invalid inbound frame size");
+      await this.#handleFrame(decodeV1ServerFrame(data));
+    } catch {
+      this.#recover("invalid_frame");
+    }
+  }
+  async #handleFrame(frame) {
+    switch (frame.type) {
+      case "welcome":
+        await this.#welcome(frame);
+        return;
+      case "replay_page":
+        await this.#replay(frame);
+        return;
+      case "recovery_complete":
+        this.#completeRecovery(frame);
+        return;
+      case "projection_snapshot":
+        this.#replaceProjection(frame);
+        return;
+      case "projection_event":
+        this.#applyProjection(frame);
+        return;
+      case "event":
+        this.#requireLive();
+        if (frame.revision <= this.#requireControl().revision) {
+          if (this.#controlEvents.get(frame.revision) !== frameSignature(frame)) throw new V1ReplicaError("conflicting or unprovable duplicate control event");
+        } else {
+          this.#control = await applyV1Event(this.#requireControl(), frame);
+          this.#rememberControlHead(this.#control.revision, this.#control.stateDigest);
+          this.#rememberControlEvent(frame);
+        }
+        await this.#settleTerminalLifecycleCommands(frame);
+        await this.#settleProvenCommands();
+        {
+          const control = this.#requireControl();
+          this.#send({ type: "delivery_ack", stream: "control", revision: control.revision, state_digest: control.stateDigest });
+        }
+        this.#emit();
+        return;
+      case "ack":
+        this.#requireLive();
+        await this.#ack(frame);
+        return;
+      case "retryable_error":
+        this.#requireLive();
+        this.#retryCommand(frame.command_id, frame.code);
+        return;
+      case "live_target_result":
+        this.#liveTargetResult(frame);
+        return;
+      case "directed_request_result":
+        this.#requestResult(frame);
+        return;
+      case "directed_request":
+        this.#directedRequest(frame);
+        return;
+      case "reaction":
+        this.#requireLive();
+        this.#requireCollaborationNegotiated();
+        this.#emitCollaboration({ type: "reaction", reaction: reactionFromFrame(frame) });
+        return;
+      case "reaction_result":
+        this.#reactionResult(frame);
+        return;
+      case "chat_message":
+        this.#requireCollaborationNegotiated();
+        this.#observeChatMessage(frame);
+        return;
+      case "chat_send_result":
+        this.#chatSendResult(frame);
+        return;
+      case "chat_page":
+        this.#chatPageResult(frame);
+        return;
+      case "chat_head":
+        this.#requireCollaborationNegotiated();
+        this.#collaboration = {
+          ...this.#collaboration,
+          chatHeadSequence: frame.head_sequence,
+          retainedFloorSequence: frame.retained_floor_sequence
+        };
+        this.#emit();
+        return;
+      case "chat_read_receipt":
+        this.#requireLive();
+        this.#requireCollaborationVersion(1);
+        {
+          const receipt = chatReadReceiptFromFrame(frame);
+          this.#rememberChatReadReceipt(receipt);
+          this.#emitCollaboration({ type: "chat_read_receipt", receipt });
+        }
+        return;
+      case "chat_read_result":
+        this.#chatReadResult(frame);
+        return;
+      case "error":
+        throw new V1ReplicaError(frame.code);
+      case "pong":
+        this.#requireLive();
+        this.#missedHeartbeats = 0;
+        return;
+    }
+  }
+  async #welcome(frame) {
+    if (this.#phase.phase !== "recovering" || this.#recovery) throw new V1ReplicaError("unexpected welcome");
+    if ("extensions" in frame) {
+      const extension = frame.extensions[0];
+      const version = 1;
+      if (this.#requestedCollaborationVersion !== version) throw new V1ReplicaError("collaboration welcome version does not match the requested extension");
+      this.#collaboration = {
+        negotiated: true,
+        version,
+        capabilities: [...extension.capabilities],
+        chatHeadSequence: extension.chat_head_sequence,
+        retainedFloorSequence: extension.retained_floor_sequence,
+        readReceipts: "read_receipts" in extension ? extension.read_receipts.map(chatReadReceiptFromWire) : []
+      };
+      this.#participantCollaborationCapabilities = copyCollaborationCapabilities(extension.participant_capabilities);
+    } else {
+      this.#requestedCollaborationVersion = 0;
+      this.#collaboration = { ...this.#collaboration, negotiated: false, version: null, capabilities: [], readReceipts: [] };
+      this.#participantCollaborationCapabilities = {};
+    }
+    this.#participantId = frame.participant_id;
+    this.#participantGeneration = frame.participant_generation;
+    this.#updateLocalMediaStates();
+    if (frame.mode === "terminal") {
+      await this.#settleTerminalRecoveryCommands(frame);
+      this.#phase = { phase: "terminal", terminalReason: frame.reason };
+      this.#socket?.close(1e3, "terminal recovery");
+      this.#emit();
+      return;
+    }
+    if (frame.mode === "snapshot") {
+      this.#control = await restoreV1Snapshot(frame.snapshot);
+      this.#controlHeads.clear();
+      this.#controlEvents.clear();
+      this.#rememberControlHead(this.#control.revision, this.#control.stateDigest);
+    }
+    if (frame.mode === "replay" && (!this.#control || this.#control.revision >= frame.head.revision)) throw new V1ReplicaError("invalid replay welcome");
+    if (frame.mode === "up_to_date" && !sameHead(this.#control, frame.head)) throw new V1ReplicaError("up-to-date head mismatch");
+    if (frame.mode === "snapshot" && !sameHead(this.#control, frame.head)) throw new V1ReplicaError("snapshot head mismatch");
+    this.#recovery = { id: frame.recovery_id, head: frame.head, replayEvents: 0, replayBytes: 0, controlComplete: false };
+    if (frame.mode !== "replay") this.#ackRecovery();
+    this.#emit();
+  }
+  async #replay(frame) {
+    const recovery = this.#requireRecovery();
+    if (frame.recovery_id !== recovery.id || frame.first_revision !== this.#requireControl().revision + 1) throw new V1ReplicaError("replay page is not exact-next");
+    recovery.replayEvents += frame.events.length;
+    recovery.replayBytes += encoder3.encode(JSON.stringify(frame.events)).byteLength;
+    if (recovery.replayEvents > MAX_REPLAY_EVENTS || recovery.replayBytes > MAX_REPLAY_BYTES) throw new V1ReplicaError("replay exceeds client bounds");
+    for (const event of frame.events) {
+      this.#control = await applyV1Event(this.#requireControl(), event);
+      this.#rememberControlHead(this.#control.revision, this.#control.stateDigest);
+      this.#rememberControlEvent(event);
+    }
+    this.#ackRecovery();
+    this.#emit();
+  }
+  #completeRecovery(frame) {
+    const recovery = this.#requireRecovery();
+    if (frame.recovery_id !== recovery.id || !sameHead(this.#control, frame.head) || !sameRawHead(recovery.head, frame.head)) throw new V1ReplicaError("recovery completed at the wrong head");
+    recovery.controlComplete = true;
+    this.#enterLiveIfReady();
+  }
+  #replaceProjection(frame) {
+    if (this.#phase.phase !== "recovering" && this.#phase.phase !== "live") throw new V1ReplicaError("projection snapshot arrived in the wrong phase");
+    if (frame.stream === "media") {
+      this.#media = { projectionId: frame.projection_id, sequence: 0, items: frame.items.map(mediaItem) };
+      this.#mediaEventEvidence.clear();
+    } else {
+      this.#presence = { projectionId: frame.projection_id, sequence: 0, items: frame.items.map(presenceItem) };
+      this.#presenceEventEvidence.clear();
+    }
+    this.#enterLiveIfReady();
+    this.#emit();
+  }
+  #applyProjection(frame) {
+    this.#requireLive();
+    if (frame.stream === "media") {
+      if (this.#acceptProjectionDuplicate(this.#media, this.#mediaEventEvidence, frame)) return;
+      this.#media = updateProjection(this.#media, frame.projection_id, frame.sequence, mediaItem(frame.item), mediaKey);
+      rememberBoundedEvidence(this.#mediaEventEvidence, frame.sequence, frameSignature(frame), MAX_PROJECTION_EVENT_EVIDENCE);
+    } else {
+      if (this.#acceptProjectionDuplicate(this.#presence, this.#presenceEventEvidence, frame)) return;
+      this.#presence = updateProjection(this.#presence, frame.projection_id, frame.sequence, presenceItem(frame.item), (item) => item.participantId);
+      rememberBoundedEvidence(this.#presenceEventEvidence, frame.sequence, frameSignature(frame), MAX_PROJECTION_EVENT_EVIDENCE);
+    }
+    this.#emit();
+  }
+  async #ack(frame) {
+    const deferred = this.#commands.get(frame.command_id);
+    if (!deferred) return;
+    if (frame.outcome === "rejected" || frame.outcome === "command_id_conflict") {
+      await this.#finishCommand(frame.command_id, frame);
+      return;
+    }
+    if (isTerminalLifecycleOperation(deferred.frame)) {
+      await this.#finishCommand(frame.command_id, frame);
+      return;
+    }
+    if (!this.#ackHeadIsProven(frame)) {
+      const previous = this.#acknowledgements.get(frame.command_id);
+      if (previous && JSON.stringify(previous) !== JSON.stringify(frame)) throw new V1ReplicaError("conflicting duplicate command ACK");
+      this.#acknowledgements.set(frame.command_id, frame);
+      return;
+    }
+    await this.#finishCommand(frame.command_id, frame);
+  }
+  async #settleProvenCommands() {
+    for (const commandId of this.#commands.keys()) {
+      const ack = this.#acknowledgements.get(commandId);
+      if (ack && this.#ackHeadIsProven(ack)) await this.#finishCommand(commandId, ack);
+    }
+  }
+  async #settleTerminalLifecycleCommands(frame) {
+    const operationName = frame.name === "episode_ended" ? "end_episode" : frame.name === "participant_left" && frame.payload.participant_id === this.#participantId ? "participant_leave" : null;
+    if (!operationName) return;
+    for (const [commandId, deferred] of this.#commands) {
+      if (deferred.frame.type !== "operation" || deferred.frame.name !== operationName) continue;
+      await this.#finishCommand(commandId, {
+        type: "ack",
+        command_id: commandId,
+        delivery: "duplicate",
+        outcome: "satisfied",
+        revision: frame.revision,
+        state_digest: frame.resulting_state_digest
+      });
+    }
+  }
+  async #settleTerminalRecoveryCommands(frame) {
+    const satisfiedOperations = /* @__PURE__ */ new Set();
+    if (frame.reason === "episode_ended") {
+      satisfiedOperations.add("end_episode");
+      satisfiedOperations.add("participant_leave");
+    } else if (frame.reason === "participant_inactive") {
+      satisfiedOperations.add("participant_leave");
+    }
+    for (const [commandId, deferred] of this.#commands) {
+      if (deferred.frame.type !== "operation" || !satisfiedOperations.has(deferred.frame.name)) continue;
+      await this.#finishCommand(commandId, {
+        type: "ack",
+        command_id: commandId,
+        delivery: "duplicate",
+        outcome: "satisfied",
+        revision: frame.head.revision,
+        state_digest: frame.head.state_digest
+      });
+    }
+  }
+  #retryCommand(commandId, code) {
+    const deferred = this.#commands.get(commandId);
+    if (!deferred || this.#commandRetryTimers.has(commandId)) return;
+    if (code === "external_operation_pending") {
+      this.#pollPendingOperation(commandId, deferred);
+      return;
+    }
+    if (deferred.retries >= MAX_RETRIES) {
+      rejectDeferred(deferred, new V1SyncError(code, "retry_exhausted"));
+      if (!deferred.durableTarget) this.#commands.delete(commandId);
+      return;
+    }
+    deferred.retries += 1;
+    const timer = this.#clock().setTimeout(() => {
+      this.#commandRetryTimers.delete(commandId);
+      if (this.#commands.get(commandId) === deferred) this.#sendIfLive(deferred.frame);
+    }, this.#options.retryDelayMs ?? 100);
+    this.#commandRetryTimers.set(commandId, timer);
+  }
+  #pollPendingOperation(commandId, deferred) {
+    const remainingAge = (this.#options.maxOperationPendingAgeMs ?? MAX_PENDING_AGE_MS) - (this.#now() - deferred.createdAt);
+    if (remainingAge <= 0) {
+      this.#expirePendingOperation(commandId, deferred);
+      return;
+    }
+    const timer = this.#clock().setTimeout(
+      () => {
+        this.#commandRetryTimers.delete(commandId);
+        if (this.#commands.get(commandId) !== deferred) return;
+        if (this.#now() - deferred.createdAt >= (this.#options.maxOperationPendingAgeMs ?? MAX_PENDING_AGE_MS)) {
+          this.#expirePendingOperation(commandId, deferred);
+          return;
+        }
+        this.#sendIfLive(deferred.frame);
+      },
+      Math.min(OPERATION_PENDING_POLL_INTERVAL_MS, remainingAge)
+    );
+    this.#commandRetryTimers.set(commandId, timer);
+  }
+  #expirePendingOperation(commandId, deferred) {
+    if (this.#commands.get(commandId) !== deferred) return;
+    this.#commands.delete(commandId);
+    this.#acknowledgements.delete(commandId);
+    this.#clearCommandRetryTimer(commandId);
+    let pending;
+    if (deferred.durableTarget) {
+      pending = this.#pendingTargets.get(commandId);
+      this.#pendingTargets.delete(commandId);
+      if (pending) this.#pendingRemovals.set(commandId, pending);
+    }
+    rejectDeferred(deferred, new V1SyncError("external operation remained pending beyond its maximum age", "operation_pending_timeout"));
+    this.#emit();
+    if (pending) void this.#removePersistedTarget(commandId, pending);
+  }
+  #liveTargetResult(frame) {
+    this.#requireLive();
+    const deferred = this.#liveTargets.get(frame.operation_id);
+    if (!deferred || deferred.frame.name !== frame.name) return;
+    if (deferred.serverResultSignature) {
+      if (deferred.serverResultSignature !== frameSignature(frame)) throw new V1ReplicaError("conflicting duplicate live-target result");
+      return;
+    }
+    if (frame.outcome === "retryable_failure") {
+      this.#retryLiveServer(frame.operation_id, deferred, frame.error_code ?? frame.outcome);
+      return;
+    }
+    if (frame.outcome !== "confirmed" && frame.outcome !== "satisfied") {
+      this.#failLiveTarget(frame.operation_id, deferred, new V1SyncError(frame.error_code ?? frame.outcome, frame.outcome));
+      return;
+    }
+    deferred.serverResult = { ...frame, outcome: frame.outcome };
+    deferred.serverResultSignature = frameSignature(frame);
+    this.#clearLiveRetryTimer(frame.operation_id);
+    this.#clearLiveDeadlineTimer(frame.operation_id);
+    this.#executeLocalMediaTarget(frame.operation_id, deferred);
+  }
+  #retryLiveServer(operationId, deferred, errorCode) {
+    if (this.#liveRetryTimers.has(operationId)) return;
+    const remainingBudget = LIVE_TARGET_RETRY_BUDGET_MS - (this.#now() - deferred.createdAt);
+    if (deferred.serverRetries >= MAX_LIVE_SERVER_RETRIES || remainingBudget <= 0) {
+      this.#failLiveTarget(operationId, deferred, new V1SyncError(errorCode, "retry_exhausted"));
+      return;
+    }
+    deferred.serverRetries += 1;
+    const baseDelay = this.#options.retryDelayMs ?? 100;
+    const delay = Math.min(remainingBudget, MAX_LIVE_TARGET_RETRY_DELAY_MS, baseDelay * 2 ** Math.min(deferred.serverRetries - 1, 4));
+    this.#scheduleLiveRetry(operationId, () => this.#sendIfLive(deferred.frame), delay);
+  }
+  #executeLocalMediaTarget(operationId, deferred) {
+    const mediaPlane = this.#options.mediaPlane;
+    const participantId = this.#participantId;
+    if (!mediaPlane || !participantId || deferred.localInFlight || this.#liveTargets.get(operationId) !== deferred) return;
+    deferred.localInFlight = true;
+    let result;
+    try {
+      result = mediaPlane.setLocalPublicationTarget({ operationId, participantId, source: deferred.source, enabled: deferred.enabled });
+    } catch {
+      this.#localMediaResult(operationId, deferred, { outcome: "ambiguous", errorCode: "media_plane_exception" });
+      return;
+    }
+    void result.then((outcome) => this.#localMediaResult(operationId, deferred, validMediaPlaneResult(outcome) ? outcome : { outcome: "ambiguous", errorCode: "invalid_media_plane_result" })).catch(() => this.#localMediaResult(operationId, deferred, { outcome: "ambiguous", errorCode: "media_plane_exception" }));
+  }
+  #localMediaResult(operationId, deferred, result) {
+    if (this.#liveTargets.get(operationId) !== deferred) return;
+    deferred.localInFlight = false;
+    if (result.outcome === "retryable_failure") {
+      if (deferred.localRetries >= MAX_RETRIES) {
+        this.#failLiveTarget(operationId, deferred, new V1SyncError(result.errorCode ?? result.outcome, "retry_exhausted"));
+        return;
+      }
+      deferred.localRetries += 1;
+      this.#scheduleLiveRetry(operationId, () => this.#executeLocalMediaTarget(operationId, deferred));
+      return;
+    }
+    if (result.outcome !== "confirmed" && result.outcome !== "satisfied") {
+      this.#failLiveTarget(operationId, deferred, new V1SyncError(result.errorCode ?? result.outcome, result.outcome));
+      return;
+    }
+    const serverResult = deferred.serverResult;
+    if (!serverResult) throw new V1ReplicaError("local MediaPlane completed before server authorization");
+    this.#liveTargets.delete(operationId);
+    this.#clearLiveRetryTimer(operationId);
+    this.#clearLiveDeadlineTimer(operationId);
+    this.#localMedia[deferred.source] = deferred.enabled ? "enabled" : "disabled";
+    resolveDeferred(deferred, { operationId, name: deferred.frame.name, serverOutcome: serverResult.outcome, mediaPlaneOutcome: result.outcome });
+    this.#emit();
+  }
+  #scheduleLiveRetry(operationId, retry, delay = this.#options.retryDelayMs ?? 100) {
+    const timer = this.#clock().setTimeout(() => {
+      this.#liveRetryTimers.delete(operationId);
+      retry();
+    }, delay);
+    this.#liveRetryTimers.set(operationId, timer);
+  }
+  #failLiveTarget(operationId, deferred, error) {
+    this.#liveTargets.delete(operationId);
+    this.#clearLiveRetryTimer(operationId);
+    this.#clearLiveDeadlineTimer(operationId);
+    this.#localMedia[deferred.source] = "failed";
+    rejectDeferred(deferred, error);
+    this.#emit();
+  }
+  #requestResult(frame) {
+    this.#requireLive();
+    const deferred = this.#requests.get(frame.request_id);
+    if (!deferred) return;
+    this.#requests.delete(frame.request_id);
+    resolveDeferred(deferred, frame);
+  }
+  #directedRequest(frame) {
+    this.#requireLive();
+    if (frame.expires_at_ms <= this.#now()) return;
+    this.#send({ type: "request_ack", request_id: frame.request_id });
+    for (const listener of this.#requestListeners) listener(frame);
+  }
+  #reactionResult(frame) {
+    this.#requireLive();
+    this.#requireCollaborationNegotiated();
+    const deferred = this.#reactions.get(frame.operation_id);
+    if (!deferred) return;
+    this.#reactions.delete(frame.operation_id);
+    if (frame.outcome === "accepted") {
+      resolveDeferred(deferred, reactionFromFrame(frame.reaction));
+    } else {
+      rejectDeferred(deferred, new V1SyncError(frame.error_code, frame.error_code));
+    }
+  }
+  #chatSendResult(frame) {
+    this.#requireLive();
+    this.#requireCollaborationNegotiated();
+    const deferred = this.#chatSends.get(frame.client_message_id);
+    if (!deferred) return;
+    this.#chatSends.delete(frame.client_message_id);
+    if (frame.outcome === "accepted") {
+      this.#assertChatMessageVersion(frame.message);
+      const message = chatMessageFromFrame(frame.message);
+      this.#rememberChatSequence(message.sequence);
+      resolveDeferred(deferred, message);
+    } else {
+      rejectDeferred(deferred, new V1SyncError(frame.error_code, frame.error_code));
+    }
+  }
+  #chatPageResult(frame) {
+    this.#requireCollaborationNegotiated();
+    const deferred = this.#chatPages.get(frame.request_id);
+    if (!deferred) return;
+    this.#chatPages.delete(frame.request_id);
+    if (frame.outcome === "cursor_reset") {
+      this.#collaboration = { ...this.#collaboration, retainedFloorSequence: frame.retained_floor_sequence };
+      const result = { status: "cursor_reset", retainedFloorSequence: frame.retained_floor_sequence };
+      this.#emitCollaboration({ type: "chat_cursor_reset", retainedFloorSequence: frame.retained_floor_sequence });
+      resolveDeferred(deferred, result);
+      return;
+    }
+    this.#collaboration = {
+      ...this.#collaboration,
+      chatHeadSequence: frame.head_sequence,
+      retainedFloorSequence: frame.retained_floor_sequence
+    };
+    for (const message of frame.messages) {
+      this.#assertChatMessageVersion(message);
+      this.#observeChatMessage(message);
+    }
+    resolveDeferred(deferred, { status: "loaded", count: frame.messages.length, hasOlder: frame.has_more });
+  }
+  #observeChatMessage(frame) {
+    this.#assertChatMessageVersion(frame);
+    const message = chatMessageFromFrame(frame);
+    this.#rememberChatSequence(message.sequence);
+    this.#emitCollaboration({ type: "chat_message", message });
+  }
+  #chatReadResult(frame) {
+    this.#requireLive();
+    this.#requireCollaborationVersion(1);
+    const deferred = this.#chatReads.get(frame.request_id);
+    if (!deferred) return;
+    this.#chatReads.delete(frame.request_id);
+    if (frame.outcome === "accepted") {
+      const receipt = chatReadReceiptFromFrame(frame);
+      this.#rememberChatReadReceipt(receipt);
+      resolveDeferred(deferred, receipt);
+    } else {
+      rejectDeferred(deferred, new V1SyncError(frame.error_code, frame.error_code));
+    }
+  }
+  #assertChatMessageVersion(frame) {
+    const version = this.#collaboration.version;
+    if (version === 1 && !("attachments" in frame)) throw new V1ReplicaError("collaboration_v1 received a chat message without attachments");
+  }
+  #rememberChatReadReceipt(receipt) {
+    const existing = this.#collaboration.readReceipts.find((candidate) => candidate.participantId === receipt.participantId && candidate.participantGeneration === receipt.participantGeneration);
+    if (existing && compareUnsignedDecimals(existing.readThroughSequence, receipt.readThroughSequence) >= 0) return;
+    this.#collaboration = {
+      ...this.#collaboration,
+      readReceipts: [...this.#collaboration.readReceipts.filter((candidate) => candidate.participantId !== receipt.participantId || candidate.participantGeneration !== receipt.participantGeneration), receipt]
+    };
+  }
+  #rememberChatSequence(sequence) {
+    if (this.#chatAfterSequence === null || compareUnsignedDecimals(sequence, this.#chatAfterSequence) > 0) this.#chatAfterSequence = sequence;
+    if (this.#collaboration.chatHeadSequence === null || compareUnsignedDecimals(sequence, this.#collaboration.chatHeadSequence) > 0) {
+      this.#collaboration = { ...this.#collaboration, chatHeadSequence: sequence };
+    }
+  }
+  #emitCollaboration(event) {
+    for (const listener of this.#collaborationListeners) listener(event);
+  }
+  async #finishCommand(commandId, result) {
+    const deferred = this.#commands.get(commandId);
+    if (!deferred) return;
+    this.#commands.delete(commandId);
+    this.#clearCommandRetryTimer(commandId);
+    this.#acknowledgements.delete(commandId);
+    let pending;
+    if (deferred.durableTarget) {
+      pending = this.#pendingTargets.get(commandId);
+      this.#pendingTargets.delete(commandId);
+      if (pending) this.#pendingRemovals.set(commandId, pending);
+    }
+    if (result.outcome === "rejected" || result.outcome === "command_id_conflict") rejectDeferred(deferred, new V1SyncError(result.reason, result.outcome));
+    else resolveDeferred(deferred, result);
+    this.#emit();
+    if (pending) void this.#removePersistedTarget(commandId, pending);
+  }
+  #enterLiveIfReady() {
+    if (!this.#recovery?.controlComplete || !this.#media || !this.#presence) return;
+    this.#recovery = null;
+    this.#phase = { phase: "live" };
+    this.#missedHeartbeats = 0;
+    for (const pending of this.#commands.values()) {
+      pending.retries = 0;
+      this.#send(pending.frame);
+    }
+    for (const pending of this.#liveTargets.values()) {
+      pending.serverRetries = 0;
+      if (pending.serverResult) this.#executeLocalMediaTarget(pending.frame.operation_id, pending);
+      else this.#send(pending.frame);
+    }
+    this.#startHeartbeat();
+    this.#emit();
+  }
+  #ackRecovery() {
+    const recovery = this.#requireRecovery();
+    const control = this.#requireControl();
+    this.#send({ type: "recovery_ack", recovery_id: recovery.id, revision: control.revision, state_digest: control.stateDigest });
+  }
+  #restorePending(pending) {
+    if (this.#pendingTargets.size + this.#pendingRemovals.size >= this.#maxPending() || this.#now() - pending.createdAt > (this.#options.maxPendingAgeMs ?? MAX_PENDING_AGE_MS) || this.#pendingBytes() + pending.bytes > (this.#options.maxPendingBytes ?? MAX_PENDING_BYTES)) {
+      void this.#removePersistedTarget(pending.commandId, pending);
+      return;
+    }
+    const frame = { type: "command", command_id: pending.commandId, name: pending.command.name, payload: pending.command.payload };
+    encodeV1ClientFrame(frame);
+    this.#pendingTargets.set(pending.commandId, pending);
+    this.#commands.set(pending.commandId, { resolve: () => void 0, reject: () => void 0, settled: true, frame, retries: 0, durableTarget: true, createdAt: pending.createdAt });
+  }
+  async #removePersistedTarget(commandId, pending) {
+    this.#pendingRemovals.set(commandId, pending);
+    try {
+      await this.#store.remove(commandId);
+      if (this.#pendingRemovals.get(commandId) !== pending) return;
+      this.#pendingRemovals.delete(commandId);
+      this.#clearPendingRemovalRetryTimer(commandId);
+    } catch {
+      if (this.#pendingRemovals.get(commandId) !== pending) return;
+      this.#schedulePendingRemovalRetry(commandId, pending);
+    }
+  }
+  #schedulePendingRemovalRetry(commandId, pending) {
+    if (!this.#started || this.#pendingRemovalRetryTimers.has(commandId)) return;
+    const timer = this.#clock().setTimeout(() => {
+      this.#pendingRemovalRetryTimers.delete(commandId);
+      void this.#removePersistedTarget(commandId, pending);
+    }, this.#options.retryDelayMs ?? 100);
+    this.#pendingRemovalRetryTimers.set(commandId, timer);
+  }
+  #ackHeadIsProven(ack) {
+    return this.#controlHeads.get(ack.revision) === ack.state_digest;
+  }
+  #rememberControlHead(revision, digest) {
+    this.#controlHeads.set(revision, digest);
+    if (this.#controlHeads.size <= MAX_REPLAY_EVENTS) return;
+    const oldest = this.#controlHeads.keys().next().value;
+    if (oldest !== void 0) this.#controlHeads.delete(oldest);
+  }
+  #rememberControlEvent(event) {
+    rememberBoundedEvidence(this.#controlEvents, event.revision, frameSignature(event), MAX_REPLAY_EVENTS);
+  }
+  #acceptProjectionDuplicate(projection, evidence, frame) {
+    if (!projection || frame.projection_id !== projection.projectionId || frame.sequence > projection.sequence) return false;
+    if (evidence.get(frame.sequence) !== frameSignature(frame)) throw new V1ReplicaError("conflicting or unprovable duplicate projection event");
+    return true;
+  }
+  #disconnected(socket) {
+    if (socket !== this.#socket) return;
+    this.#socket = null;
+    this.#recovery = null;
+    this.#clearHeartbeat();
+    this.#clearRetryTimers();
+    this.#media = null;
+    this.#presence = null;
+    this.#rejectRequests("disconnected_before_delivery");
+    this.#rejectCollaboration("disconnected_before_delivery");
+    this.#collaboration = { ...this.#collaboration, negotiated: false, version: null, capabilities: [], readReceipts: [] };
+    this.#participantCollaborationCapabilities = {};
+    if (!this.#started || !this.#transportAvailable || this.#phase.phase === "terminal") return;
+    this.#phase = { phase: "connecting" };
+    this.#emit();
+    this.#clearReconnect();
+    this.#reconnectTimer = this.#clock().setTimeout(() => {
+      this.#reconnectTimer = void 0;
+      this.#connect();
+    }, this.#options.reconnectDelayMs ?? 250);
+  }
+  #recover(reason) {
+    const socket = this.#socket;
+    if (!socket) return;
+    socket.close(CLIENT_RESTART_CLOSE_CODE, reason);
+    this.#disconnected(socket);
+  }
+  #handleLifecycle(event) {
+    if (event === "online" || event === "offline") this.#online = event === "online";
+    else this.#active = event === "active";
+    this.#transportAvailable = this.#online && this.#active;
+    if (!this.#transportAvailable) this.#socket?.close(CLIENT_RESTART_CLOSE_CODE, "lifecycle unavailable");
+    else this.#connect();
+  }
+  #rejectEphemeral(code) {
+    this.#rejectRequests(code);
+    for (const deferred of this.#liveTargets.values()) rejectDeferred(deferred, new V1SyncError(code, code));
+    this.#liveTargets.clear();
+  }
+  #rejectCollaboration(code) {
+    for (const deferred of this.#reactions.values()) rejectDeferred(deferred, new V1SyncError(code, code));
+    for (const deferred of this.#chatSends.values()) rejectDeferred(deferred, new V1SyncError(code, code));
+    for (const deferred of this.#chatPages.values()) rejectDeferred(deferred, new V1SyncError(code, code));
+    for (const deferred of this.#chatReads.values()) rejectDeferred(deferred, new V1SyncError(code, code));
+    this.#reactions.clear();
+    this.#chatSends.clear();
+    this.#chatPages.clear();
+    this.#chatReads.clear();
+  }
+  #rejectRequests(code) {
+    for (const deferred of this.#requests.values()) rejectDeferred(deferred, new V1SyncError(code, code));
+    this.#requests.clear();
+  }
+  #sendIfLive(frame) {
+    if (this.#phase.phase === "live") this.#send(frame);
+  }
+  #send(frame) {
+    this.#socket?.send(encodeV1ClientFrame(frame));
+  }
+  #requireLive() {
+    if (this.#phase.phase !== "live") throw new V1ReplicaError("live frame arrived before four-stream recovery completed");
+  }
+  #requireCollaborationNegotiated() {
+    if (!this.#collaboration.negotiated) throw new V1ReplicaError("collaboration frame arrived without a negotiated extension");
+  }
+  #requireCollaborationVersion(version) {
+    this.#requireCollaborationNegotiated();
+    if (this.#collaboration.version !== version) throw new V1ReplicaError(`collaboration_v1 frame arrived on a different extension version`);
+  }
+  #requireControl() {
+    if (!this.#control) throw new V1ReplicaError("control replica is unavailable");
+    return this.#control;
+  }
+  #requireRecovery() {
+    if (!this.#recovery || this.#phase.phase !== "recovering") throw new V1ReplicaError("recovery frame arrived outside recovery");
+    return this.#recovery;
+  }
+  #assertCapacity() {
+    if (this.#commands.size + this.#pendingRemovals.size + this.#reservedCommandIds.size + this.#liveTargets.size + this.#requests.size >= this.#maxPending()) throw new V1SyncError("in-flight request capacity exceeded", "capacity");
+  }
+  #assertCollaborationReady(capability) {
+    if (!this.#collaboration.negotiated) throw new V1SyncError("collaboration is unavailable", "collaboration_unavailable");
+    if (this.#phase.phase !== "live") throw new V1SyncError("collaboration requires a live connection", "not_live");
+    if (capability && !this.#collaboration.capabilities.includes(capability)) throw new V1SyncError("collaboration capability denied", "capability_denied");
+  }
+  #assertCollaborationCapacity() {
+    const maximum = Math.min(this.#options.maxPendingCollaborationRequests ?? MAX_COLLABORATION_REQUESTS_IN_FLIGHT, MAX_COLLABORATION_REQUESTS_IN_FLIGHT);
+    if (this.#reactions.size + this.#chatSends.size + this.#chatPages.size + this.#chatReads.size >= maximum) throw new V1SyncError("collaboration in-flight capacity exceeded", "capacity");
+  }
+  #assertCollaborationRequestIdAvailable(id) {
+    if (this.#reactions.has(id) || this.#chatSends.has(id) || this.#chatPages.has(id) || this.#chatReads.has(id)) throw new V1SyncError("collaboration request ID is already pending", "request_id_conflict");
+  }
+  #nextCollaborationRequestId() {
+    const id = this.#nextRequestId();
+    this.#assertCollaborationRequestIdAvailable(id);
+    return id;
+  }
+  #maxPending() {
+    return Math.min(this.#options.maxPendingCommands ?? MAX_IN_FLIGHT, MAX_IN_FLIGHT);
+  }
+  #pendingBytes() {
+    return [...this.#pendingTargets.values(), ...this.#pendingRemovals.values()].reduce((total, pending) => total + pending.bytes, 0);
+  }
+  #nextCommandId() {
+    return this.#options.ids?.next() ?? crypto.randomUUID();
+  }
+  #nextRequestId() {
+    return this.#options.requestIds?.next() ?? crypto.randomUUID();
+  }
+  #clock() {
+    return this.#options.clock ?? {
+      now: Date.now,
+      setTimeout: (callback, milliseconds) => globalThis.setTimeout(callback, milliseconds),
+      clearTimeout: (handle) => globalThis.clearTimeout(handle)
+    };
+  }
+  #now() {
+    return this.#clock().now();
+  }
+  #clearReconnect() {
+    if (this.#reconnectTimer === void 0) return;
+    this.#clock().clearTimeout(this.#reconnectTimer);
+    this.#reconnectTimer = void 0;
+  }
+  #subscribeMediaPlane(mediaPlane) {
+    if (!mediaPlane) return;
+    try {
+      this.#unsubscribeLocalMedia = mediaPlane.observeLocalPublications((publications) => this.#replaceMediaPlanePublications("local", publications));
+      this.#unsubscribeRemoteMedia = mediaPlane.observeRemotePublications((publications) => this.#replaceMediaPlanePublications("remote", publications));
+    } catch {
+      this.#unsubscribeMediaPlane();
+      this.#started = false;
+      throw new V1SyncError("unable to observe the client MediaPlane", "media_plane_unavailable");
+    }
+  }
+  #unsubscribeMediaPlane() {
+    this.#unsubscribeLocalMedia?.();
+    this.#unsubscribeRemoteMedia?.();
+    this.#unsubscribeLocalMedia = void 0;
+    this.#unsubscribeRemoteMedia = void 0;
+  }
+  #replaceMediaPlanePublications(kind, publications) {
+    if (publications.length > SyncProtocolLimits.projectionMaxItems || !publications.every(validMediaPublication)) return;
+    const copy = publications.map(copyPublication);
+    if (kind === "local") {
+      this.#localPublications = copy;
+      this.#updateLocalMediaStates();
+    } else {
+      this.#remotePublications = copy;
+    }
+    this.#emit();
+  }
+  #updateLocalMediaStates() {
+    if (!this.#participantId) return;
+    for (const source of ["microphone", "camera", "screen"]) {
+      const publication = this.#localPublications.find((candidate) => candidate.source === source && candidate.participantId === this.#participantId);
+      this.#localMedia[source] = publication?.enabled ? "enabled" : "disabled";
+    }
+  }
+  #clearRetryTimers() {
+    for (const timer of this.#commandRetryTimers.values()) this.#clock().clearTimeout(timer);
+    for (const timer of this.#liveRetryTimers.values()) this.#clock().clearTimeout(timer);
+    for (const timer of this.#liveDeadlineTimers.values()) this.#clock().clearTimeout(timer);
+    this.#commandRetryTimers.clear();
+    this.#liveRetryTimers.clear();
+    this.#liveDeadlineTimers.clear();
+  }
+  #clearPendingRemovalRetryTimers() {
+    for (const timer of this.#pendingRemovalRetryTimers.values()) this.#clock().clearTimeout(timer);
+    this.#pendingRemovalRetryTimers.clear();
+  }
+  #clearPendingRemovalRetryTimer(commandId) {
+    const timer = this.#pendingRemovalRetryTimers.get(commandId);
+    if (timer === void 0) return;
+    this.#clock().clearTimeout(timer);
+    this.#pendingRemovalRetryTimers.delete(commandId);
+  }
+  #clearLiveRetryTimer(operationId) {
+    const timer = this.#liveRetryTimers.get(operationId);
+    if (timer === void 0) return;
+    this.#clock().clearTimeout(timer);
+    this.#liveRetryTimers.delete(operationId);
+  }
+  #clearLiveDeadlineTimer(operationId) {
+    const timer = this.#liveDeadlineTimers.get(operationId);
+    if (timer === void 0) return;
+    this.#clock().clearTimeout(timer);
+    this.#liveDeadlineTimers.delete(operationId);
+  }
+  #clearCommandRetryTimer(commandId) {
+    const timer = this.#commandRetryTimers.get(commandId);
+    if (timer === void 0) return;
+    this.#clock().clearTimeout(timer);
+    this.#commandRetryTimers.delete(commandId);
+  }
+  #startHeartbeat() {
+    this.#clearHeartbeat();
+    this.#heartbeatTimer = this.#clock().setTimeout(() => {
+      this.#heartbeatTimer = void 0;
+      if (this.#phase.phase !== "live") return;
+      this.#missedHeartbeats += 1;
+      if (this.#missedHeartbeats > 2) {
+        this.#socket?.close(CLIENT_RESTART_CLOSE_CODE, "heartbeat timeout");
+        return;
+      }
+      this.#send({ type: "ping" });
+      this.#startHeartbeat();
+    }, 2e4);
+  }
+  #clearHeartbeat() {
+    if (this.#heartbeatTimer === void 0) return;
+    this.#clock().clearTimeout(this.#heartbeatTimer);
+    this.#heartbeatTimer = void 0;
+  }
+  #emit() {
+    const snapshot = this.getSnapshot();
+    for (const listener of this.#listeners) listener(snapshot);
+  }
+};
+function updateProjection(projection, projectionId, sequence, item, key) {
+  if (!projection || projection.projectionId !== projectionId) throw new V1ReplicaError("projection event has no matching replace snapshot");
+  if (sequence !== projection.sequence + 1) throw new V1ReplicaError("projection event is not exact-next");
+  const itemKey = key(item);
+  return { projectionId, sequence, items: [...projection.items.filter((candidate) => key(candidate) !== itemKey), item] };
+}
+function mediaItem(item) {
+  return { participantId: item.participant_id, source: item.source, enabled: item.enabled, publicationId: item.publication_id };
+}
+function presenceItem(item) {
+  return { participantId: item.participant_id, state: item.state, speaking: item.speaking, activeSpeaker: item.active_speaker };
+}
+function mediaKey(item) {
+  return `${item.participantId}:${item.source}`;
+}
+function sameHead(control, head) {
+  return control !== null && control.revision === head.revision && control.stateSchemaVersion === head.state_schema_version && control.stateDigest === head.state_digest;
+}
+function sameRawHead(left, right) {
+  return left.revision === right.revision && left.state_schema_version === right.state_schema_version && left.state_digest === right.state_digest;
+}
+function copyProjection(projection) {
+  return projection && { ...projection, items: projection.items.map((item) => ({ ...item })) };
+}
+function frameSignature(frame) {
+  return new TextDecoder().decode(canonicalJsonBytesFromUnknown(frame));
+}
+function copyCollaborationCapabilities(capabilities) {
+  return Object.fromEntries(Object.entries(capabilities).map(([participantId, values]) => [participantId, [...values]]));
+}
+function chatReadReceiptFromWire(receipt) {
+  return {
+    participantId: receipt.participant_id,
+    participantGeneration: receipt.participant_generation,
+    readThroughSequence: receipt.sequence,
+    readAt: receipt.read_at
+  };
+}
+function compareUnsignedDecimals(left, right) {
+  if (left.length !== right.length) return left.length - right.length;
+  return left.localeCompare(right);
+}
+function rememberBoundedEvidence(evidence, sequence, signature, capacity) {
+  evidence.set(sequence, signature);
+  if (evidence.size <= capacity) return;
+  const oldest = evidence.keys().next().value;
+  if (oldest !== void 0) evidence.delete(oldest);
+}
+function resolveDeferred(deferred, value) {
+  if (deferred.settled) return;
+  deferred.settled = true;
+  deferred.resolve(value);
+}
+function rejectDeferred(deferred, error) {
+  if (deferred.settled) return;
+  deferred.settled = true;
+  deferred.reject(error);
+}
+function copyPublication(publication) {
+  return { ...publication };
+}
+function validMediaPublication(publication) {
+  return typeof publication.participantId === "string" && publication.participantId.length > 0 && (publication.source === "microphone" || publication.source === "camera" || publication.source === "screen") && typeof publication.enabled === "boolean" && (publication.publicationId === null || typeof publication.publicationId === "string") && publication.enabled === (publication.publicationId !== null);
+}
+function validMediaPlaneResult(result) {
+  return (result.outcome === "confirmed" || result.outcome === "satisfied" || result.outcome === "retryable_failure" || result.outcome === "terminal_failure" || result.outcome === "ambiguous") && (result.errorCode === null || typeof result.errorCode === "string");
+}
+function isTerminalLifecycleOperation(frame) {
+  return frame.type === "operation" && (frame.name === "participant_leave" || frame.name === "end_episode");
+}
+function assertV1Url(value) {
+  const url = new URL(value);
+  if (url.pathname !== "/v1/sync") throw new V1SyncError("SyncEngine v1 websocket URL must use /v1/sync", "invalid_url");
+}
+
+// src/sync/v1-platform-persistence.ts
+var STORE_NAME = "pending_targets";
+var SCOPE_INDEX = "by_scope";
+var STORAGE_PREFIX = "chalk-sync-v1:pending-targets:";
+var IndexedDbV1PendingTargetStore = class {
+  #scope;
+  #databaseName;
+  #indexedDb;
+  #database;
+  constructor(options) {
+    if (!options.scope) throw new Error("v1 pending-target scope must not be empty");
+    this.#scope = options.scope;
+    this.#databaseName = options.databaseName ?? "chalk-sync-v1";
+    this.#indexedDb = options.indexedDb ?? globalThis.indexedDB;
+  }
+  async load() {
+    const database = await this.#open();
+    const transaction = database.transaction(STORE_NAME, "readonly");
+    const records = await requestResult(transaction.objectStore(STORE_NAME).index(SCOPE_INDEX).getAll(this.#scope));
+    await transactionComplete(transaction);
+    return records.filter(isPendingTarget).map(copyPendingTarget);
+  }
+  async put(command) {
+    const database = await this.#open();
+    const transaction = database.transaction(STORE_NAME, "readwrite");
+    transaction.objectStore(STORE_NAME).put({ scope: this.#scope, ...copyPendingTarget(command) });
+    await transactionComplete(transaction);
+  }
+  async remove(commandId) {
+    const database = await this.#open();
+    const transaction = database.transaction(STORE_NAME, "readwrite");
+    transaction.objectStore(STORE_NAME).delete([this.#scope, commandId]);
+    await transactionComplete(transaction);
+  }
+  #open() {
+    this.#database ??= openDatabase(this.#indexedDb, this.#databaseName);
+    return this.#database;
+  }
+};
+var AsyncStorageV1PendingTargetStore = class {
+  #storage;
+  #key;
+  #operations = Promise.resolve();
+  constructor(options) {
+    if (!options.scope) throw new Error("v1 pending-target scope must not be empty");
+    this.#storage = options.storage;
+    this.#key = `${STORAGE_PREFIX}${options.scope}`;
+  }
+  load() {
+    return this.#enqueue(async () => this.#read());
+  }
+  put(command) {
+    return this.#enqueue(async () => {
+      const commands = await this.#read();
+      const next = [...commands.filter((candidate) => candidate.commandId !== command.commandId), copyPendingTarget(command)];
+      await this.#write(next);
+    });
+  }
+  remove(commandId) {
+    return this.#enqueue(async () => this.#write((await this.#read()).filter((command) => command.commandId !== commandId)));
+  }
+  #enqueue(operation) {
+    const result = this.#operations.then(operation, operation);
+    this.#operations = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
+  async #read() {
+    const stored = await this.#storage.getItem(this.#key);
+    if (stored === null) return [];
+    const value = JSON.parse(stored);
+    if (!Array.isArray(value)) throw new Error("v1 pending-target storage is invalid");
+    return value.filter(isPendingTarget).map(copyPendingTarget);
+  }
+  async #write(commands) {
+    if (commands.length === 0) {
+      await this.#storage.removeItem(this.#key);
+      return;
+    }
+    await this.#storage.setItem(this.#key, JSON.stringify(commands.map(copyPendingTarget)));
+  }
+};
+function isPendingTarget(value) {
+  if (!isRecord(value) || typeof value.commandId !== "string" || typeof value.createdAt !== "number" || typeof value.bytes !== "number" || !isTargetCommand(value.command)) return false;
+  try {
+    encodeV1ClientFrame({ type: "command", command_id: value.commandId, name: value.command.name, payload: value.command.payload });
+    return Number.isSafeInteger(value.createdAt) && value.createdAt >= 0 && Number.isSafeInteger(value.bytes) && value.bytes > 0;
+  } catch {
+    return false;
+  }
+}
+function isTargetCommand(value) {
+  return isRecord(value) && typeof value.name === "string" && isRecord(value.payload) && ["set_hand_raised", "set_display_name", "set_admission_policy", "assign_roles"].includes(value.name);
+}
+function copyPendingTarget(command) {
+  return structuredClone(command);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function openDatabase(indexedDb, name) {
+  if (!indexedDb) return Promise.reject(new Error("IndexedDB is unavailable"));
+  return new Promise((resolve, reject) => {
+    const request = indexedDb.open(name, 1);
+    request.onupgradeneeded = () => {
+      const store = request.result.createObjectStore(STORE_NAME, { keyPath: ["scope", "commandId"] });
+      store.createIndex(SCOPE_INDEX, "scope", { unique: false });
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(new Error("unable to open v1 pending-target storage"));
+    request.onblocked = () => reject(new Error("v1 pending-target storage is blocked"));
+  });
+}
+function requestResult(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(new Error("v1 pending-target request failed"));
+  });
+}
+function transactionComplete(transaction) {
+  return new Promise((resolve, reject) => {
+    transaction.oncomplete = () => resolve();
+    transaction.onerror = () => reject(new Error("v1 pending-target transaction failed"));
+    transaction.onabort = () => reject(new Error("v1 pending-target transaction aborted"));
+  });
+}
+
+// src/sync/v1-create.ts
+function createV1SyncClient(options) {
+  const { indexedDb, lifecycle, mediaPlane, pendingStore, persistenceScope, webSocket, ...clientOptions } = options;
+  return new V1SyncClient({
+    ...clientOptions,
+    lifecycle: lifecycle ?? createBrowserSyncLifecycle(),
+    mediaPlane,
+    pendingStore: pendingStore ?? (persistenceScope ? new IndexedDbV1PendingTargetStore({ ...indexedDb, scope: persistenceScope }) : void 0),
+    webSocket: webSocket ?? createBrowserWebSocketFactory()
+  });
+}
+
+export {
+  canonicalJson,
+  canonicalJsonBytes,
+  SyncBrowserCapabilityError,
+  SyncReactNativeCapabilityError,
+  createBrowserWebSocketFactory,
+  createBrowserSyncLifecycle,
+  createReactNativeWebSocketFactory,
+  createReactNativeSyncLifecycle,
+  reactionFromFrame,
+  chatMessageFromFrame,
+  chatReadReceiptFromFrame,
+  encodeV1ClientFrame,
+  decodeV1ServerFrame,
+  decodeV1ClientFrame,
+  InMemoryV1PendingTargetStore,
+  V1ReplicaError,
+  restoreV1Snapshot,
+  applyV1Event,
+  optimisticV1Control,
+  assertV1ControlSemantics,
+  computeV1StateDigest,
+  V1SyncError,
+  V1SyncClient,
+  IndexedDbV1PendingTargetStore,
+  AsyncStorageV1PendingTargetStore,
+  createV1SyncClient
+};