@q9labsai/chalk-client 4.1.15 → 4.1.17

package/dist/{chunk-PWUU6T3R.js → chunk-CZUJNAUI.js}

@@ -1,3 +1,6 @@
+import {
+  recordReconnect
+} from "./chunk-RCDXIDCN.js";
 import {
   syncTelemetryCorrelation
 } from "./chunk-PBSYXPNJ.js";
@@ -1381,7 +1384,7 @@ var SatisfiedAckFrameSchema = Schema.Struct({ type: Schema.Literal("ack"), comma
 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" })
+  Schema.makeFilter((item) => !item.enabled || item.publication_id !== null ? void 0 : { path: [], issue: "enabled requires a publication_id" })
 );
 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" })
@@ -1570,6 +1573,18 @@ function encodeSyncFrame(frame) {
   return JSON.stringify(frame);
 }
 
+// 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/collaboration/wire.ts
 function reactionFromFrame(frame) {
   return {
@@ -1607,40 +1622,27 @@ function chatReadReceiptFromFrame(frame) {
   };
 }
 
-// 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));
+// src/sync/v1-deferred.ts
+function resolveV1Deferred(deferred, value) {
+  if (deferred.settled) return;
+  deferred.settled = true;
+  deferred.resolve(value);
 }
-function decodeV1ClientFrame(value) {
-  return Schema2.decodeUnknownSync(SyncV1ClientFrameSchema)(value);
+function rejectV1Deferred(deferred, error) {
+  if (deferred.settled) return;
+  deferred.settled = true;
+  deferred.reject(error);
 }
 
-// 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);
+// src/sync/v1-error.ts
+var V1SyncError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "V1SyncError";
   }
+  code;
 };
-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";
@@ -1902,93 +1904,25 @@ 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 DEFAULT_RECONNECT_DELAY_MS = 250;
-var MAX_RECONNECT_DELAY_MS = 5e3;
+// src/sync/v1-collaboration-state.ts
 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 {
+var V1CollaborationState = 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;
-  #reconnectAttempt = 0;
-  #heartbeatTimer;
-  #missedHeartbeats = 0;
-  #unsubscribeLifecycle;
-  #inbound = Promise.resolve();
-  #transportAvailable = true;
-  #online = true;
-  #active = true;
-  #unsubscribeLocalMedia;
-  #unsubscribeRemoteMedia;
-  #localPublications = [];
-  #remotePublications = [];
-  #collaboration;
-  #participantCollaborationCapabilities = {};
+  #state;
+  #participantCapabilities = {};
   #chatAfterSequence;
-  #requestedCollaborationVersion;
-  #localMedia = { microphone: "unknown", camera: "unknown", screen: "unknown" };
+  #requestedVersion;
   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 };
+    const cursor = options.request === false ? { afterSequence: null, retainedFloorSequence: null } : options.request?.chatCursor ?? { afterSequence: null, retainedFloorSequence: null };
     this.#chatAfterSequence = cursor.afterSequence;
-    this.#requestedCollaborationVersion = options.collaboration === false ? 0 : 1;
-    this.#collaboration = {
+    this.#requestedVersion = options.request === false ? 0 : 1;
+    this.#state = {
       negotiated: false,
       version: null,
       capabilities: [],
@@ -1997,142 +1931,77 @@ var V1SyncClient = class {
       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();
+  get requestedVersion() {
+    return this.#requestedVersion;
   }
-  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();
+  get helloExtension() {
+    if (this.#requestedVersion === 0) return null;
+    return { name: "collaboration_v1", chat_cursor: { after_sequence: this.#chatAfterSequence, retained_floor_sequence: this.#state.retainedFloorSequence } };
   }
-  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
-    };
+  getState() {
+    return { ...this.#state, capabilities: [...this.#state.capabilities], readReceipts: this.#state.readReceipts.map((receipt) => ({ ...receipt })) };
+  }
+  getParticipantCapabilities() {
+    return Object.fromEntries(Object.entries(this.#participantCapabilities).map(([participantId, capabilities]) => [participantId, [...capabilities]]));
   }
   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]]));
+  acceptWelcome(frame) {
+    if ("extensions" in frame) {
+      const extension = frame.extensions[0];
+      const version = 1;
+      if (this.#requestedVersion !== version) throw new V1ReplicaError("collaboration welcome version does not match the requested extension");
+      this.#state = {
+        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.#participantCapabilities = copyCapabilities(extension.participant_capabilities);
+      return;
+    }
+    this.#requestedVersion = 0;
+    this.#state = { ...this.#state, negotiated: false, version: null, capabilities: [], readReceipts: [] };
+    this.#participantCapabilities = {};
   }
-  subscribeCollaboration(listener) {
-    this.#collaborationListeners.add(listener);
-    return () => this.#collaborationListeners.delete(listener);
+  disconnect(code) {
+    this.#rejectPending(code);
+    this.#state = { ...this.#state, negotiated: false, version: null, capabilities: [], readReceipts: [] };
+    this.#participantCapabilities = {};
   }
   sendReaction(reaction) {
-    this.#assertCollaborationReady("sendReaction");
-    this.#assertCollaborationCapacity();
-    const operationId = this.#nextCollaborationRequestId();
+    this.#assertReady("sendReaction");
+    this.#assertCapacity();
+    const operationId = this.#nextRequestId();
     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;
+    return this.#sendTrackedRequest(operationId, frame, this.#reactions);
   }
   sendChatMessage(input) {
-    this.#assertCollaborationReady("sendChat");
-    this.#assertCollaborationCapacity();
-    const clientMessageId = input.clientMessageId ?? this.#nextCollaborationRequestId();
-    this.#assertCollaborationRequestIdAvailable(clientMessageId);
+    this.#assertReady("sendChat");
+    this.#assertCapacity();
+    const clientMessageId = input.clientMessageId ?? this.#nextRequestId();
+    this.#assertRequestIdAvailable(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;
+    return this.#sendTrackedRequest(clientMessageId, frame, this.#chatSends);
   }
   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();
+    this.#assertReady();
+    if (this.#state.version !== 1) throw new V1SyncError("durable chat read receipts require collaboration_v1", "collaboration_unavailable");
+    this.#assertCapacity();
+    const requestId = this.#nextRequestId();
     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;
+    return this.#sendTrackedRequest(requestId, frame, this.#chatReads);
   }
   readChatPage(input) {
-    this.#assertCollaborationReady();
-    this.#assertCollaborationCapacity();
+    this.#assertReady();
+    this.#assertCapacity();
     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 requestId = this.#nextRequestId();
     const frame = {
       type: "chat_page_request",
       request_id: requestId,
@@ -2140,57 +2009,989 @@ var V1SyncClient = class {
       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;
+    return this.#sendTrackedRequest(requestId, frame, this.#chatPages);
   }
-  setHandRaised(raised, options) {
-    return this.#sendTarget({ name: "set_hand_raised", payload: { raised } }, options);
+  reaction(frame) {
+    this.#requireLive();
+    this.#requireNegotiated();
+    this.#emit({ type: "reaction", reaction: reactionFromFrame(frame) });
   }
-  setDisplayName(displayName, options) {
-    return this.#sendTarget({ name: "set_display_name", payload: { display_name: displayName } }, options);
+  reactionResult(frame) {
+    this.#requireLive();
+    this.#requireNegotiated();
+    const deferred = this.#reactions.get(frame.operation_id);
+    if (!deferred) return;
+    this.#reactions.delete(frame.operation_id);
+    if (frame.outcome === "accepted") resolveV1Deferred(deferred, reactionFromFrame(frame.reaction));
+    else rejectV1Deferred(deferred, new V1SyncError(frame.error_code, frame.error_code));
   }
-  setAdmissionPolicy(policy, options) {
-    return this.#sendTarget({ name: "set_admission_policy", payload: { policy } }, options);
+  chatMessage(frame) {
+    this.#requireNegotiated();
+    this.#observeChatMessage(frame);
   }
-  assignRole(participantId, role, options) {
-    return this.#sendTarget({ name: "assign_roles", payload: { participant_id: participantId, role } }, options);
+  chatSendResult(frame) {
+    this.#requireLive();
+    this.#requireNegotiated();
+    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);
+      resolveV1Deferred(deferred, message);
+    } else {
+      rejectV1Deferred(deferred, new V1SyncError(frame.error_code, frame.error_code));
+    }
   }
-  admit(admissionRequestId, options) {
-    return this.#sendOperation("admit_participant", { admission_request_id: admissionRequestId }, options);
+  chatPage(frame) {
+    this.#requireNegotiated();
+    const deferred = this.#chatPages.get(frame.request_id);
+    if (!deferred) return;
+    this.#chatPages.delete(frame.request_id);
+    if (frame.outcome === "cursor_reset") {
+      this.#state = { ...this.#state, retainedFloorSequence: frame.retained_floor_sequence };
+      const result = { status: "cursor_reset", retainedFloorSequence: frame.retained_floor_sequence };
+      this.#emit({ type: "chat_cursor_reset", retainedFloorSequence: frame.retained_floor_sequence });
+      resolveV1Deferred(deferred, result);
+      return;
+    }
+    this.#state = { ...this.#state, chatHeadSequence: frame.head_sequence, retainedFloorSequence: frame.retained_floor_sequence };
+    for (const message of frame.messages) this.#observeChatMessage(message);
+    resolveV1Deferred(deferred, { status: "loaded", count: frame.messages.length, hasOlder: frame.has_more });
   }
-  deny(admissionRequestId, options) {
-    return this.#sendOperation("deny_admission", { admission_request_id: admissionRequestId }, options);
+  chatHead(frame) {
+    this.#requireNegotiated();
+    this.#state = { ...this.#state, chatHeadSequence: frame.head_sequence, retainedFloorSequence: frame.retained_floor_sequence };
+    this.#options.stateChanged();
   }
-  muteParticipant(participantId, options) {
-    return this.#sendOperation("mute_participant", { participant_id: participantId }, options);
+  chatReadReceipt(frame) {
+    this.#requireLive();
+    this.#requireVersion(1);
+    const receipt = chatReadReceiptFromFrame(frame);
+    this.#rememberChatReadReceipt(receipt);
+    this.#emit({ type: "chat_read_receipt", receipt });
+  }
+  chatReadResult(frame) {
+    this.#requireLive();
+    this.#requireVersion(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);
+      resolveV1Deferred(deferred, receipt);
+    } else {
+      rejectV1Deferred(deferred, new V1SyncError(frame.error_code, frame.error_code));
+    }
+  }
+  #rejectPending(code) {
+    for (const deferred of this.#reactions.values()) rejectV1Deferred(deferred, new V1SyncError(code, code));
+    for (const deferred of this.#chatSends.values()) rejectV1Deferred(deferred, new V1SyncError(code, code));
+    for (const deferred of this.#chatPages.values()) rejectV1Deferred(deferred, new V1SyncError(code, code));
+    for (const deferred of this.#chatReads.values()) rejectV1Deferred(deferred, new V1SyncError(code, code));
+    this.#reactions.clear();
+    this.#chatSends.clear();
+    this.#chatPages.clear();
+    this.#chatReads.clear();
+  }
+  #sendTrackedRequest(requestId, frame, pending) {
+    encodeV1ClientFrame(frame);
+    const promise = new Promise((resolve, reject) => pending.set(requestId, { resolve, reject, settled: false }));
+    this.#options.send(frame);
+    return promise;
+  }
+  #observeChatMessage(frame) {
+    this.#assertChatMessageVersion(frame);
+    const message = chatMessageFromFrame(frame);
+    this.#rememberChatSequence(message.sequence);
+    this.#emit({ type: "chat_message", message });
+  }
+  #assertChatMessageVersion(frame) {
+    if (this.#state.version === 1 && !("attachments" in frame)) throw new V1ReplicaError("collaboration_v1 received a chat message without attachments");
+  }
+  #rememberChatReadReceipt(receipt) {
+    const existing = this.#state.readReceipts.find((candidate) => candidate.participantId === receipt.participantId && candidate.participantGeneration === receipt.participantGeneration);
+    if (existing && compareUnsignedDecimals(existing.readThroughSequence, receipt.readThroughSequence) >= 0) return;
+    this.#state = {
+      ...this.#state,
+      readReceipts: [...this.#state.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.#state.chatHeadSequence === null || compareUnsignedDecimals(sequence, this.#state.chatHeadSequence) > 0) this.#state = { ...this.#state, chatHeadSequence: sequence };
+  }
+  #assertReady(capability) {
+    if (!this.#state.negotiated) throw new V1SyncError("collaboration is unavailable", "collaboration_unavailable");
+    if (!this.#options.isLive()) throw new V1SyncError("collaboration requires a live connection", "not_live");
+    if (capability && !this.#state.capabilities.includes(capability)) throw new V1SyncError("collaboration capability denied", "capability_denied");
+  }
+  #assertCapacity() {
+    const maximum = Math.min(this.#options.maxPendingRequests ?? 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");
+  }
+  #assertRequestIdAvailable(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");
+  }
+  #nextRequestId() {
+    const id = this.#options.requestIds?.next() ?? crypto.randomUUID();
+    this.#assertRequestIdAvailable(id);
+    return id;
+  }
+  #requireLive() {
+    if (!this.#options.isLive()) throw new V1ReplicaError("live frame arrived before four-stream recovery completed");
+  }
+  #requireNegotiated() {
+    if (!this.#state.negotiated) throw new V1ReplicaError("collaboration frame arrived without a negotiated extension");
+  }
+  #requireVersion(version) {
+    this.#requireNegotiated();
+    if (this.#state.version !== version) throw new V1ReplicaError("collaboration_v1 frame arrived on a different extension version");
+  }
+  #emit(event) {
+    for (const listener of this.#listeners) listener(event);
+  }
+};
+function copyCapabilities(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 ? -1 : 1;
+  return left === right ? 0 : left < right ? -1 : 1;
+}
+
+// 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-command-scheduler.ts
+var MAX_IN_FLIGHT = 256;
+var MAX_PENDING_BYTES = 1024 * 1024;
+var MAX_PENDING_AGE_MS = 24 * 60 * 60 * 1e3;
+var MAX_RETRIES = 3;
+var OPERATION_PENDING_POLL_INTERVAL_MS = 1e3;
+var V1CommandScheduler = class {
+  #options;
+  #pendingTargets = /* @__PURE__ */ new Map();
+  #reservedCommandIds = /* @__PURE__ */ new Set();
+  #commands = /* @__PURE__ */ new Map();
+  #acknowledgements = /* @__PURE__ */ new Map();
+  #pendingRemovals = /* @__PURE__ */ new Map();
+  #commandRetryTimers = /* @__PURE__ */ new Map();
+  #pendingRemovalRetryTimers = /* @__PURE__ */ new Map();
+  #stopGeneration = 0;
+  constructor(options) {
+    this.#options = options;
+  }
+  get pendingCount() {
+    return this.#pendingTargets.size;
+  }
+  get inFlightCount() {
+    return this.#commands.size + this.#pendingRemovals.size + this.#reservedCommandIds.size;
+  }
+  get pendingCommands() {
+    return [...this.#pendingTargets.values()].sort(compareV1PendingTargets).map((pending) => pending.command);
+  }
+  load() {
+    return this.#options.store.load();
+  }
+  reconcileStored(stored) {
+    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);
+      }
+    }
+  }
+  stop(code) {
+    this.#stopGeneration += 1;
+    this.#clearCommandRetryTimers();
+    this.#clearPendingRemovalRetryTimers();
+    for (const deferred of this.#commands.values()) rejectV1Deferred(deferred, new V1SyncError(code, code));
+    this.#commands.clear();
+    this.#acknowledgements.clear();
+  }
+  disconnect() {
+    this.#clearCommandRetryTimers();
+  }
+  assertCapacity(externalInFlight) {
+    if (this.inFlightCount + externalInFlight >= this.#maxPending()) throw new V1SyncError("in-flight request capacity exceeded", "capacity");
+  }
+  async sendTarget(command, externalInFlight, options) {
+    this.assertCapacity(externalInFlight);
+    const commandId = options?.commandId ?? this.#nextCommandId();
+    this.#assertCommandIdAvailable(commandId);
+    const frame = targetFrame(commandId, command);
+    encodeV1ClientFrame(frame);
+    const pending = { commandId, command, createdAt: this.#now(), bytes: new TextEncoder().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);
+    const stopGeneration = this.#stopGeneration;
+    try {
+      await this.#options.store.put(pending);
+      if (stopGeneration !== this.#stopGeneration) {
+        this.#pendingTargets.set(commandId, pending);
+        this.#commands.set(commandId, { resolve: () => void 0, reject: () => void 0, settled: true, frame, retries: 0, durableTarget: true, createdAt: pending.createdAt });
+        this.#options.sendIfLive(frame);
+        this.#options.stateChanged();
+        throw new V1SyncError("client_stopped", "client_stopped");
+      }
+      this.#pendingTargets.set(commandId, pending);
+      const promise = this.#registerCommand(commandId, frame, true, pending.createdAt);
+      this.#options.sendIfLive(frame);
+      this.#options.stateChanged();
+      return promise;
+    } finally {
+      this.#reservedCommandIds.delete(commandId);
+    }
+  }
+  sendOperation(createFrame, externalInFlight, options) {
+    this.assertCapacity(externalInFlight);
+    const commandId = options?.commandId ?? this.#nextCommandId();
+    this.#assertCommandIdAvailable(commandId);
+    const frame = createFrame(commandId);
+    encodeV1ClientFrame(frame);
+    const promise = this.#registerCommand(commandId, frame, false, this.#now());
+    this.#options.sendIfLive(frame);
+    return promise;
+  }
+  async acknowledge(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.#options.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 settleProven() {
+    for (const commandId of this.#commands.keys()) {
+      const ack = this.#acknowledgements.get(commandId);
+      if (ack && this.#options.ackHeadIsProven(ack)) await this.#finishCommand(commandId, ack);
+    }
+  }
+  async settleTerminalLifecycle(frame, participantId) {
+    const operationName = frame.name === "episode_ended" ? "end_episode" : frame.name === "participant_left" && frame.payload.participant_id === 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 settleTerminalRecovery(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
+      });
+    }
+  }
+  retry(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) {
+      rejectV1Deferred(deferred, new V1SyncError(code, "retry_exhausted"));
+      if (!deferred.durableTarget) this.#commands.delete(commandId);
+      return;
+    }
+    deferred.retries += 1;
+    const timer = this.#options.clock().setTimeout(() => {
+      this.#commandRetryTimers.delete(commandId);
+      if (this.#commands.get(commandId) === deferred) this.#options.sendIfLive(deferred.frame);
+    }, this.#options.retryDelayMs ?? 100);
+    this.#commandRetryTimers.set(commandId, timer);
+  }
+  enterLive() {
+    for (const pending of this.#commands.values()) {
+      pending.retries = 0;
+      this.#options.sendIfLive(pending.frame);
+    }
+  }
+  #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 }));
+  }
+  #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.#options.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.#options.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);
+    }
+    rejectV1Deferred(deferred, new V1SyncError("external operation remained pending beyond its maximum age", "operation_pending_timeout"));
+    this.#options.stateChanged();
+    if (pending) void this.#removePersistedTarget(commandId, pending);
+  }
+  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") rejectV1Deferred(deferred, new V1SyncError(result.reason, result.outcome));
+    else resolveV1Deferred(deferred, result);
+    this.#options.stateChanged();
+    if (pending) void this.#removePersistedTarget(commandId, pending);
+  }
+  #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 = targetFrame(pending.commandId, pending.command);
+    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.#options.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.#options.isStarted() || this.#pendingRemovalRetryTimers.has(commandId)) return;
+    const timer = this.#options.clock().setTimeout(() => {
+      this.#pendingRemovalRetryTimers.delete(commandId);
+      void this.#removePersistedTarget(commandId, pending);
+    }, this.#options.retryDelayMs ?? 100);
+    this.#pendingRemovalRetryTimers.set(commandId, timer);
+  }
+  #assertCommandIdAvailable(commandId) {
+    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");
+  }
+  #pendingBytes() {
+    return [...this.#pendingTargets.values(), ...this.#pendingRemovals.values()].reduce((total, pending) => total + pending.bytes, 0);
+  }
+  #maxPending() {
+    return Math.min(this.#options.maxPendingCommands ?? MAX_IN_FLIGHT, MAX_IN_FLIGHT);
+  }
+  #nextCommandId() {
+    return this.#options.ids?.next() ?? crypto.randomUUID();
+  }
+  #now() {
+    return this.#options.clock().now();
+  }
+  #clearCommandRetryTimers() {
+    for (const timer of this.#commandRetryTimers.values()) this.#options.clock().clearTimeout(timer);
+    this.#commandRetryTimers.clear();
+  }
+  #clearPendingRemovalRetryTimers() {
+    for (const timer of this.#pendingRemovalRetryTimers.values()) this.#options.clock().clearTimeout(timer);
+    this.#pendingRemovalRetryTimers.clear();
+  }
+  #clearPendingRemovalRetryTimer(commandId) {
+    const timer = this.#pendingRemovalRetryTimers.get(commandId);
+    if (timer === void 0) return;
+    this.#options.clock().clearTimeout(timer);
+    this.#pendingRemovalRetryTimers.delete(commandId);
+  }
+  #clearCommandRetryTimer(commandId) {
+    const timer = this.#commandRetryTimers.get(commandId);
+    if (timer === void 0) return;
+    this.#options.clock().clearTimeout(timer);
+    this.#commandRetryTimers.delete(commandId);
+  }
+};
+function targetFrame(commandId, command) {
+  switch (command.name) {
+    case "set_hand_raised":
+      return { type: "command", command_id: commandId, name: command.name, payload: command.payload };
+    case "set_display_name":
+      return { type: "command", command_id: commandId, name: command.name, payload: command.payload };
+    case "set_admission_policy":
+      return { type: "command", command_id: commandId, name: command.name, payload: command.payload };
+    case "assign_roles":
+      return { type: "command", command_id: commandId, name: command.name, payload: command.payload };
+  }
+}
+function isTerminalLifecycleOperation(frame) {
+  return frame.type === "operation" && (frame.name === "participant_leave" || frame.name === "end_episode");
+}
+
+// src/sync/v1-frame-signature.ts
+function frameSignature(frame) {
+  return new TextDecoder().decode(canonicalJsonBytesFromUnknown(frame));
+}
+
+// src/sync/v1-live-target-coordinator.ts
+var MAX_RETRIES2 = 3;
+var MAX_LIVE_SERVER_RETRIES = 16;
+var LIVE_TARGET_RETRY_BUDGET_MS = 15e3;
+var LOCAL_MEDIA_TIMEOUT_MS = 45e3;
+var MAX_LIVE_TARGET_RETRY_DELAY_MS = 1e3;
+var V1LiveTargetCoordinator = class {
+  #options;
+  #targets = /* @__PURE__ */ new Map();
+  #retryTimers = /* @__PURE__ */ new Map();
+  #deadlineTimers = /* @__PURE__ */ new Map();
+  #localMedia = { microphone: "unknown", camera: "unknown", screen: "unknown" };
+  constructor(options) {
+    this.#options = options;
+  }
+  get pendingCount() {
+    return this.#targets.size;
+  }
+  has(requestId) {
+    return this.#targets.has(requestId);
+  }
+  getLocalMedia() {
+    return { ...this.#localMedia };
+  }
+  updateFromPublications(publications) {
+    const participantId = this.#options.participantId();
+    if (!participantId) return;
+    for (const source of ["microphone", "camera", "screen"]) {
+      const publication = publications.find((candidate) => candidate.source === source && candidate.participantId === participantId);
+      this.#localMedia[source] = publication?.enabled ? "enabled" : "disabled";
+    }
+  }
+  resetLocalMedia() {
+    for (const source of ["microphone", "camera", "screen"]) this.#localMedia[source] = "unknown";
+  }
+  send(name, source, enabled, options) {
+    this.#options.assertCapacity();
+    const participantId = this.#options.participantId();
+    if (!this.#options.isLive() || !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.#targets.has(operationId) || this.#options.requestIdInUse(operationId)) throw new V1SyncError("request ID is already pending", "request_id_conflict");
+    const frame = { type: "live_target", operation_id: operationId, name, enabled };
+    encodeV1ClientFrame(frame);
+    const { deferred, promise } = createLiveDeferred(frame, source, enabled, this.#now());
+    this.#targets.set(operationId, deferred);
+    const deadlineTimer = this.#options.clock().setTimeout(() => {
+      this.#deadlineTimers.delete(operationId);
+      if (this.#targets.get(operationId) === deferred) this.#fail(operationId, deferred, new V1SyncError("self-media target confirmation timed out", "retry_exhausted"));
+    }, LIVE_TARGET_RETRY_BUDGET_MS);
+    this.#deadlineTimers.set(operationId, deadlineTimer);
+    this.#localMedia[source] = "requesting";
+    this.#options.sendIfLive(frame);
+    this.#options.stateChanged();
+    return promise;
+  }
+  receive(frame) {
+    this.#requireLive();
+    const deferred = this.#matchingTarget(frame);
+    if (!deferred || this.#acceptDuplicateServerResult(deferred, frame)) return;
+    this.#applyServerResult(deferred, frame);
+  }
+  #matchingTarget(frame) {
+    const deferred = this.#targets.get(frame.operation_id);
+    return deferred?.frame.name === frame.name ? deferred : void 0;
+  }
+  #acceptDuplicateServerResult(deferred, frame) {
+    if (!deferred.serverResultSignature) return false;
+    if (deferred.serverResultSignature !== frameSignature(frame)) throw new V1ReplicaError("conflicting duplicate live-target result");
+    return true;
+  }
+  #applyServerResult(deferred, frame) {
+    if (frame.outcome === "retryable_failure") {
+      this.#retryServer(frame.operation_id, deferred, frame.error_code ?? frame.outcome);
+      return;
+    }
+    if (!isSuccessfulLiveTargetResult(frame)) {
+      this.#fail(frame.operation_id, deferred, new V1SyncError(frame.error_code ?? frame.outcome, frame.outcome));
+      return;
+    }
+    deferred.serverResult = frame;
+    deferred.serverResultSignature = frameSignature(frame);
+    this.#clearRetryTimer(frame.operation_id);
+    this.#clearDeadlineTimer(frame.operation_id);
+    const localDeadline = this.#options.clock().setTimeout(() => {
+      this.#deadlineTimers.delete(frame.operation_id);
+      if (this.#targets.get(frame.operation_id) === deferred) this.#fail(frame.operation_id, deferred, new V1SyncError("Media did not respond in time. Try again.", "media_timeout"));
+    }, LOCAL_MEDIA_TIMEOUT_MS);
+    this.#deadlineTimers.set(frame.operation_id, localDeadline);
+    this.#executeLocal(frame.operation_id, deferred);
+  }
+  enterLive() {
+    for (const pending of this.#targets.values()) {
+      pending.serverRetries = 0;
+      if (pending.serverResult) this.#executeLocal(pending.frame.operation_id, pending);
+      else this.#options.sendIfLive(pending.frame);
+    }
+  }
+  disconnect(code) {
+    this.#clearTimers();
+    for (const deferred of this.#targets.values()) rejectV1Deferred(deferred, new V1SyncError(code, code));
+    this.#targets.clear();
+  }
+  #retryServer(operationId, deferred, errorCode) {
+    if (this.#retryTimers.has(operationId)) return;
+    const remainingBudget = LIVE_TARGET_RETRY_BUDGET_MS - (this.#now() - deferred.createdAt);
+    if (deferred.serverRetries >= MAX_LIVE_SERVER_RETRIES || remainingBudget <= 0) {
+      this.#fail(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.#scheduleRetry(operationId, () => this.#options.sendIfLive(deferred.frame), delay);
+  }
+  #executeLocal(operationId, deferred) {
+    const mediaPlane = this.#options.mediaPlane;
+    const participantId = this.#options.participantId();
+    if (!mediaPlane || !participantId || deferred.localInFlight || this.#targets.get(operationId) !== deferred) return;
+    deferred.localInFlight = true;
+    let result;
+    try {
+      result = mediaPlane.setLocalPublicationTarget({ operationId, participantId, source: deferred.source, enabled: deferred.enabled });
+    } catch {
+      this.#localResult(operationId, deferred, { outcome: "ambiguous", errorCode: "media_plane_exception" });
+      return;
+    }
+    void result.then((outcome) => this.#localResult(operationId, deferred, normalizeMediaPlaneResult(outcome))).catch(() => this.#localResult(operationId, deferred, { outcome: "ambiguous", errorCode: "media_plane_exception" }));
+  }
+  #localResult(operationId, deferred, result) {
+    if (this.#targets.get(operationId) !== deferred) return;
+    deferred.localInFlight = false;
+    if (result.outcome === "retryable_failure") {
+      this.#retryLocal(operationId, deferred, result);
+      return;
+    }
+    this.#settleLocal(operationId, deferred, result);
+  }
+  #retryLocal(operationId, deferred, result) {
+    if (deferred.localRetries >= MAX_RETRIES2) {
+      this.#fail(operationId, deferred, new V1SyncError(result.errorCode ?? result.outcome, "retry_exhausted"));
+      return;
+    }
+    deferred.localRetries += 1;
+    this.#scheduleRetry(operationId, () => this.#executeLocal(operationId, deferred));
+  }
+  #settleLocal(operationId, deferred, result) {
+    if (!isSuccessfulMediaPlaneResult(result)) {
+      if (result.errorCode === "signaling_timeout" || result.errorCode === "negotiation_timeout") {
+        this.#fail(operationId, deferred, new V1SyncError("Media did not respond in time. Try again.", result.errorCode));
+        return;
+      }
+      this.#fail(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.#targets.delete(operationId);
+    this.#clearRetryTimer(operationId);
+    this.#clearDeadlineTimer(operationId);
+    this.#localMedia[deferred.source] = deferred.enabled ? "enabled" : "disabled";
+    resolveV1Deferred(deferred, { operationId, name: deferred.frame.name, serverOutcome: serverResult.outcome, mediaPlaneOutcome: result.outcome });
+    this.#options.stateChanged();
+  }
+  #scheduleRetry(operationId, retry, delay = this.#options.retryDelayMs ?? 100) {
+    const timer = this.#options.clock().setTimeout(() => {
+      this.#retryTimers.delete(operationId);
+      retry();
+    }, delay);
+    this.#retryTimers.set(operationId, timer);
+  }
+  #fail(operationId, deferred, error) {
+    this.#targets.delete(operationId);
+    this.#clearRetryTimer(operationId);
+    this.#clearDeadlineTimer(operationId);
+    this.#localMedia[deferred.source] = "failed";
+    rejectV1Deferred(deferred, error);
+    this.#options.stateChanged();
+  }
+  #nextRequestId() {
+    return this.#options.requestIds?.next() ?? crypto.randomUUID();
+  }
+  #now() {
+    return this.#options.clock().now();
+  }
+  #requireLive() {
+    if (!this.#options.isLive()) throw new V1ReplicaError("live frame arrived before four-stream recovery completed");
+  }
+  #clearTimers() {
+    for (const timer of this.#retryTimers.values()) this.#options.clock().clearTimeout(timer);
+    for (const timer of this.#deadlineTimers.values()) this.#options.clock().clearTimeout(timer);
+    this.#retryTimers.clear();
+    this.#deadlineTimers.clear();
+  }
+  #clearRetryTimer(operationId) {
+    const timer = this.#retryTimers.get(operationId);
+    if (timer === void 0) return;
+    this.#options.clock().clearTimeout(timer);
+    this.#retryTimers.delete(operationId);
+  }
+  #clearDeadlineTimer(operationId) {
+    const timer = this.#deadlineTimers.get(operationId);
+    if (timer === void 0) return;
+    this.#options.clock().clearTimeout(timer);
+    this.#deadlineTimers.delete(operationId);
+  }
+};
+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 normalizeMediaPlaneResult(result) {
+  return validMediaPlaneResult(result) ? result : { outcome: "ambiguous", errorCode: "invalid_media_plane_result" };
+}
+function isSuccessfulLiveTargetResult(result) {
+  return result.outcome === "confirmed" || result.outcome === "satisfied";
+}
+function isSuccessfulMediaPlaneResult(result) {
+  return result.outcome === "confirmed" || result.outcome === "satisfied";
+}
+function createLiveDeferred(frame, source, enabled, createdAt) {
+  let resolvePromise = (_value) => void 0;
+  let rejectPromise = (_error) => void 0;
+  const promise = new Promise((resolve, reject) => {
+    resolvePromise = resolve;
+    rejectPromise = reject;
+  });
+  return {
+    deferred: {
+      resolve: resolvePromise,
+      reject: rejectPromise,
+      settled: false,
+      frame,
+      createdAt,
+      serverRetries: 0,
+      localRetries: 0,
+      localInFlight: false,
+      source,
+      enabled
+    },
+    promise
+  };
+}
+
+// src/sync/v1-client.ts
+var encoder3 = new TextEncoder();
+var MAX_REPLAY_EVENTS = SyncProtocolLimits.completeReplayMaxEvents;
+var MAX_REPLAY_BYTES = SyncProtocolLimits.completeReplayEncodedBytes;
+var MAX_PROJECTION_EVENT_EVIDENCE = 256;
+var CLIENT_RESTART_CLOSE_CODE = 4e3;
+var DEFAULT_RECONNECT_DELAY_MS = 250;
+var MAX_RECONNECT_DELAY_MS = 5e3;
+var FAST_RECONNECT_ATTEMPTS = 8;
+var NOTICE_PROBE_INTERVAL_MS = 500;
+var NOTICE_SILENCE_MS = 750;
+var V1SyncClient = class {
+  #options;
+  #commandScheduler;
+  #listeners = /* @__PURE__ */ new Set();
+  #requestListeners = /* @__PURE__ */ new Set();
+  #collaborationState;
+  #controlHeads = /* @__PURE__ */ new Map();
+  #controlEvents = /* @__PURE__ */ new Map();
+  #liveTargets;
+  #requests = /* @__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;
+  #reconnectAttempt = 0;
+  #heartbeatTimer;
+  #missedHeartbeats = 0;
+  #noticeTimer;
+  #noticeProbeTimer;
+  #noticeLastInboundAt = 0;
+  #noticeUnresponsive = false;
+  #unsubscribeLifecycle;
+  #inbound = Promise.resolve();
+  #transportAvailable = true;
+  #online = true;
+  #active = true;
+  #unsubscribeLocalMedia;
+  #unsubscribeRemoteMedia;
+  #localPublications = [];
+  #remotePublications = [];
+  constructor(options) {
+    assertV1Url(options.url);
+    this.#options = options;
+    this.#commandScheduler = new V1CommandScheduler({
+      store: options.pendingStore ?? new InMemoryV1PendingTargetStore(),
+      ids: options.ids,
+      maxPendingCommands: options.maxPendingCommands,
+      maxPendingBytes: options.maxPendingBytes,
+      maxPendingAgeMs: options.maxPendingAgeMs,
+      maxOperationPendingAgeMs: options.maxOperationPendingAgeMs,
+      retryDelayMs: options.retryDelayMs,
+      clock: () => this.#clock(),
+      isStarted: () => this.#started,
+      sendIfLive: (frame) => this.#sendIfLive(frame),
+      stateChanged: () => this.#emit(),
+      ackHeadIsProven: (ack) => this.#ackHeadIsProven(ack)
+    });
+    this.#liveTargets = new V1LiveTargetCoordinator({
+      mediaPlane: options.mediaPlane,
+      requestIds: options.requestIds,
+      retryDelayMs: options.retryDelayMs,
+      clock: () => this.#clock(),
+      participantId: () => this.#participantId,
+      isLive: () => this.#phase.phase === "live",
+      requestIdInUse: (requestId) => this.#requests.has(requestId),
+      assertCapacity: () => this.#assertCapacity(),
+      sendIfLive: (frame) => this.#sendIfLive(frame),
+      stateChanged: () => this.#emit()
+    });
+    this.#collaborationState = new V1CollaborationState({
+      request: options.collaboration,
+      requestIds: options.requestIds,
+      maxPendingRequests: options.maxPendingCollaborationRequests,
+      isLive: () => this.#phase.phase === "live",
+      send: (frame) => this.#send(frame),
+      stateChanged: () => this.#emit()
+    });
+  }
+  restartTransport() {
+    this.#recover("lifecycle transport deadline");
+  }
+  async start() {
+    if (this.#started) return;
+    this.#started = true;
+    const startupGeneration = ++this.#startupGeneration;
+    let stored;
+    try {
+      stored = await this.#commandScheduler.load();
+    } catch (error) {
+      if (startupGeneration === this.#startupGeneration) {
+        this.#started = false;
+      }
+      throw error;
+    }
+    if (!this.#started || startupGeneration !== this.#startupGeneration) return;
+    this.#commandScheduler.reconcileStored(stored);
+    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.#clearNoticeProbe();
+    this.#commandScheduler.stop("client_stopped");
+    this.#unsubscribeMediaPlane();
+    this.#socket?.close(1e3, "client stopped");
+    this.#socket = null;
+    this.#phase = { phase: "stopped" };
+    this.#rejectEphemeral("client_stopped");
+    this.#collaborationState.disconnect("client_stopped");
+    this.#localPublications = [];
+    this.#remotePublications = [];
+    this.#liveTargets.resetLocalMedia();
+    this.#emit();
+  }
+  getSnapshot() {
+    const pendingCommands = this.#commandScheduler.pendingCommands;
+    const optimisticControl = this.#control && this.#participantId ? optimisticV1Control(this.#control, this.#participantId, pendingCommands) : this.#control;
+    return {
+      connection: this.#phase.phase === "live" ? { ...this.#phase, noticeUnresponsive: this.#noticeUnresponsive } : { ...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.#liveTargets.getLocalMedia(),
+      pendingCommandCount: this.#commandScheduler.pendingCount
+    };
+  }
+  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.#collaborationState.getState();
+  }
+  getParticipantCollaborationCapabilities() {
+    return this.#collaborationState.getParticipantCapabilities();
+  }
+  subscribeCollaboration(listener) {
+    return this.#collaborationState.subscribe(listener);
+  }
+  sendReaction(reaction) {
+    return this.#collaborationState.sendReaction(reaction);
+  }
+  sendChatMessage(input) {
+    return this.#collaborationState.sendChatMessage(input);
+  }
+  markChatRead(sequence) {
+    return this.#collaborationState.markChatRead(sequence);
+  }
+  readChatPage(input) {
+    return this.#collaborationState.readChatPage(input);
+  }
+  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((commandId) => ({ type: "operation", command_id: commandId, name: "admit_participant", payload: { admission_request_id: admissionRequestId } }), options);
+  }
+  deny(admissionRequestId, options) {
+    return this.#sendOperation((commandId) => ({ type: "operation", command_id: commandId, name: "deny_admission", payload: { admission_request_id: admissionRequestId } }), options);
+  }
+  muteParticipant(participantId, options) {
+    return this.#sendOperation((commandId) => ({ type: "operation", command_id: commandId, name: "mute_participant", payload: { participant_id: participantId } }), options);
   }
   stopParticipantCamera(participantId, options) {
-    return this.#sendOperation("stop_participant_camera", { participant_id: participantId }, options);
+    return this.#sendOperation((commandId) => ({ type: "operation", command_id: commandId, name: "stop_participant_camera", payload: { participant_id: participantId } }), options);
   }
   stopParticipantScreenShare(participantId, options) {
-    return this.#sendOperation("stop_participant_screen_share", { participant_id: participantId }, options);
+    return this.#sendOperation((commandId) => ({ type: "operation", command_id: commandId, name: "stop_participant_screen_share", payload: { participant_id: participantId } }), options);
   }
   removeParticipant(participantId, options) {
-    return this.#sendOperation("remove_participant", { participant_id: participantId }, options);
+    return this.#sendOperation((commandId) => ({ type: "operation", command_id: commandId, name: "remove_participant", payload: { 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 }));
+    return this.#sendOperation((commandId) => ({ type: "operation", command_id: commandId, name: "start_recording", payload: { recording_id: recordingId } }), options).then((result) => ({ recordingId, result }));
   }
   stopRecording(recordingId, options) {
-    return this.#sendOperation("stop_recording", { recording_id: recordingId }, options);
+    return this.#sendOperation((commandId) => ({ type: "operation", command_id: commandId, name: "stop_recording", payload: { recording_id: recordingId } }), options);
   }
   leave(options) {
-    return this.#sendOperation("participant_leave", {}, options);
+    return this.#sendOperation((commandId) => ({ type: "operation", command_id: commandId, name: "participant_leave", payload: {} }), options);
   }
   endEpisode(options) {
-    return this.#sendOperation("end_episode", {}, options);
+    return this.#sendOperation((commandId) => ({ type: "operation", command_id: commandId, name: "end_episode", payload: {} }), 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);
+    return this.#sendOperation((commandId) => ({ type: "operation", command_id: commandId, name: "extend_episode", payload: { extension_seconds: minutes * 60 } }), options);
   }
   setMicrophoneEnabled(enabled, options) {
     return this.#sendLiveTarget("set_microphone_enabled", "microphone", enabled, options);
@@ -2208,68 +3009,13 @@ var V1SyncClient = class {
     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);
-    }
+    return this.#commandScheduler.sendTarget(command, this.#liveTargets.pendingCount + this.#requests.size, options);
   }
-  #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;
+  #sendOperation(createFrame, options) {
+    return this.#commandScheduler.sendOperation(createFrame, this.#liveTargets.pendingCount + this.#requests.size, options);
   }
   #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;
+    return this.#liveTargets.send(name, source, enabled, options);
   }
   #sendDirectedRequest(name, participantId, options) {
     this.#assertCapacity();
@@ -2282,18 +3028,18 @@ var V1SyncClient = class {
     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();
+    recordReconnect(this.#options.recordReconnect, "sync_attempt", { attempt: this.#reconnectAttempt });
     const socket = this.#options.webSocket.connect(this.#options.url);
     const connectionGeneration = ++this.#connectionGeneration;
     this.#socket = socket;
-    socket.onopen = () => void this.#authenticate(socket);
+    socket.onopen = () => {
+      recordReconnect(this.#options.recordReconnect, "sync_socket_open");
+      void this.#authenticate(socket);
+    };
     socket.onmessage = (event) => {
       this.#inbound = this.#inbound.then(() => this.#receive(socket, event.data));
     };
@@ -2322,14 +3068,11 @@ var V1SyncClient = class {
         },
         ...this.#options.telemetry ? syncTelemetryCorrelation(this.#options.telemetry) : {}
       };
-      if (this.#requestedCollaborationVersion === 0) {
+      const collaborationExtension = this.#collaborationState.helloExtension;
+      if (!collaborationExtension) {
         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.#send({ ...hello, extensions: [collaborationExtension] });
       }
       this.#emit();
     } catch {
@@ -2340,7 +3083,16 @@ var V1SyncClient = class {
     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));
+      const frame = decodeV1ServerFrame(data);
+      if (this.#phase.phase === "live") {
+        this.#noticeLastInboundAt = this.#now();
+        this.#scheduleNoticeCheck();
+        if (this.#noticeUnresponsive) {
+          this.#noticeUnresponsive = false;
+          this.#emit();
+        }
+      }
+      await this.#handleFrame(frame);
     } catch {
       this.#recover("invalid_frame");
     }
@@ -2371,24 +3123,28 @@ var V1SyncClient = class {
           this.#rememberControlHead(this.#control.revision, this.#control.stateDigest);
           this.#rememberControlEvent(frame);
         }
-        await this.#settleTerminalLifecycleCommands(frame);
-        await this.#settleProvenCommands();
+        await this.#commandScheduler.settleTerminalLifecycle(frame, this.#participantId);
+        await this.#commandScheduler.settleProven();
         {
           const control = this.#requireControl();
           this.#send({ type: "delivery_ack", stream: "control", revision: control.revision, state_digest: control.stateDigest });
         }
+        if (frame.name === "participant_left" && frame.payload.participant_id === this.#participantId) {
+          this.#phase = { phase: "terminal", terminalReason: "participant_inactive" };
+          this.#socket?.close(1e3, "participant inactive");
+        }
         this.#emit();
         return;
       case "ack":
         this.#requireLive();
-        await this.#ack(frame);
+        await this.#commandScheduler.acknowledge(frame);
         return;
       case "retryable_error":
         this.#requireLive();
-        this.#retryCommand(frame.command_id, frame.code);
+        this.#commandScheduler.retry(frame.command_id, frame.code);
         return;
       case "live_target_result":
-        this.#liveTargetResult(frame);
+        this.#liveTargets.receive(frame);
         return;
       case "directed_request_result":
         this.#requestResult(frame);
@@ -2397,43 +3153,28 @@ var V1SyncClient = class {
         this.#directedRequest(frame);
         return;
       case "reaction":
-        this.#requireLive();
-        this.#requireCollaborationNegotiated();
-        this.#emitCollaboration({ type: "reaction", reaction: reactionFromFrame(frame) });
+        this.#collaborationState.reaction(frame);
         return;
       case "reaction_result":
-        this.#reactionResult(frame);
+        this.#collaborationState.reactionResult(frame);
         return;
       case "chat_message":
-        this.#requireCollaborationNegotiated();
-        this.#observeChatMessage(frame);
+        this.#collaborationState.chatMessage(frame);
         return;
       case "chat_send_result":
-        this.#chatSendResult(frame);
+        this.#collaborationState.chatSendResult(frame);
         return;
       case "chat_page":
-        this.#chatPageResult(frame);
+        this.#collaborationState.chatPage(frame);
         return;
       case "chat_head":
-        this.#requireCollaborationNegotiated();
-        this.#collaboration = {
-          ...this.#collaboration,
-          chatHeadSequence: frame.head_sequence,
-          retainedFloorSequence: frame.retained_floor_sequence
-        };
-        this.#emit();
+        this.#collaborationState.chatHead(frame);
         return;
       case "chat_read_receipt":
-        this.#requireLive();
-        this.#requireCollaborationVersion(1);
-        {
-          const receipt = chatReadReceiptFromFrame(frame);
-          this.#rememberChatReadReceipt(receipt);
-          this.#emitCollaboration({ type: "chat_read_receipt", receipt });
-        }
+        this.#collaborationState.chatReadReceipt(frame);
         return;
       case "chat_read_result":
-        this.#chatReadResult(frame);
+        this.#collaborationState.chatReadResult(frame);
         return;
       case "error":
         throw new V1ReplicaError(frame.code);
@@ -2445,29 +3186,12 @@ var V1SyncClient = class {
   }
   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.#collaborationState.acceptWelcome(frame);
     this.#participantId = frame.participant_id;
     this.#participantGeneration = frame.participant_generation;
     this.#updateLocalMediaStates();
     if (frame.mode === "terminal") {
-      await this.#settleTerminalRecoveryCommands(frame);
+      await this.#commandScheduler.settleTerminalRecovery(frame);
       this.#phase = { phase: "terminal", terminalReason: frame.reason };
       this.#socket?.close(1e3, "terminal recovery");
       this.#emit();
@@ -2482,8 +3206,9 @@ var V1SyncClient = class {
     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");
+    recordReconnect(this.#options.recordReconnect, "sync_reconnected");
     this.#recovery = { id: frame.recovery_id, head: frame.head, replayEvents: 0, replayBytes: 0, controlComplete: false };
-    if (frame.mode !== "replay") this.#ackRecovery();
+    if (frame.mode === "snapshot") this.#ackRecovery();
     this.#emit();
   }
   async #replay(frame) {
@@ -2494,251 +3219,71 @@ var V1SyncClient = class {
     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);
+      this.#rememberControlHead(this.#control.revision, this.#control.stateDigest);
+      this.#rememberControlEvent(event);
     }
-    rejectDeferred(deferred, new V1SyncError("external operation remained pending beyond its maximum age", "operation_pending_timeout"));
+    this.#ackRecovery();
     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);
+  #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();
   }
-  #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;
+  #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") {
+      const previous = this.#media?.items ?? [];
+      this.#media = { projectionId: frame.projection_id, sequence: 0, items: frame.items.map(mediaItem) };
+      this.#mediaEventEvidence.clear();
+      for (const item of this.#media.items)
+        this.#notifyRemotePublicationResumed(
+          previous.find((candidate) => mediaKey(candidate) === mediaKey(item)),
+          item
+        );
+      if (!this.#mediaEnded()) this.#options.mediaPlane?.remotePublicationsChanged?.();
+    } else {
+      this.#presence = { projectionId: frame.projection_id, sequence: 0, items: frame.items.map(presenceItem) };
+      this.#presenceEventEvidence.clear();
     }
-    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" }));
+    this.#enterLiveIfReady();
+    this.#emit();
   }
-  #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;
+  #applyProjection(frame) {
+    this.#requireLive();
+    if (frame.stream === "media") {
+      if (this.#acceptProjectionDuplicate(this.#media, this.#mediaEventEvidence, frame)) return;
+      const item = mediaItem(frame.item);
+      const previous = this.#media?.items.find((candidate) => mediaKey(candidate) === mediaKey(item));
+      this.#media = updateProjection(this.#media, frame.projection_id, frame.sequence, item, mediaKey);
+      rememberBoundedEvidence(this.#mediaEventEvidence, frame.sequence, frameSignature(frame), MAX_PROJECTION_EVENT_EVIDENCE);
+      this.#notifyRemotePublicationResumed(previous, item);
+      if (!this.#mediaEnded() && item.participantId !== this.#participantId && (previous?.enabled !== item.enabled || previous?.publicationId !== item.publicationId)) {
+        this.#options.mediaPlane?.remotePublicationsChanged?.();
       }
-      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;
+    } 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);
     }
-    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);
+  #mediaEnded() {
+    return this.#control?.status === "ended" || this.#phase.phase === "terminal";
   }
-  #failLiveTarget(operationId, deferred, error) {
-    this.#liveTargets.delete(operationId);
-    this.#clearLiveRetryTimer(operationId);
-    this.#clearLiveDeadlineTimer(operationId);
-    this.#localMedia[deferred.source] = "failed";
-    rejectDeferred(deferred, error);
-    this.#emit();
+  #notifyRemotePublicationResumed(previous, current) {
+    if (this.#mediaEnded()) return;
+    if (previous?.enabled === false && current.enabled && current.publicationId && previous.publicationId === current.publicationId && current.participantId !== this.#participantId) {
+      this.#options.mediaPlane?.remotePublicationResumed?.(current.publicationId);
+    }
   }
   #requestResult(frame) {
     this.#requireLive();
     const deferred = this.#requests.get(frame.request_id);
     if (!deferred) return;
     this.#requests.delete(frame.request_id);
-    resolveDeferred(deferred, frame);
+    resolveV1Deferred(deferred, frame);
   }
   #directedRequest(frame) {
     this.#requireLive();
@@ -2746,130 +3291,17 @@ var V1SyncClient = class {
     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;
+    recordReconnect(this.#options.recordReconnect, "state_resynced");
     this.#recovery = null;
     this.#phase = { phase: "live" };
     this.#reconnectAttempt = 0;
     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.#commandScheduler.enterLive();
+    this.#liveTargets.enterLive();
     this.#startHeartbeat();
+    this.#startNoticeProbe();
     this.#emit();
   }
   #ackRecovery() {
@@ -2877,36 +3309,6 @@ var V1SyncClient = class {
     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;
   }
@@ -2926,25 +3328,31 @@ var V1SyncClient = class {
   }
   #disconnected(socket) {
     if (socket !== this.#socket) return;
+    recordReconnect(this.#options.recordReconnect, "sync_loss");
     this.#socket = null;
     this.#recovery = null;
     this.#clearHeartbeat();
-    this.#clearRetryTimers();
+    this.#clearNoticeProbe();
+    this.#liveTargets.disconnect("disconnected_before_delivery");
+    this.#commandScheduler.disconnect();
     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 = {};
+    this.#collaborationState.disconnect("disconnected_before_delivery");
     if (!this.#started || !this.#transportAvailable || this.#phase.phase === "terminal") return;
     this.#phase = { phase: "connecting" };
     this.#emit();
     this.#clearReconnect();
     const configuredDelay = this.#options.reconnectDelayMs;
-    const delay = configuredDelay === 0 ? 0 : Math.min(MAX_RECONNECT_DELAY_MS, (configuredDelay ?? DEFAULT_RECONNECT_DELAY_MS) * 2 ** Math.min(this.#reconnectAttempt, 5));
+    const exponentialAttempt = configuredDelay === void 0 ? Math.max(0, this.#reconnectAttempt - FAST_RECONNECT_ATTEMPTS + 1) : this.#reconnectAttempt;
+    const baseDelay = configuredDelay === 0 ? 0 : Math.min(MAX_RECONNECT_DELAY_MS, (configuredDelay ?? DEFAULT_RECONNECT_DELAY_MS) * 2 ** Math.min(exponentialAttempt, 5));
+    const delay = configuredDelay === void 0 ? Math.round(baseDelay * (0.8 + 0.4 * Math.random())) : baseDelay;
+    recordReconnect(this.#options.recordReconnect, "sync_backoff", { boundary: "start", delay_ms: delay, attempt: this.#reconnectAttempt });
     this.#reconnectAttempt += 1;
+    const backoffStartedAt = this.#now();
     this.#reconnectTimer = this.#clock().setTimeout(() => {
       this.#reconnectTimer = void 0;
+      recordReconnect(this.#options.recordReconnect, "sync_backoff", { boundary: "end", duration_ms: Math.max(0, this.#now() - backoffStartedAt) });
       this.#connect();
     }, delay);
   }
@@ -2955,6 +3363,7 @@ var V1SyncClient = class {
     this.#disconnected(socket);
   }
   #handleLifecycle(event) {
+    recordReconnect(this.#options.recordReconnect, "network_change", { lifecycle: event });
     if (event === "online" || event === "offline") this.#online = event === "online";
     else this.#active = event === "active";
     this.#transportAvailable = this.#online && this.#active;
@@ -2963,21 +3372,10 @@ var V1SyncClient = class {
   }
   #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();
+    this.#liveTargets.disconnect(code);
   }
   #rejectRequests(code) {
-    for (const deferred of this.#requests.values()) rejectDeferred(deferred, new V1SyncError(code, code));
+    for (const deferred of this.#requests.values()) rejectV1Deferred(deferred, new V1SyncError(code, code));
     this.#requests.clear();
   }
   #sendIfLive(frame) {
@@ -2989,13 +3387,6 @@ var V1SyncClient = class {
   #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;
@@ -3005,33 +3396,7 @@ var V1SyncClient = class {
     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();
+    this.#commandScheduler.assertCapacity(this.#liveTargets.pendingCount + this.#requests.size);
   }
   #nextRequestId() {
     return this.#options.requestIds?.next() ?? crypto.randomUUID();
@@ -3080,47 +3445,7 @@ var V1SyncClient = class {
     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);
+    this.#liveTargets.updateFromPublications(this.#localPublications);
   }
   #startHeartbeat() {
     this.#clearHeartbeat();
@@ -3141,6 +3466,36 @@ var V1SyncClient = class {
     this.#clock().clearTimeout(this.#heartbeatTimer);
     this.#heartbeatTimer = void 0;
   }
+  #startNoticeProbe() {
+    this.#clearNoticeProbe();
+    this.#noticeLastInboundAt = this.#now();
+    this.#scheduleNoticeCheck();
+    const tick = () => {
+      this.#noticeProbeTimer = void 0;
+      if (this.#phase.phase !== "live") return;
+      this.#send({ type: "ping" });
+      this.#noticeProbeTimer = this.#clock().setTimeout(tick, NOTICE_PROBE_INTERVAL_MS);
+    };
+    this.#noticeProbeTimer = this.#clock().setTimeout(tick, NOTICE_PROBE_INTERVAL_MS);
+  }
+  #scheduleNoticeCheck() {
+    if (this.#noticeTimer !== void 0) this.#clock().clearTimeout(this.#noticeTimer);
+    const remaining = Math.max(0, NOTICE_SILENCE_MS - (this.#now() - this.#noticeLastInboundAt));
+    this.#noticeTimer = this.#clock().setTimeout(() => {
+      this.#noticeTimer = void 0;
+      if (this.#phase.phase !== "live" || this.#noticeUnresponsive) return;
+      if (this.#now() - this.#noticeLastInboundAt < NOTICE_SILENCE_MS) return this.#scheduleNoticeCheck();
+      this.#noticeUnresponsive = true;
+      this.#emit();
+    }, remaining);
+  }
+  #clearNoticeProbe() {
+    if (this.#noticeTimer !== void 0) this.#clock().clearTimeout(this.#noticeTimer);
+    if (this.#noticeProbeTimer !== void 0) this.#clock().clearTimeout(this.#noticeProbeTimer);
+    this.#noticeTimer = void 0;
+    this.#noticeProbeTimer = void 0;
+    this.#noticeUnresponsive = false;
+  }
   #emit() {
     const snapshot = this.getSnapshot();
     for (const listener of this.#listeners) listener(snapshot);
@@ -3170,51 +3525,17 @@ function sameRawHead(left, right) {
 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");
+  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 assertV1Url(value) {
   const url = new URL(value);
@@ -3371,20 +3692,21 @@ export {
   createBrowserSyncLifecycle,
   createReactNativeWebSocketFactory,
   createReactNativeSyncLifecycle,
-  reactionFromFrame,
-  chatMessageFromFrame,
-  chatReadReceiptFromFrame,
+  ChatAttachmentMimeTypeSchema,
   encodeV1ClientFrame,
   decodeV1ServerFrame,
   decodeV1ClientFrame,
-  InMemoryV1PendingTargetStore,
+  reactionFromFrame,
+  chatMessageFromFrame,
+  chatReadReceiptFromFrame,
+  V1SyncError,
   V1ReplicaError,
   restoreV1Snapshot,
   applyV1Event,
   optimisticV1Control,
   assertV1ControlSemantics,
   computeV1StateDigest,
-  V1SyncError,
+  InMemoryV1PendingTargetStore,
   V1SyncClient,
   IndexedDbV1PendingTargetStore,
   AsyncStorageV1PendingTargetStore,