@q9labsai/chalk-client 5.0.0 → 5.1.0

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

@@ -1,12 +1,12 @@
 import {
   AccessGrantError,
   requireParsedAccessGrant
-} from "./chunk-2HJIJVE2.js";
+} from "./chunk-3ZN7IXOZ.js";
 import {
   CloudflareSFUClient,
   createCloudflareSFUHTTPTransport,
   describeMediaCaptureError
-} from "./chunk-O2NOZKJP.js";
+} from "./chunk-DWKTGBHR.js";
 import {
   ChatAttachmentMimeTypeSchema,
   ChatReactionSetFrameSchema,
@@ -16,8 +16,9 @@ import {
   V1SyncError,
   createBrowserSyncLifecycle,
   createBrowserWebSocketFactory,
-  createV1SyncClient
-} from "./chunk-AVXJ4HQU.js";
+  createV1SyncClient,
+  scheduleSyncDialDeadline
+} from "./chunk-K7PNW3KI.js";
 
 // src/access/manager.ts
 import { Clock, Context, Data, Effect, Layer, SynchronizedRef } from "effect";
@@ -80,7 +81,7 @@ function fetchAccessGrant(provider, input) {
       try: () => validateFetchedAccess(currentAccess, next, now, shouldReplaceMediaConnection),
       catch: (cause) => new ConnectionAccessFailure({ code: "access.invalid", cause })
     });
-    return [{ access: next, automaticMediaReplacement: mediaExpired && !input.replaceMediaConnection }, { access: next }];
+    return [{ access: next, automaticMediaReplacement: currentAccess !== null && !input.replaceMediaConnection && !hasSameMediaConnection(currentAccess, next) }, { access: next }];
   });
 }
 function connectionAccessRequest(input, replaceMediaConnection) {
@@ -114,9 +115,10 @@ function validateExpiration(access, now) {
 }
 function validateRefresh(previous, next, replaceMediaConnection) {
   if (!hasSameSubject(previous, next)) throw new TypeError("Access grant refresh changed its subject");
-  const mediaConnectionChanged = previous.media.provider !== next.media.provider || mediaBinding(previous) !== mediaBinding(next);
-  if (replaceMediaConnection === mediaConnectionChanged) return;
-  throw new TypeError(replaceMediaConnection ? "Access grant replacement did not change its media binding" : "Access grant refresh unexpectedly replaced its media connection");
+  if (replaceMediaConnection && hasSameMediaConnection(previous, next)) throw new TypeError("Access grant replacement did not change its media binding");
+}
+function hasSameMediaConnection(previous, next) {
+  return previous.media.provider === next.media.provider && mediaBinding(previous) === mediaBinding(next);
 }
 function hasSameSubject(previous, next) {
   const left = previous.subject;
@@ -383,6 +385,11 @@ var WhiteboardV1ProtocolMetadata = {
     presentation: {
       name: "presentation_v1",
       exactFields: ["name"]
+    },
+    view: {
+      name: "view_v1",
+      exactFields: ["name"],
+      extendedExactFields: ["name", "origins"]
     }
   },
   identity: {
@@ -399,7 +406,7 @@ var WhiteboardV1ProtocolMetadata = {
     },
     {
       id: "live",
-      accepts: ["submit_update", "submit_update_part", "request_snapshot", "snapshot_ack", "clear", "set_draw_permission", "set_presentation", "cursor", "ping"],
+      accepts: ["submit_update", "submit_update_part", "request_snapshot", "snapshot_ack", "clear", "set_draw_permission", "set_presentation", "cursor", "view", "ping"],
       heartbeatIntervalMs: 2e4,
       missedDeadlinesBeforeClose: 2
     }
@@ -479,6 +486,14 @@ var WhiteboardV1ProtocolMetadata = {
       clientExactFields: ["type", "x", "y"],
       serverExactFields: ["type", "participant_id", "display_name", "x", "y", "occurred_at"]
     },
+    view: {
+      maxCoordinate: 1e6,
+      maxExtent: 2e6,
+      epochField: "origin_epoch",
+      originFields: ["origin_participant_id", "origin_sequence"],
+      clientExactFields: ["type", "x", "y", "width", "height", "bring"],
+      serverExactFields: ["type", "participant_id", "display_name", "x", "y", "width", "height", "bring", "occurred_at"]
+    },
     welcome: {
       exactFields: ["type", "protocol", "participant_id", "participant_generation", "capabilities", "participant_capabilities", "scene_id", "revision", "can_draw"],
       extendedExactFields: ["type", "protocol", "participant_id", "participant_generation", "capabilities", "participant_capabilities", "scene_id", "revision", "can_draw", "presenting"]
@@ -508,8 +523,8 @@ var WhiteboardV1ProtocolMetadata = {
       exactFields: ["type", "correlation_id", "operation", "code", "recoverable", "message"]
     }
   },
-  clientFrames: ["hello", "submit_update", "submit_update_part", "request_snapshot", "snapshot_ack", "clear", "set_draw_permission", "set_presentation", "cursor", "ping"],
-  serverFrames: ["welcome", "snapshot_page", "update", "update_part", "commit", "cursor", "permission_updated", "presentation_updated", "reset_required", "operation_error", "pong"],
+  clientFrames: ["hello", "submit_update", "submit_update_part", "request_snapshot", "snapshot_ack", "clear", "set_draw_permission", "set_presentation", "cursor", "view", "ping"],
+  serverFrames: ["welcome", "snapshot_page", "update", "update_part", "commit", "cursor", "view", "permission_updated", "presentation_updated", "reset_required", "operation_error", "pong"],
   receiptOperations: ["submit_update", "clear", "set_draw_permission", "set_presentation"],
   receiptOutcomes: ["committed", "duplicate"],
   resetReasons: ["scene_changed", "cursor_expired", "gap"],
@@ -612,7 +627,7 @@ function isClientFrame(value) {
   if (!isRecord2(value)) return false;
   switch (value.type) {
     case "hello":
-      return (hasExactRecordKeys(value, WhiteboardV1ProtocolMetadata.frames.hello.exactFields) || hasExactRecordKeys(value, WhiteboardV1ProtocolMetadata.frames.hello.extendedExactFields) && isPresentationExtensions(value.extensions)) && value.protocol === "whiteboard-v1" && typeof value.token === "string" && utf8Bytes(value.token) > 0 && utf8Bytes(value.token) <= WhiteboardV1ProtocolLimits.tokenBytes && (value.cursor === null || isCursor(value.cursor));
+      return (hasExactRecordKeys(value, WhiteboardV1ProtocolMetadata.frames.hello.exactFields) || hasExactRecordKeys(value, WhiteboardV1ProtocolMetadata.frames.hello.extendedExactFields) && isExtensions(value.extensions)) && value.protocol === "whiteboard-v1" && typeof value.token === "string" && utf8Bytes(value.token) > 0 && utf8Bytes(value.token) <= WhiteboardV1ProtocolLimits.tokenBytes && (value.cursor === null || isCursor(value.cursor));
     case "submit_update":
       return hasExactKeys(value, WhiteboardV1ProtocolMetadata.frames.submitUpdate.exactFields) && isBoundedIdentifier(value.operation_id, WhiteboardV1ProtocolLimits.operationIdMinBytes, WhiteboardV1ProtocolLimits.operationIdMaxBytes) && isUuid(value.scene_id) && typeof value.sync_all === "boolean" && isElementBatch(value.elements, WhiteboardV1ProtocolLimits.elementBatchMaxItems);
     case "submit_update_part":
@@ -629,17 +644,32 @@ function isClientFrame(value) {
       return hasExactKeys(value, WhiteboardV1ProtocolMetadata.frames.setPresentation.exactFields) && isBoundedIdentifier(value.operation_id, WhiteboardV1ProtocolLimits.operationIdMinBytes, WhiteboardV1ProtocolLimits.operationIdMaxBytes) && typeof value.presenting === "boolean";
     case "cursor":
       return hasExactKeys(value, WhiteboardV1ProtocolMetadata.frames.cursor.clientExactFields) && isFiniteNumber(value.x) && isFiniteNumber(value.y) && encodedWhiteboardV1FrameBytes(value) <= WhiteboardV1ProtocolLimits.cursorFrameBytes;
+    case "view":
+      return isViewFields(value, WhiteboardV1ProtocolMetadata.frames.view.clientExactFields) && isViewRect(value) && typeof value.bring === "boolean" && encodedWhiteboardV1FrameBytes(value) <= WhiteboardV1ProtocolLimits.cursorFrameBytes;
     case "ping":
       return hasExactKeys(value, ["type"]);
     default:
       return false;
   }
 }
+function isViewFields(value, fields) {
+  if (hasExactRecordKeys(value, fields)) return true;
+  const originFields = [...fields, ...WhiteboardV1ProtocolMetadata.frames.view.originFields];
+  const validFields = hasExactRecordKeys(value, originFields) || hasExactRecordKeys(value, [...originFields, WhiteboardV1ProtocolMetadata.frames.view.epochField]) && isUuid(value.origin_epoch);
+  return validFields && isUuid(value.origin_participant_id) && Number.isSafeInteger(value.origin_sequence) && Number(value.origin_sequence) > 0;
+}
+function isViewRect(value) {
+  return isFiniteNumber(value.x) && isFiniteNumber(value.y) && isFiniteNumber(value.width) && isFiniteNumber(value.height) && value.width > 0 && value.height > 0 && Math.abs(value.x) <= WhiteboardV1ProtocolMetadata.frames.view.maxCoordinate && Math.abs(value.y) <= WhiteboardV1ProtocolMetadata.frames.view.maxCoordinate && value.width <= WhiteboardV1ProtocolMetadata.frames.view.maxExtent && value.height <= WhiteboardV1ProtocolMetadata.frames.view.maxExtent;
+}
 function isAppState(value) {
   return value === null || hasExactKeys(value, WhiteboardV1ProtocolMetadata.sharedAppState.exactFields) && typeof value.view_background_color === "string" && utf8Bytes(value.view_background_color) <= 64;
 }
-function isPresentationExtensions(value) {
-  return Array.isArray(value) && value.length === 1 && hasExactKeys(value[0], WhiteboardV1ProtocolMetadata.extensions.presentation.exactFields) && value[0].name === WhiteboardV1ProtocolMetadata.extensions.presentation.name;
+function isExtension(value, extension) {
+  return hasExactKeys(value, extension.exactFields) && value.name === extension.name;
+}
+function isExtensions(value) {
+  const { presentation, view } = WhiteboardV1ProtocolMetadata.extensions;
+  return Array.isArray(value) && (value.length === 1 || value.length === 2) && isExtension(value[0], presentation) && (value.length === 1 || isExtension(value[1], view) || hasExactKeys(value[1], view.extendedExactFields) && value[1].name === view.name && value[1].origins === true);
 }
 function isWelcome(value) {
   const exact = hasExactRecordKeys(value, WhiteboardV1ProtocolMetadata.frames.welcome.exactFields) || hasExactRecordKeys(value, WhiteboardV1ProtocolMetadata.frames.welcome.extendedExactFields) && typeof value.presenting === "boolean";
@@ -660,6 +690,8 @@ function isServerFrame(value) {
       return hasExactKeys(value, WhiteboardV1ProtocolMetadata.frames.commit.exactFields) && isBoundedIdentifier(value.operation_id, WhiteboardV1ProtocolLimits.operationIdMinBytes, WhiteboardV1ProtocolLimits.operationIdMaxBytes) && typeof value.outcome === "string" && WhiteboardV1ProtocolMetadata.receiptOutcomes.some((outcome) => outcome === value.outcome) && isUuid(value.scene_id) && isUnsignedDecimal(value.revision);
     case "cursor":
       return hasExactKeys(value, WhiteboardV1ProtocolMetadata.frames.cursor.serverExactFields) && isUuid(value.participant_id) && typeof value.display_name === "string" && utf8Bytes(value.display_name) > 0 && utf8Bytes(value.display_name) <= WhiteboardV1ProtocolLimits.displayNameMaxBytes && isFiniteNumber(value.x) && isFiniteNumber(value.y) && typeof value.occurred_at === "string" && !Number.isNaN(Date.parse(value.occurred_at)) && encodedWhiteboardV1FrameBytes(value) <= WhiteboardV1ProtocolLimits.cursorFrameBytes;
+    case "view":
+      return isViewFields(value, WhiteboardV1ProtocolMetadata.frames.view.serverExactFields) && isUuid(value.participant_id) && typeof value.display_name === "string" && utf8Bytes(value.display_name) > 0 && utf8Bytes(value.display_name) <= WhiteboardV1ProtocolLimits.displayNameMaxBytes && isViewRect(value) && typeof value.bring === "boolean" && typeof value.occurred_at === "string" && !Number.isNaN(Date.parse(value.occurred_at)) && encodedWhiteboardV1FrameBytes(value) <= WhiteboardV1ProtocolLimits.cursorFrameBytes;
     case "permission_updated":
       return hasExactKeys(value, WhiteboardV1ProtocolMetadata.frames.permissionUpdated.exactFields) && isUuid(value.participant_id) && typeof value.can_draw === "boolean";
     case "presentation_updated":
@@ -890,6 +922,7 @@ var ChalkWhiteboardV1Client = class {
   #options;
   #store;
   #listeners = /* @__PURE__ */ new Set();
+  #latestViews = /* @__PURE__ */ new Map();
   #summaryListeners = /* @__PURE__ */ new Set();
   #operations = /* @__PURE__ */ new Map();
   #reservedOperationIds = /* @__PURE__ */ new Set();
@@ -900,6 +933,7 @@ var ChalkWhiteboardV1Client = class {
   #updateAssembler = new WhiteboardV1UpdateAssembler();
   #updateAssemblyTimers = /* @__PURE__ */ new Map();
   #socket = null;
+  #cancelDial;
   #started = false;
   #startupGeneration = 0;
   #phase = "idle";
@@ -909,8 +943,12 @@ var ChalkWhiteboardV1Client = class {
   #capabilities = [];
   #canDraw = false;
   #presentationSupported = false;
+  #viewsSupported = false;
   #presenting = false;
-  #useLegacyHello = false;
+  #hello = "versioned-view";
+  #viewSequence = 0;
+  #viewEpoch = crypto.randomUUID();
+  #pendingBring = null;
   #summaryStatus = "unsubscribed";
   #summaryError = null;
   #latestSnapshot = null;
@@ -957,7 +995,8 @@ var ChalkWhiteboardV1Client = class {
     if (this.#started && this.#startPromise) return this.#startPromise;
     this.#started = true;
     globalThis.document?.addEventListener("visibilitychange", this.#visibilityChanged);
-    this.#useLegacyHello = false;
+    this.#hello = "versioned-view";
+    this.#viewsSupported = false;
     this.#phase = "connecting";
     this.#publishSummary("loading", null);
     const generation = ++this.#startupGeneration;
@@ -981,11 +1020,15 @@ var ChalkWhiteboardV1Client = class {
   }
   #stopNow() {
     this.#started = false;
+    this.#viewsSupported = false;
+    this.#pendingBring = null;
+    this.#latestViews.clear();
     this.#removeVisibilityListener();
     this.#startupGeneration += 1;
     this.#unsubscribeLifecycle?.();
     this.#unsubscribeLifecycle = void 0;
     this.#clearReconnect();
+    this.#clearDial();
     this.#clearHeartbeat();
     this.#clearOperationRetryTimers();
     this.#clearUpdateAssemblies();
@@ -1008,12 +1051,18 @@ var ChalkWhiteboardV1Client = class {
   subscribe(listener) {
     this.#listeners.add(listener);
     if (this.#phase !== "live") return () => this.#listeners.delete(listener);
-    if (this.#latestSnapshot && this.#latestSnapshot.sceneId === this.#sceneId && this.#latestSnapshot.revision === this.#revision) {
-      listener(this.#latestSnapshot);
-    }
-    if (this.#snapshots.size === 0 && !this.#waitingForOperations) void this.#requestSnapshot().catch(() => void 0);
+    const currentSnapshot = this.#currentSnapshot();
+    if (currentSnapshot) listener(currentSnapshot);
+    for (const view of this.#latestViews.values()) listener({ ...view, bring: false });
+    if (!currentSnapshot && this.#snapshots.size === 0 && !this.#waitingForOperations) void this.#requestSnapshot().catch(() => void 0);
     return () => this.#listeners.delete(listener);
   }
+  #currentSnapshot() {
+    const snapshot = this.#latestSnapshot;
+    if (snapshot?.sceneId !== this.#sceneId) return null;
+    if (snapshot?.revision !== this.#revision) return null;
+    return snapshot;
+  }
   subscribeSummary(listener) {
     this.#summaryListeners.add(listener);
     this.#notifySummaryListener(listener, this.#summary());
@@ -1034,7 +1083,7 @@ var ChalkWhiteboardV1Client = class {
     });
   }
   sendCursor(input) {
-    if (this.#phase !== "live" || this.#summaryStatus !== "ready" || this.#snapshots.size > 0 || !this.#canDraw) return;
+    if (!this.#presenceReady || !this.#canDraw) return;
     const now = this.#now();
     if (now - this.#lastCursorAt < 1e3 / WhiteboardV1ProtocolLimits.cursorRatePerSecond) return;
     const frame = { type: "cursor", x: input.x, y: input.y };
@@ -1042,6 +1091,40 @@ var ChalkWhiteboardV1Client = class {
     this.#lastCursorAt = now;
     this.#send(frame);
   }
+  get supportsViews() {
+    return this.#started && this.#viewsSupported && this.#viewExtensionEnabled;
+  }
+  get #viewExtensionEnabled() {
+    return this.#hello === "view" || this.#hello === "versioned-view";
+  }
+  get #presenceReady() {
+    return this.#phase === "live" && this.#summaryStatus === "ready" && this.#snapshots.size === 0;
+  }
+  sendView(view) {
+    if (!this.#started || !this.#viewExtensionEnabled) return false;
+    const frame = this.#viewFrame(view);
+    encodeWhiteboardV1ClientFrame(frame);
+    if (!this.#presenceReady) {
+      if (view.bring) this.#pendingBring = { sceneId: this.#sceneId, view: { ...view } };
+      return true;
+    }
+    if (view.bring) this.#pendingBring = null;
+    this.#send(frame);
+    return true;
+  }
+  #viewFrame(view) {
+    const rectangle = { type: "view", x: view.x, y: view.y, width: view.width, height: view.height, bring: view.bring };
+    if (view.bring || this.#hello !== "versioned-view") return rectangle;
+    if (view.originParticipantId !== void 0) return { ...rectangle, origin_participant_id: view.originParticipantId, origin_sequence: view.originSequence, ...view.originEpoch !== void 0 ? { origin_epoch: view.originEpoch } : {} };
+    if (!this.#participantId) return rectangle;
+    return { ...rectangle, origin_participant_id: this.#participantId, origin_sequence: ++this.#viewSequence, origin_epoch: this.#viewEpoch };
+  }
+  #flushPendingBring() {
+    if (!this.#presenceReady) return;
+    const pending = this.#pendingBring;
+    this.#pendingBring = null;
+    if (pending && (pending.sceneId === null || pending.sceneId === this.#sceneId)) this.sendView(pending.view);
+  }
   requestSnapshot() {
     this.#assertLive("request_snapshot");
     return this.#requestSnapshot();
@@ -1128,7 +1211,21 @@ var ChalkWhiteboardV1Client = class {
     this.#phase = "connecting";
     const socket = this.#options.webSocket.connect(this.#options.url);
     this.#socket = socket;
-    socket.onopen = () => void this.#authenticate(socket);
+    this.#cancelDial = scheduleSyncDialDeadline(
+      this.#clock(),
+      () => {
+        this.#cancelDial = void 0;
+        socket.close(CLIENT_RESTART_CLOSE_CODE, "WebSocket dial timeout");
+        this.#disconnected(socket, CLIENT_RESTART_CLOSE_CODE);
+        this.#publishSummary("recovering", failure("start_scene_subscription", "unavailable", true, "The board connection timed out before opening."));
+      },
+      this.#options.dialTimeoutMs
+    );
+    socket.onopen = () => {
+      if (socket !== this.#socket) return;
+      this.#clearDial();
+      void this.#authenticate(socket);
+    };
     socket.onmessage = (event) => {
       this.#inbound = this.#inbound.then(() => this.#receive(socket, event.data));
     };
@@ -1142,7 +1239,7 @@ var ChalkWhiteboardV1Client = class {
       this.#phase = "authenticating";
       this.#presentationSupported = false;
       const cursor = this.#sceneId && this.#revision ? { scene_id: this.#sceneId, revision: this.#revision } : null;
-      this.#send(this.#useLegacyHello ? { type: "hello", protocol: "whiteboard-v1", token, cursor } : { type: "hello", protocol: "whiteboard-v1", token, cursor, extensions: [{ name: "presentation_v1" }] });
+      this.#send(helloFrame(this.#hello, token, cursor));
     } catch {
       socket.close(CLIENT_RESTART_CLOSE_CODE, "whiteboard authentication failed");
     }
@@ -1193,6 +1290,22 @@ var ChalkWhiteboardV1Client = class {
           occurredAt: frame.occurred_at
         });
         return;
+      case "view": {
+        this.#requireLive();
+        const event = {
+          type: "view",
+          participantId: frame.participant_id,
+          displayName: frame.display_name,
+          x: frame.x,
+          y: frame.y,
+          width: frame.width,
+          height: frame.height,
+          bring: frame.bring,
+          occurredAt: frame.occurred_at
+        };
+        this.#emit(frame.origin_participant_id ? { ...event, originParticipantId: frame.origin_participant_id, originSequence: frame.origin_sequence, ...frame.origin_epoch ? { originEpoch: frame.origin_epoch } : {} } : event);
+        return;
+      }
       case "permission_updated":
         this.#requireLive();
         if (frame.participant_id === this.#participantId) this.#canDraw = frame.can_draw;
@@ -1200,6 +1313,7 @@ var ChalkWhiteboardV1Client = class {
         return;
       case "presentation_updated":
         this.#requireLive();
+        if (this.#sceneId !== frame.scene_id) this.#latestViews.clear();
         this.#sceneId = frame.scene_id;
         this.#revision = frame.revision;
         this.#presenting = frame.presenting;
@@ -1207,6 +1321,7 @@ var ChalkWhiteboardV1Client = class {
         return;
       case "reset_required":
         this.#requireLive();
+        if (this.#sceneId !== frame.scene_id) this.#latestViews.clear();
         this.#sceneId = frame.scene_id;
         this.#revision = null;
         this.#publishSummary("recovering", failure("request_snapshot", "cursor_reset_required", true, "Whiteboard snapshot recovery is required."));
@@ -1227,6 +1342,7 @@ var ChalkWhiteboardV1Client = class {
   }
   #update(frame) {
     this.#requireLive();
+    if (this.#sceneId !== frame.scene_id) this.#latestViews.clear();
     this.#sceneId = frame.scene_id;
     this.#revision = frame.revision;
     this.#publishSummary("ready", null);
@@ -1261,8 +1377,10 @@ var ChalkWhiteboardV1Client = class {
   #welcome(frame) {
     if (this.#phase !== "authenticating") throw new Error("unexpected whiteboard welcome");
     this.#phase = "live";
+    this.#viewsSupported = this.#hello === "view" || this.#hello === "versioned-view";
     this.#reconnectAttempt = 0;
     this.#participantId = frame.participant_id;
+    if (this.#sceneId !== frame.scene_id) this.#latestViews.clear();
     this.#sceneId = frame.scene_id;
     this.#revision = frame.revision;
     this.#capabilities = [...frame.capabilities];
@@ -1325,6 +1443,7 @@ var ChalkWhiteboardV1Client = class {
   }
   #completeSnapshot(frame, assembly, elements) {
     this.#snapshots.delete(frame.request_id);
+    if (this.#sceneId !== frame.scene_id) this.#latestViews.clear();
     this.#sceneId = frame.scene_id;
     this.#revision = frame.revision;
     this.#publishSummary("ready", null);
@@ -1388,6 +1507,7 @@ var ChalkWhiteboardV1Client = class {
     if (!entry) return;
     this.#operations.delete(frame.operation_id);
     this.#clearOperationRetryTimer(frame.operation_id);
+    if (this.#sceneId !== frame.scene_id) this.#latestViews.clear();
     this.#sceneId = frame.scene_id;
     this.#revision = frame.revision;
     this.#awaitingOperationIds.delete(frame.operation_id);
@@ -1450,10 +1570,11 @@ var ChalkWhiteboardV1Client = class {
   #disconnected(socket, closeCode) {
     if (socket !== this.#socket) return;
     const rejectedPresentationHello = this.#rejectedPresentationHello(closeCode);
+    const wasLive = this.#phase === "live";
     this.#resetDisconnectedState();
     if (!this.#started || !this.#transportAvailable) return;
     if (rejectedPresentationHello) {
-      this.#useLegacyHello = true;
+      this.#fallbackHello();
       this.#scheduleReconnect();
       return;
     }
@@ -1461,13 +1582,19 @@ var ChalkWhiteboardV1Client = class {
       this.#failRejectedConnection(closeCode);
       return;
     }
+    if (wasLive) this.#hello = "versioned-view";
     this.#scheduleReconnect();
   }
   #rejectedPresentationHello(closeCode) {
-    return this.#phase === "authenticating" && !this.#useLegacyHello && terminalCloseCode(closeCode);
+    return this.#phase === "authenticating" && this.#hello !== "legacy" && terminalCloseCode(closeCode);
+  }
+  #fallbackHello() {
+    this.#hello = this.#hello === "versioned-view" ? "view" : this.#hello === "view" ? "presentation" : "legacy";
+    if (this.#hello !== "view") this.#pendingBring = null;
   }
   #resetDisconnectedState() {
     this.#socket = null;
+    this.#clearDial();
     this.#clearHeartbeat();
     this.#clearUpdateAssemblies();
     this.#phase = "connecting";
@@ -1484,6 +1611,10 @@ var ChalkWhiteboardV1Client = class {
     if (this.#initialSnapshot) rejectDeferred(this.#initialSnapshot, error(terminalFailure));
     this.#rejectOperationCallers(terminalFailure);
   }
+  #clearDial() {
+    this.#cancelDial?.();
+    this.#cancelDial = void 0;
+  }
   #scheduleReconnect() {
     this.#clearReconnect();
     const configuredDelay = this.#options.reconnectDelayMs;
@@ -1527,11 +1658,21 @@ var ChalkWhiteboardV1Client = class {
   }
   #emit(event) {
     if (event.type === "snapshot") this.#latestSnapshot = event;
+    if (event.type === "view") {
+      this.#latestViews.delete(event.participantId);
+      this.#latestViews.set(event.participantId, event);
+      if (this.#latestViews.size > 256) {
+        const oldest = this.#latestViews.keys().next().value;
+        if (oldest !== void 0) this.#latestViews.delete(oldest);
+      }
+    }
     for (const listener of this.#listeners) listener(event);
   }
   #publishSummary(status, summaryError) {
     this.#summaryStatus = status;
     this.#summaryError = summaryError;
+    if (status === "failed") this.#pendingBring = null;
+    if (status === "ready") this.#flushPendingBring();
     const summary = this.#summary();
     try {
       this.#options.onSummary?.(summary);
@@ -1752,6 +1893,12 @@ function operationName(frame) {
 function retryableOperationCode(code) {
   return code === "unavailable" || code === "overloaded" || code === "rate_limited" || code === "storage_unavailable";
 }
+function helloFrame(level, token, cursor) {
+  const hello = { type: "hello", protocol: "whiteboard-v1", token, cursor };
+  if (level === "legacy") return hello;
+  if (level === "presentation") return { ...hello, extensions: [{ name: "presentation_v1" }] };
+  return { ...hello, extensions: [{ name: "presentation_v1" }, level === "versioned-view" ? { name: "view_v1", origins: true } : { name: "view_v1" }] };
+}
 function terminalCloseCode(closeCode) {
   return closeCode === 1008 || closeCode === 1009;
 }
@@ -1792,6 +1939,12 @@ function createChalkWhiteboardV1Client(options) {
   });
 }
 
+// src/whiteboard/index.ts
+var ChalkWhiteboardViewBounds = {
+  maxCoordinate: WhiteboardV1ProtocolMetadata.frames.view.maxCoordinate,
+  maxExtent: WhiteboardV1ProtocolMetadata.frames.view.maxExtent
+};
+
 // src/connection/types.ts
 var ConnectionError = class extends Error {
   code;
@@ -2123,6 +2276,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       syncNoticeUnresponsive: false,
       mediaSnapshot: null,
       failure: null,
+      startInitialMedia: null,
       initialMedia: (intent) => Effect2.tryPromise({
         try: () => intent.microphone || intent.camera ? platform.mediaDevices.getUserMedia({ audio: intent.microphone, video: intent.camera }) : Promise.resolve(streamFromTracks([])),
         catch: (cause) => cause
@@ -2267,8 +2421,14 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       model.syncBindingCleanup?.();
       model.syncNoticeUnresponsive = false;
       let latestSnapshot = null;
+      let observedDialTimeouts = 0;
       let snapshotQueued = false;
       const unsubscribe = sync.subscribe((snapshot) => {
+        const count = snapshot.connection.dialTimeoutCount ?? 0;
+        if (sync === model.sync && count > observedDialTimeouts) {
+          observedDialTimeouts = count;
+          diagnostics.record({ event: "sync_dial_timeout", state: model.state, epoch: model.epoch, attempt: count });
+        }
         if (sync === model.sync && snapshot.connection.phase === "live") {
           const notice = snapshot.connection.noticeUnresponsive === true;
           if (notice !== model.syncNoticeUnresponsive) {
@@ -2330,7 +2490,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       const unsubscribe = sync.subscribe(observe);
       observe(sync.getSnapshot());
       return Effect2.sync(unsubscribe);
-    }).pipe((effect) => withinForegroundBudget(effect, timeoutMs, lifecycleFailure("sync_start_failed", true, "Sync did not become live before the startup deadline")));
+    }).pipe((effect) => withinForegroundBudget(effect, timeoutMs, lifecycleFailure("sync_hello_timeout", true, "Sync did not become live before the startup deadline")));
     const trace = (step, effect) => {
       const span = diagnostics.startSpan({ step, state: model.state, epoch: model.epoch });
       return effect.pipe(
@@ -2388,7 +2548,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
           [
             trace(
               "start_media",
-              foreign7(() => media.start(stream), "media_start_failed", "The media layer could not start")
+              model.startInitialMedia ? model.startInitialMedia(media, stream).pipe(Effect2.mapError((cause) => lifecycleFailure("media_start_failed", true, "The media layer could not start", cause))) : foreign7(() => media.start(stream), "media_start_failed", "The media layer could not start")
             ),
             trace("start_sync", foreign7(() => sync.start(), "sync_start_failed", "The sync layer could not start").pipe(Effect2.andThen(trace("wait_for_sync_live", waitForSyncLive(sync, boundedInteger(options.syncStartupTimeoutMs, START_TIMEOUT_MS, 1, 6e4))))))
           ],
@@ -2845,8 +3005,9 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       },
       getDiagnostics: () => diagnostics.snapshot(),
       getJoinTrace: () => diagnostics.joinTrace(),
-      setInitialMedia: (provider, intent) => Effect2.sync(() => {
+      setInitialMedia: (provider, intent, start) => Effect2.sync(() => {
         model.initialMedia = provider;
+        model.startInitialMedia = start ?? null;
         model.initialMediaIntent = intent ?? null;
       }),
       configureJoin: (intent) => Effect2.sync(() => {
@@ -2907,7 +3068,7 @@ function snapshotFor(model, access) {
     state: model.state,
     subject: subjectFor(access),
     episode: episodeFor(access, control),
-    connection: Object.freeze({ sync: model.syncSnapshot?.connection.phase === "live" && model.syncNoticeUnresponsive ? "unresponsive" : syncPhase(model.syncSnapshot?.connection.phase), media: mediaPhase(model.mediaSnapshot?.connection.phase) }),
+    connection: Object.freeze({ syncHealth: model.syncSnapshot?.connection.health, sync: model.syncSnapshot?.connection.phase === "live" && model.syncNoticeUnresponsive ? "unresponsive" : syncPhase(model.syncSnapshot?.connection.phase), media: mediaPhase(model.mediaSnapshot?.connection.phase) }),
     failure: model.failure ? Object.freeze({ ...model.failure }) : null,
     episodeEnded: model.episodeEndConfirmed,
     removedByHost: model.removedByHost
@@ -3027,6 +3188,7 @@ function mediaPhase(phase) {
 }
 function syncTerminalFailure(snapshot) {
   const reason = snapshot.connection.terminalReason;
+  if (reason === "state_digest_recovery_failed") return lifecycleFailure("state_digest_recovery_failed", false, "The Episode state could not be recovered from an authoritative snapshot");
   if (reason === "episode_ended") return lifecycleFailure("episode_ended", false, "The Episode has ended");
   if (reason === "participant_inactive" || reason === "participant_removed" || reason === "stale_participant_generation") return lifecycleFailure("invalid_access", false, "Participant access is no longer valid");
   return lifecycleFailure("sync_start_failed", true, "The Sync transport needs recovery");
@@ -3045,6 +3207,8 @@ var CONNECTION_ERROR_CODE_MAP = {
   device_constraint_invalid: "media.device_constraint_invalid",
   media_capture_failed: "media.capture_failed",
   sync_start_failed: "connection.sync_start_failed",
+  state_digest_recovery_failed: "connection.state_digest_recovery_failed",
+  sync_hello_timeout: "connection.sync_hello_timeout",
   media_start_failed: "connection.media_start_failed",
   join_cleanup_unconfirmed: "connection.join_cleanup_unconfirmed",
   sync_recovery_exhausted: "connection.sync_recovery_exhausted",
@@ -3067,17 +3231,32 @@ var INVALID_PAYLOAD_CODE_BY_ACTION = /* @__PURE__ */ new Map([
   ["acceptMediaRequest", "media.request_invalid"],
   ["declineMediaRequest", "media.request_invalid"]
 ]);
-function normalizeClientError(cause, fallback = "client.internal_error") {
+var MEDIA_TIMEOUT_FAILURE = { code: "media.timeout", recoverable: true, message: "Media did not respond in time. Try again." };
+var SYNC_FAILURES = /* @__PURE__ */ new Map([
+  ["not_live", { failure: { code: "connection.invalid_state", recoverable: true, message: "Wait for the call to connect, then try again." } }],
+  ["signaling_timeout", { failure: MEDIA_TIMEOUT_FAILURE }],
+  ["negotiation_timeout", { failure: MEDIA_TIMEOUT_FAILURE }],
+  ["media_timeout", { failure: MEDIA_TIMEOUT_FAILURE }],
+  ["retry_exhausted", { failure: MEDIA_TIMEOUT_FAILURE, scope: "media" }],
+  ["reaction_ack_timeout", { failure: { code: "collaboration.unavailable", recoverable: true, message: "Couldn\u2019t confirm your reaction. Try again." } }],
+  ["overloaded", { failure: { code: "collaboration.unavailable", recoverable: true, message: "The call is busy right now. Try again." } }],
+  ["rate_limited", { failure: { code: "command.rate_limited", recoverable: true, message: "You are sending messages too fast. Wait a moment, then try again." } }]
+]);
+function normalizeMediaError(cause) {
+  return normalizeClientError(cause, "client.internal_error", "media");
+}
+function normalizeClientError(cause, fallback = "client.internal_error", scope) {
   if (cause instanceof SpaceClientError) return cause;
-  if (isConnectionError(cause)) {
+  if (cause instanceof ConnectionLifecycleFailure || isConnectionError(cause)) {
     return new SpaceClientError({
-      code: connectionErrorCode(cause.code, cause.action),
+      code: connectionErrorCode(cause.code, cause instanceof ConnectionLifecycleFailure ? null : cause.action),
       recoverable: cause.recoverable,
       message: cause.message
     });
   }
-  if (cause instanceof V1SyncError && ["signaling_timeout", "negotiation_timeout", "media_timeout"].includes(cause.code)) {
-    return new SpaceClientError({ code: "media.timeout", recoverable: true, message: "Media did not respond in time. Try again." });
+  if (cause instanceof V1SyncError) {
+    const policy = SYNC_FAILURES.get(cause.code);
+    if (policy && (!policy.scope || policy.scope === scope)) return new SpaceClientError(policy.failure);
   }
   if (isAccessInvalid(cause)) {
     return new SpaceClientError({ code: "access.invalid", recoverable: true, message: "The access grant was rejected" });
@@ -3146,6 +3325,7 @@ var SpaceStore = class _SpaceStore {
     const error2 = connectionError(snapshot.failure);
     const next = {
       status: connectionStatus(snapshot),
+      syncHealth: snapshot.connection.syncHealth,
       episode: snapshot.episode,
       lastError: sameError(current.lastError, error2) ? current.lastError : error2,
       episodeEnded: snapshot.episodeEnded ?? false,
@@ -3199,27 +3379,15 @@ var SpaceStoreService = class extends Context4.Service()("@chalk/client/SpaceSto
 };
 var makeSpaceStoreLayer = Layer4.effect(SpaceStoreService, SpaceStore.make());
 var makeFakeSpaceStoreLayer = (store = new SpaceStore()) => Layer4.succeed(SpaceStoreService, store);
-function mapCode(code) {
-  return {
-    invalid_access: "access.invalid",
-    access_unavailable: "access.unavailable",
-    episode_ended: "episode.ended",
-    invalid_payload: "chat.payload_invalid",
-    permission_denied: "media.permission_denied",
-    unsupported_environment: "environment.unsupported",
-    rate_limited: "command.rate_limited",
-    command_rejected: "command.rejected"
-  }[code] ?? "client.internal_error";
-}
 function connectionError(failure2) {
-  return failure2 ? empty({ code: publicCode(failure2.code), recoverable: failure2.recoverable, message: failure2.message }) : null;
+  return failure2 ? empty({ code: connectionErrorCode(failure2.code, failure2.action), recoverable: failure2.recoverable, message: failure2.message }) : null;
 }
 function connectionStatus(snapshot) {
   const interrupted = INTERRUPTED_CONNECTION_PHASES.has(snapshot.connection.sync) || INTERRUPTED_CONNECTION_PHASES.has(snapshot.connection.media);
   return snapshot.state === "live" && interrupted ? "reconnecting" : snapshot.state;
 }
 function sameConnection(left, right) {
-  return left.status === right.status && sameEpisode(left.episode, right.episode) && left.lastError === right.lastError && left.episodeEnded === right.episodeEnded && left.removedByHost === right.removedByHost;
+  return left.status === right.status && left.syncHealth === right.syncHealth && sameEpisode(left.episode, right.episode) && left.lastError === right.lastError && left.episodeEnded === right.episodeEnded && left.removedByHost === right.removedByHost;
 }
 function sameEpisode(left, right) {
   if (left === right) return true;
@@ -3231,20 +3399,6 @@ function sameError(left, right) {
   if (!left || !right) return false;
   return left.code === right.code && left.recoverable === right.recoverable && left.message === right.message;
 }
-function publicCode(code) {
-  switch (code) {
-    case "device_not_found":
-      return "media.device_not_found";
-    case "device_busy":
-      return "media.device_busy";
-    case "device_constraint_invalid":
-      return "media.device_constraint_invalid";
-    case "media_capture_failed":
-      return "media.capture_failed";
-    default:
-      return mapCode(code);
-  }
-}
 
 // src/space-client/core.ts
 import { Clock as Clock5, Context as Context13, Duration as Duration2, Effect as Effect12, Layer as Layer13 } from "effect";
@@ -3786,8 +3940,11 @@ function chatError(message) {
 }
 
 // src/space-client/media-controller.ts
-import { Clock as Clock3, Context as Context6, Effect as Effect5, Exit as Exit2, Layer as Layer6, Semaphore } from "effect";
+import { Clock as Clock3, Context as Context6, Deferred as Deferred2, Effect as Effect5, Exit as Exit2, Layer as Layer6, Semaphore } from "effect";
 var MEDIA_SOURCES = ["microphone", "camera", "screen"];
+function sourceWorker(enabled) {
+  return { desired: { enabled, revision: 0, previousEnabled: enabled }, result: { revision: 0, status: "confirmed" }, sentRevision: 0, initialRevision: 0, localEnabled: enabled, pause: null, serverSequence: -1, forcedRevision: null };
+}
 var MediaControllerService = class extends Context6.Service()("@chalk/client/MediaController") {
 };
 var makeMediaController = (connection, store, selection) => Effect5.gen(function* () {
@@ -3812,7 +3969,8 @@ var makeMediaController = (connection, store, selection) => Effect5.gen(function
   );
   yield* connection.setInitialMedia(
     (intent) => controller.captureInitial(intent),
-    () => controller.initialIntent()
+    () => controller.initialIntent(),
+    (media, stream) => controller.startInitial(media, stream)
   );
   yield* Effect5.addFinalizer(() => Effect5.sync(() => controller.dispose()));
   controller.refreshDevicesInBackground();
@@ -3826,17 +3984,17 @@ var MediaControllerRuntime = class {
   #now;
   #fork;
   #tracks = /* @__PURE__ */ new Map();
-  #observedPublicationIds = /* @__PURE__ */ new Map();
-  #intentRevisions = /* @__PURE__ */ new Map();
-  #pendingEnables = /* @__PURE__ */ new Map();
+  #sources = { microphone: sourceWorker(true), camera: sourceWorker(true), screen: sourceWorker(false) };
+  #syncLive = false;
   #pendingSources = /* @__PURE__ */ new Set();
+  #pendingCaptures = /* @__PURE__ */ new Set();
   #requestGenerations = /* @__PURE__ */ new Map();
-  #intent = { microphone: true, camera: true };
+  #camera = { status: "idle" };
   #requests = Object.freeze([]);
   #ports = null;
-  #screenEndedPending = false;
   #screenAudioTrack = null;
   #unsubscribeMedia = null;
+  #unsubscribePause = null;
   #unsubscribeRequests = null;
   #unsubscribeSync = null;
   #unsubscribeConnection = null;
@@ -3854,328 +4012,396 @@ var MediaControllerRuntime = class {
     this.#unsubscribePorts = connection.subscribePorts((ports) => this.#bind(ports));
   }
   configure(intent) {
-    if (intent.microphone !== void 0) this.#intent.microphone = intent.microphone;
-    if (intent.camera !== void 0) this.#intent.camera = intent.camera;
+    if (intent.microphone !== void 0) this.#recordIntent("microphone", intent.microphone);
+    if (intent.camera !== void 0) this.#recordIntent("camera", intent.camera);
   }
-  setMicrophoneEnabled = (enabled) => this.#set("microphone", enabled);
-  setCameraEnabled = (enabled) => this.#set("camera", enabled);
-  setScreenShareEnabled = (enabled, options) => enabled ? this.#startScreen(options) : this.#stopScreen();
+  setMicrophoneEnabled = (enabled) => this.#mediaAction(enabled, this.#set("microphone", enabled));
+  setCameraEnabled = (enabled) => this.#mediaAction(enabled, this.#set("camera", enabled));
+  captureCameraPreview = () => this.#cameraSource("preview").pipe(Effect5.mapError(normalizeMediaError));
+  setScreenShareEnabled = (enabled, options) => enabled ? this.#mediaAction(true, this.#startScreen(options)) : this.#stopScreen();
   selectMicrophone = (deviceId) => Effect5.sync(() => {
     this.#selection.selectCapture("microphone", deviceId);
     this.#store.select("microphone", deviceId);
-  }).pipe(Effect5.mapError(normalizeClientError));
+  }).pipe(Effect5.mapError(normalizeMediaError));
   selectCamera = (deviceId) => Effect5.sync(() => {
+    const changed = this.#store.getSnapshot().media.selection.camera !== deviceId;
     this.#selection.selectCapture("camera", deviceId);
+    if (changed && (!this.#sources.camera.localEnabled || !this.#hasTrack("camera"))) {
+      this.#transitionCamera({ status: "ended" });
+    }
     this.#store.select("camera", deviceId);
-  }).pipe(Effect5.mapError(normalizeClientError));
+  }).pipe(Effect5.mapError(normalizeMediaError));
   selectSpeaker = (deviceId) => foreign2(() => this.#selection.selectSpeaker(deviceId)).pipe(
     Effect5.tap(() => Effect5.sync(() => this.#store.select("speaker", deviceId))),
-    Effect5.mapError(normalizeClientError)
+    Effect5.mapError(normalizeMediaError)
   );
   acceptRequest = (requestId) => {
     return Effect5.suspend(() => {
       const request = this.#requests.find((candidate) => candidate.requestId === requestId);
       if (!request) return Effect5.fail(new SpaceClientError({ code: "media.request_invalid", recoverable: false, message: "The media request is no longer active" }));
-      return (request.kind === "unmute" ? this.#set("microphone", true) : this.#set("camera", true)).pipe(
+      return (request.kind === "unmute" ? this.setMicrophoneEnabled(true) : this.setCameraEnabled(true)).pipe(
         Effect5.tap(
           () => Effect5.sync(() => {
             this.#removeRequest(requestId);
           })
         )
       );
-    }).pipe(Effect5.mapError(normalizeClientError));
+    }).pipe(Effect5.mapError(normalizeMediaError));
   };
   declineRequest = (requestId) => {
     return Effect5.sync(() => {
       this.#removeRequest(requestId);
-    }).pipe(Effect5.mapError(normalizeClientError));
+    }).pipe(Effect5.mapError(normalizeMediaError));
   };
   initialIntent() {
-    return { ...this.#intent };
+    return { microphone: this.#sources.microphone.desired.enabled, camera: this.#sources.camera.desired.enabled };
   }
   captureInitial(intent) {
+    for (const source of ["microphone", "camera"]) this.#sources[source].initialRevision = this.#sources[source].desired.revision;
+    if (!intent.camera) return this.#captureInitial(intent);
+    return this.#useCamera(
+      (track) => Effect5.sync(() => this.#setTrack("camera", track)).pipe(
+        Effect5.andThen(Effect5.suspend(() => intent.microphone && !this.#hasTrack("microphone") ? this.#captureSource("microphone").pipe(Effect5.tap((audio) => Effect5.sync(() => this.#setTrack("microphone", audio)))) : Effect5.void)),
+        Effect5.map(() => {
+          this.#pauseInitialTracks();
+          this.#publish();
+          return streamFromTracks([...this.#localTracks().values()]);
+        })
+      ),
+      (signal) => this.#captureInitial(intent, signal).pipe(
+        Effect5.map((stream) => {
+          const track = stream.getTracks().find((track2) => track2.kind === "video");
+          if (!track) throw new TypeError("Initial capture did not return a camera track");
+          return track;
+        })
+      )
+    );
+  }
+  #captureInitial(intent, signal) {
     if (!intent.microphone && !intent.camera) {
-      this.#intent = { microphone: this.#tracks.has("microphone"), camera: this.#tracks.has("camera") };
+      this.#pauseInitialTracks();
       this.#publish();
-      return Effect5.succeed(streamFromTracks([...this.#tracks.values()]));
+      return Effect5.succeed(streamFromTracks([...this.#localTracks().values()]));
     }
-    return foreign2(() => this.#selection.getUserMedia({ audio: intent.microphone, video: intent.camera })).pipe(
-      Effect5.flatMap(
-        (stream) => Effect5.try({ try: () => selectInitialTracks(stream, intent), catch: (cause) => cause }).pipe(
-          Effect5.tap(
-            (tracks) => Effect5.sync(() => {
-              for (const [source, track] of tracks) this.#tracks.set(source, track);
-              this.#intent = { microphone: this.#tracks.has("microphone"), camera: this.#tracks.has("camera") };
-              this.#publish();
-            })
-          ),
-          Effect5.tap(() => this.#refreshDevices().pipe(Effect5.ignore)),
-          Effect5.map(() => streamFromTracks([...this.#tracks.values()])),
-          Effect5.catch(
-            (cause) => Effect5.sync(() => {
-              stopStream(stream);
-              this.#publish();
-            }).pipe(Effect5.andThen(Effect5.fail(captureError(cause, "join", "Camera or microphone permission was denied"))))
-          )
+    return this.#captureStream(
+      () => this.#selection.getUserMedia({ audio: intent.microphone, video: intent.camera }),
+      (stream) => Effect5.try({ try: () => selectInitialTracks(stream, intent), catch: (cause) => cause }).pipe(
+        Effect5.tap(
+          (tracks) => Effect5.sync(() => {
+            for (const [source, track] of tracks) this.#setTrack(source, track);
+            this.#pauseInitialTracks();
+            this.#publish();
+          })
+        ),
+        Effect5.tap(() => this.#refreshDevices().pipe(Effect5.ignore)),
+        Effect5.map(() => streamFromTracks([...this.#localTracks().values()])),
+        Effect5.catch(
+          (cause) => Effect5.sync(() => {
+            stopStream(stream);
+            this.#publish();
+          }).pipe(Effect5.andThen(Effect5.fail(captureError(cause, "join", "Camera or microphone permission was denied"))))
         )
       ),
-      Effect5.catch((cause) => Effect5.fail(cause instanceof ConnectionError ? cause : captureError(cause, "join", "Camera or microphone permission was denied")))
-    );
+      (cause) => cause,
+      signal
+    ).pipe(Effect5.catch((cause) => Effect5.fail(cause instanceof ConnectionError ? cause : captureError(cause, "join", "Camera or microphone permission was denied"))));
   }
   refreshDevicesInBackground() {
     this.#fork(this.#refreshDevices().pipe(Effect5.ignore));
   }
   dispose() {
-    this.#unsubscribeMedia?.();
-    this.#unsubscribeRequests?.();
-    this.#unsubscribeSync?.();
+    this.#cancelCaptures();
+    for (const unsubscribe of [this.#unsubscribeMedia, this.#unsubscribeRequests, this.#unsubscribePause, this.#unsubscribeSync]) unsubscribe?.();
     this.#unsubscribeConnection?.();
     this.#unsubscribeScreenEnded?.();
     this.#unsubscribePorts?.();
     this.#unsubscribeMedia = null;
     this.#unsubscribeRequests = null;
+    this.#unsubscribePause = null;
     this.#unsubscribeSync = null;
     this.#unsubscribeConnection = null;
     this.#unsubscribeScreenEnded = null;
     this.#unsubscribePorts = null;
     this.#ports = null;
+    this.#resetObservations();
     this.#screenAudioTrack?.stop();
     this.#screenAudioTrack = null;
     for (const track of this.#tracks.values()) track.stop();
-    this.#tracks.clear();
+    this.#clearTracks();
     this.#clearRequests();
     this.#publish();
   }
+  #mediaAction(enabling, operation) {
+    return Effect5.suspend(() => !enabling || this.#store.getSnapshot().connection.status === "live" ? operation : Effect5.fail(normalizeMediaError(new V1SyncError("Media enable requires a live call", "not_live"))));
+  }
   #set(source, enabled) {
-    let previousIntent = this.#intent[source];
-    let intentRevision = 0;
-    let earlyPause = null;
-    const localPause = Effect5.suspend(() => {
-      previousIntent = this.#intent[source];
-      intentRevision = (this.#intentRevisions.get(source) ?? 0) + 1;
-      this.#intentRevisions.set(source, intentRevision);
-      this.#intent[source] = enabled;
-      if (enabled) this.#pendingEnables.set(source, intentRevision);
-      this.#ports?.media.setLocalSourceIntent?.(source, enabled);
-      if (!enabled && this.#ports) earlyPause = this.#beginLocalPause(this.#ports, source);
-      return Effect5.void;
-    });
-    return localPause.pipe(
-      Effect5.andThen(
-        this.#serialize(
-          source,
-          this.#connection.runCommand((ports) => {
-            let captured = null;
-            let prepared = false;
-            const action = source === "microphone" ? "setMicrophoneEnabled" : "setCameraEnabled";
-            return Effect5.suspend(() => {
-              if (!enabled) {
-                let paused = false;
-                return (earlyPause ? foreign2(() => earlyPause) : this.#localTarget(ports, source, false)).pipe(
-                  Effect5.tap(
-                    () => Effect5.sync(() => {
-                      paused = true;
-                    })
-                  ),
-                  Effect5.andThen(source === "microphone" ? foreign2(() => ports.sync.setMicrophoneEnabled(false)) : foreign2(() => ports.sync.setCameraEnabled(false))),
-                  Effect5.asVoid,
-                  Effect5.catch((cause) => {
-                    if (paused && !isSyncRejection(cause) || this.#intentRevisions.get(source) !== intentRevision) return Effect5.fail(cause);
-                    this.#intent[source] = previousIntent;
-                    ports.media.setLocalSourceIntent?.(source, previousIntent);
-                    return this.#localTarget(ports, source, previousIntent).pipe(
-                      Effect5.catch(() => Effect5.void),
-                      Effect5.andThen(Effect5.fail(cause))
-                    );
-                  })
-                );
-              }
-              const acquire = enabled && !this.#tracks.has(source) ? this.#captureSource(source).pipe(
-                Effect5.tap(
-                  (track) => Effect5.sync(() => {
-                    captured = track;
-                    try {
-                      this.#assertActivePorts(ports, action);
-                    } catch (cause) {
-                      track.stop();
-                      throw cause;
-                    }
-                    this.#tracks.set(source, track);
-                    ports.media.prepareLocalTrack(source, track);
-                    prepared = true;
-                    this.#publish();
-                  })
-                )
-              ) : Effect5.void;
-              return acquire.pipe(
-                Effect5.asVoid,
-                Effect5.andThen(source === "microphone" ? foreign2(() => ports.sync.setMicrophoneEnabled(enabled)) : foreign2(() => ports.sync.setCameraEnabled(enabled))),
-                Effect5.tap(() => Effect5.sync(() => this.#assertActivePorts(ports, action))),
-                Effect5.asVoid,
-                Effect5.catch(
-                  (cause) => this.#rollbackCapture({
-                    action,
-                    cause,
-                    fallback: Effect5.void,
-                    media: ports.media,
-                    permissionMessage: `${source} permission was denied`,
-                    prepared,
-                    restoreIntent: () => {
-                      if (this.#intentRevisions.get(source) === intentRevision) this.#intent[source] = previousIntent;
-                    },
-                    source,
-                    track: captured
-                  })
-                )
-              );
-            });
-          })
-        )
-      )
-    ).pipe(
-      Effect5.mapError(normalizeClientError),
-      Effect5.ensuring(
-        Effect5.sync(() => {
-          if (this.#pendingEnables.get(source) === intentRevision) this.#pendingEnables.delete(source);
-        })
-      )
-    );
+    return this.#act(source, enabled);
   }
   #startScreen(options) {
-    let intentRevision = 0;
-    return Effect5.sync(() => {
-      intentRevision = (this.#intentRevisions.get("screen") ?? 0) + 1;
-      this.#intentRevisions.set("screen", intentRevision);
-      this.#pendingEnables.set("screen", intentRevision);
-      this.#ports?.media.setLocalSourceIntent?.("screen", true);
-    }).pipe(
-      Effect5.andThen(
-        this.#serialize(
-          "screen",
-          this.#connection.runCommand((ports) => {
-            let track = null;
-            let prepared = false;
-            return Effect5.suspend(() => {
-              if (this.#tracks.has("screen") && options === void 0) {
-                return Effect5.void;
-              }
-              return Effect5.acquireUseRelease(
-                foreign2(() => this.#selection.getDisplayMedia(displayMediaConstraints(options))).pipe(Effect5.mapError((cause) => captureError(cause, "startScreenShare", "Screen sharing permission was denied"))),
-                (stream) => Effect5.sync(() => {
-                  this.#assertActivePorts(ports, "startScreenShare");
-                  track = requireDisplayVideoTrack(stream);
-                  return { stream, track };
-                }).pipe(
-                  Effect5.tap(() => {
-                    const previous = this.#tracks.get("screen");
-                    if (!previous) return Effect5.void;
-                    return foreign2(() => ports.sync.setScreenShareEnabled(false)).pipe(
-                      Effect5.andThen(this.#clearScreenAudio(ports.media)),
-                      Effect5.andThen(foreign2(() => ports.media.clearPreparedLocalTrack("screen"))),
-                      Effect5.tap(
-                        () => Effect5.sync(() => {
-                          this.#assertActivePorts(ports, "startScreenShare");
-                          this.#tracks.delete("screen");
-                          previous.stop();
-                        })
-                      )
-                    );
-                  }),
-                  Effect5.tap(
-                    ({ stream: captured, track: screenTrack }) => Effect5.sync(() => {
-                      const audio = captured.getAudioTracks()[0];
-                      for (const extra of captured.getAudioTracks().slice(1)) extra.stop();
-                      ports.media.prepareLocalTrack("screen", screenTrack);
-                      prepared = true;
-                      this.#tracks.set("screen", screenTrack);
-                      this.#screenAudioTrack = audio ?? null;
-                      if (audio) {
-                        ports.media.prepareLocalTrack("screen_audio", audio);
-                        audio.addEventListener("ended", () => this.#handleScreenAudioEnded(audio, ports));
-                      }
-                      screenTrack.addEventListener("ended", () => this.#handleScreenEnded(screenTrack));
-                      this.#screenEndedPending = false;
-                      this.#publish();
-                    })
-                  ),
-                  Effect5.andThen(foreign2(() => ports.sync.setScreenShareEnabled(true))),
-                  Effect5.tap(() => Effect5.sync(() => this.#assertActivePorts(ports, "startScreenShare"))),
-                  Effect5.asVoid,
-                  Effect5.catch(
-                    (cause) => (prepared ? this.#clearScreenAudio(ports.media) : Effect5.void).pipe(
-                      Effect5.ignore,
-                      Effect5.andThen(this.#rollbackCapture({ action: "startScreenShare", cause, fallback: Effect5.sync(() => stopStream(stream)), media: ports.media, permissionMessage: "Screen sharing permission was denied", prepared, source: "screen", track }))
-                    )
-                  )
-                ),
-                (stream, exit) => Effect5.sync(() => {
-                  if (Exit2.isFailure(exit)) stopStream(stream);
-                })
-              );
-            });
+    return this.#act("screen", true, options);
+  }
+  #stopScreen() {
+    return this.#act("screen", false);
+  }
+  #pauseTracks(source) {
+    const track = this.#track(source);
+    if (track) track.enabled = false;
+    if (source === "screen" && this.#screenAudioTrack) this.#screenAudioTrack.enabled = false;
+  }
+  #recordIntent(source, enabled, options) {
+    const state = this.#sources[source];
+    const desired = { enabled, revision: state.desired.revision + 1, options, previousEnabled: state.localEnabled };
+    state.desired = desired;
+    if (!enabled) {
+      state.localEnabled = false;
+      this.#pauseTracks(source);
+      if (source === "screen") {
+        this.#track("screen")?.stop();
+        this.#screenAudioTrack?.stop();
+      }
+      const ports = this.#ports;
+      if (ports) {
+        ports.media.setLocalSourceIntent?.(source, false);
+        const previous = state.pause;
+        const next = this.#beginLocalPause(ports, source);
+        state.pause = previous ? Promise.allSettled([previous, next]).then((results) => {
+          for (const result of results) if (result.status === "rejected") throw result.reason;
+        }) : next;
+        void state.pause.catch(() => void 0);
+      }
+    }
+    return desired;
+  }
+  #act(source, enabled, options) {
+    return Effect5.suspend(() => {
+      const desired = this.#recordIntent(source, enabled, options);
+      return this.#serialize(source, this.#work(source)).pipe(
+        Effect5.andThen(
+          Effect5.suspend(() => {
+            if (enabled && this.#store.getSnapshot().connection.status !== "live") return this.#mediaAction(true, Effect5.void);
+            const result = this.#sources[source].result;
+            return result.revision === desired.revision && result.status === "failed" ? Effect5.fail(result.cause) : Effect5.void;
           })
         )
-      )
-    ).pipe(
-      Effect5.mapError(normalizeClientError),
+      );
+    }).pipe(Effect5.mapError(normalizeMediaError));
+  }
+  #work(source) {
+    return Effect5.gen({ self: this }, function* () {
+      const state = this.#sources[source];
+      while (state.result.revision !== state.desired.revision || state.result.status === "failed" && state.result.cleanup) {
+        const intent = state.desired;
+        yield* this.#runRevision(source, intent);
+        if (state.desired.revision === intent.revision) return;
+      }
+    });
+  }
+  #runRevision(source, intent) {
+    return Effect5.gen({ self: this }, function* () {
+      const state = this.#sources[source];
+      const pause = state.pause;
+      state.pause = null;
+      const paused = yield* Effect5.exit(pause ? foreign2(() => pause) : Effect5.void);
+      if (state.desired.revision !== intent.revision) return;
+      const ports = this.#ports;
+      const cleanup = source === "screen" && !intent.enabled ? yield* Effect5.exit(this.#stopScreenLocally(ports)) : Exit2.succeed(void 0);
+      if (state.desired.revision !== intent.revision) return;
+      if (ports && this.#syncLive) yield* this.#executeRevision(ports, source, intent);
+      else if (intent.enabled) state.result = { revision: intent.revision, status: "failed", cause: new V1SyncError("Media enable requires a live call", "not_live"), cleanup: !intent.previousEnabled };
+      yield* paused;
+      yield* cleanup;
+    });
+  }
+  #executeRevision(ports, source, intent) {
+    return Effect5.gen({ self: this }, function* () {
+      const state = this.#sources[source];
+      if (state.result.revision === intent.revision && state.result.status === "failed") {
+        yield* this.#connection.runCommand((p) => this.#send(p, source, intent, false));
+        if (state.result.revision === intent.revision && state.result.status === "failed") state.result.cleanup = false;
+        return;
+      }
+      const operation = source === "screen" ? this.#prepareScreen(ports, intent) : this.#prepareDevice(ports, source, intent);
+      const result = yield* Effect5.exit(this.#connection.runCommand(() => operation));
+      if (state.desired.revision !== intent.revision) return;
+      if (Exit2.isSuccess(result)) {
+        state.result = { revision: intent.revision, status: "confirmed" };
+        state.localEnabled = state.forcedRevision === intent.revision ? false : intent.enabled;
+      } else {
+        const cause = yield* Effect5.flip(result);
+        yield* this.#failRevision(ports, source, intent, cause);
+      }
+    });
+  }
+  #failRevision(ports, source, intent, cause) {
+    return Effect5.sync(() => {
+      const state = this.#sources[source];
+      if (!intent.enabled && ports.sync.getSnapshot().connection.phase !== "live") return;
+      const previous = intent.previousEnabled;
+      if (state.desired.revision === intent.revision) state.result = { revision: intent.revision, status: "failed", cause, cleanup: !intent.enabled || !previous };
+    });
+  }
+  #prepareDevice(ports, source, intent) {
+    if (!intent.enabled) return this.#send(ports, source, intent, false);
+    let captured = null;
+    let prepared = false;
+    const action = source === "microphone" ? "setMicrophoneEnabled" : "setCameraEnabled";
+    return this.#mediaAction(
+      true,
+      Effect5.suspend(() => {
+        this.#assertCurrentIntent(source, intent.revision);
+        ports.media.setLocalSourceIntent?.(source, true);
+        const retire = source === "microphone" ? this.#retireEndedMicrophone(ports.media) : Effect5.void;
+        const acquire = Effect5.suspend(() => {
+          this.#assertActivePorts(ports, action);
+          this.#assertCurrentIntent(source, intent.revision);
+          return source === "camera" && !intent.previousEnabled || !this.#hasTrack(source) ? this.#captureForPublish(
+            source,
+            ports.media,
+            (track) => Effect5.try({
+              try: () => {
+                captured = track;
+                this.#assertActivePorts(ports, action);
+                this.#assertCurrentIntent(source, intent.revision);
+                this.#setTrack(source, track);
+                ports.media.prepareLocalTrack(source, track);
+                prepared = true;
+                this.#publish();
+              },
+              catch: (cause) => cause
+            })
+          ) : Effect5.void;
+        });
+        return retire.pipe(Effect5.andThen(acquire), Effect5.andThen(this.#send(ports, source, intent, true)));
+      })
+    ).pipe(Effect5.catch((cause) => this.#rollbackCapture({ action, cause, fallback: Effect5.void, media: ports.media, permissionMessage: `${source} permission was denied`, prepared, source, track: captured })));
+  }
+  #stopScreenLocally(ports) {
+    const track = this.#track("screen");
+    const clearVideo = ports ? foreign2(() => ports.media.clearPreparedLocalTrack("screen")) : Effect5.void;
+    const clear = ports ? this.#clearScreenAudio(ports.media).pipe(Effect5.matchEffect({ onFailure: (cause) => clearVideo.pipe(Effect5.andThen(Effect5.fail(cause))), onSuccess: () => clearVideo })) : Effect5.void;
+    return clear.pipe(
       Effect5.ensuring(
         Effect5.sync(() => {
-          if (this.#pendingEnables.get("screen") === intentRevision) this.#pendingEnables.delete("screen");
+          if (this.#track("screen") === track) this.#deleteTrack("screen");
+          track?.stop();
+          this.#publish();
         })
       )
     );
   }
-  #stopScreen() {
-    let intentRevision = 0;
-    let earlyPause = null;
-    const localPause = Effect5.suspend(() => {
-      intentRevision = (this.#intentRevisions.get("screen") ?? 0) + 1;
-      this.#intentRevisions.set("screen", intentRevision);
-      this.#ports?.media.setLocalSourceIntent?.("screen", false);
-      if (this.#ports) earlyPause = this.#beginLocalPause(this.#ports, "screen");
-      return Effect5.void;
+  #prepareScreen(ports, intent) {
+    if (!intent.enabled) return this.#send(ports, "screen", intent, false);
+    return this.#mediaAction(
+      true,
+      Effect5.suspend(() => {
+        this.#assertCurrentIntent("screen", intent.revision);
+        ports.media.setLocalSourceIntent?.("screen", true);
+        if (this.#hasTrack("screen") && !intent.options) return this.#send(ports, "screen", intent, true);
+        let track = null;
+        let prepared = false;
+        return this.#captureStream(
+          () => this.#selection.getDisplayMedia(displayMediaConstraints(intent.options)),
+          (stream) => Effect5.gen({ self: this }, function* () {
+            this.#assertActivePorts(ports, "startScreenShare");
+            this.#assertCurrentIntent("screen", intent.revision);
+            track = requireDisplayVideoTrack(stream);
+            const previous = this.#track("screen");
+            if (previous) {
+              yield* this.#send(ports, "screen", intent, false);
+              yield* this.#clearScreenAudio(ports.media);
+              yield* foreign2(() => ports.media.clearPreparedLocalTrack("screen"));
+              this.#deleteTrack("screen");
+              previous.stop();
+            }
+            this.#assertActivePorts(ports, "startScreenShare");
+            this.#assertCurrentIntent("screen", intent.revision);
+            const audio = stream.getAudioTracks()[0];
+            for (const extra of stream.getAudioTracks().slice(1)) extra.stop();
+            ports.media.prepareLocalTrack("screen", track);
+            prepared = true;
+            this.#setTrack("screen", track);
+            this.#screenAudioTrack = audio ?? null;
+            if (audio) {
+              ports.media.prepareLocalTrack("screen_audio", audio);
+              audio.addEventListener("ended", () => this.#handleScreenAudioEnded(audio, ports));
+            }
+            track.addEventListener("ended", () => this.#handleScreenEnded(track ?? void 0));
+            this.#publish();
+            yield* this.#send(ports, "screen", intent, true);
+          }).pipe(
+            Effect5.catch(
+              (cause) => (prepared ? this.#clearScreenAudio(ports.media) : Effect5.void).pipe(
+                Effect5.ignore,
+                Effect5.andThen(this.#rollbackCapture({ action: "startScreenShare", cause, fallback: Effect5.sync(() => stopStream(stream)), media: ports.media, permissionMessage: "Screen sharing permission was denied", prepared, source: "screen", track }))
+              )
+            )
+          ),
+          (cause) => captureError(cause, "startScreenShare", "Screen sharing permission was denied")
+        );
+      })
+    );
+  }
+  #assertCurrentIntent(source, revision) {
+    if (this.#sources[source].desired.revision !== revision) throw cancelledCaptureError();
+  }
+  #resetObservations() {
+    for (const source of MEDIA_SOURCES) {
+      const state = this.#sources[source];
+      state.result = { revision: state.desired.revision, status: "confirmed" };
+      state.pause = null;
+      state.serverSequence = -1;
+      state.forcedRevision = null;
+    }
+  }
+  #pauseInitialTracks() {
+    for (const source of ["microphone", "camera"]) {
+      const enabled = this.#sources[source].desired.enabled;
+      const track = this.#track(source);
+      if (track && !enabled) track.enabled = false;
+      this.#sources[source].localEnabled = !!track && enabled;
+    }
+  }
+  startInitial(media, stream) {
+    const publish = foreign2(async () => {
+      const revisions = { microphone: this.#sources.microphone.initialRevision, camera: this.#sources.camera.initialRevision };
+      const tracks = stream.getTracks().filter((track) => {
+        const source = track.kind === "audio" ? "microphone" : "camera";
+        const state = this.#sources[source];
+        track.enabled = state.desired.enabled;
+        if (!state.desired.enabled) {
+          this.#deleteTrack(source);
+          if (source === "microphone") track.stop();
+        }
+        return state.desired.enabled;
+      });
+      for (const source of ["microphone", "camera"]) this.#sources[source].sentRevision = revisions[source];
+      await media.start(streamFromTracks(tracks));
+      for (const source of ["microphone", "camera"]) {
+        const state = this.#sources[source];
+        if (state.desired.revision === revisions[source]) state.result = { revision: revisions[source], status: "confirmed" };
+      }
     });
-    return localPause.pipe(
-      Effect5.andThen(
-        this.#serialize(
-          "screen",
-          this.#connection.runCommand(
-            (ports) => Effect5.suspend(() => {
-              const track = this.#tracks.get("screen");
-              let paused = false;
-              return (earlyPause ? foreign2(() => earlyPause) : this.#localTarget(ports, "screen", false)).pipe(
-                Effect5.tap(
-                  () => Effect5.sync(() => {
-                    paused = true;
-                  })
-                ),
-                Effect5.andThen(foreign2(() => ports.sync.setScreenShareEnabled(false))),
-                Effect5.tap(() => Effect5.sync(() => this.#assertActivePorts(ports, "stopScreenShare"))),
-                Effect5.andThen(this.#clearScreenAudio(ports.media)),
-                Effect5.andThen(foreign2(() => ports.media.clearPreparedLocalTrack("screen"))),
-                Effect5.tap(
-                  () => Effect5.sync(() => {
-                    this.#assertActivePorts(ports, "stopScreenShare");
-                    if (this.#tracks.get("screen") === track) this.#tracks.delete("screen");
-                    track?.stop();
-                    this.#screenEndedPending = false;
-                    this.#publish();
-                  })
-                ),
-                Effect5.asVoid,
-                Effect5.catch(
-                  (cause) => paused && !isSyncRejection(cause) || this.#intentRevisions.get("screen") !== intentRevision ? Effect5.fail(cause) : Effect5.sync(() => ports.media.setLocalSourceIntent?.("screen", true)).pipe(
-                    Effect5.andThen(this.#localTarget(ports, "screen", true)),
-                    Effect5.catch(() => Effect5.void),
-                    Effect5.andThen(Effect5.fail(cause))
-                  )
-                )
-              );
-            })
-          )
-        )
-      )
-    ).pipe(Effect5.mapError(normalizeClientError));
+    return this.#serialize("microphone", this.#serialize("camera", publish));
+  }
+  #send(ports, source, intent, enabled) {
+    return this.#mediaAction(
+      enabled,
+      foreign2(async () => {
+        this.#assertCurrentIntent(source, intent.revision);
+        this.#assertActivePorts(ports, source === "screen" ? "startScreenShare" : source === "camera" ? "setCameraEnabled" : "setMicrophoneEnabled");
+        const state = this.#sources[source];
+        state.sentRevision = intent.revision;
+        await (source === "microphone" ? ports.sync.setMicrophoneEnabled(enabled) : source === "camera" ? ports.sync.setCameraEnabled(enabled) : ports.sync.setScreenShareEnabled(enabled));
+        this.#assertActivePorts(ports, source === "screen" ? "startScreenShare" : source === "camera" ? "setCameraEnabled" : "setMicrophoneEnabled");
+      })
+    );
+  }
+  #reconcileIntents() {
+    const live = this.#connection.getSnapshot().state === "live" && this.#ports?.sync.getSnapshot().connection.phase === "live";
+    const resumed = live && !this.#syncLive;
+    this.#syncLive = live;
+    if (!resumed) return;
+    for (const source of MEDIA_SOURCES) this.#fork(this.#serialize(source, this.#work(source)).pipe(Effect5.ignore));
   }
   #clearScreenAudio(media) {
     return foreign2(() => media.clearPreparedLocalTrack("screen_audio")).pipe(
@@ -4215,26 +4441,241 @@ var MediaControllerRuntime = class {
       )
     );
   }
-  #captureSource(source) {
-    return foreign2(() => this.#selection.getUserMedia({ audio: source === "microphone", video: source === "camera" })).pipe(
-      Effect5.mapError((cause) => captureError(cause, source === "microphone" ? "setMicrophoneEnabled" : "setCameraEnabled", `${source} permission was denied`)),
-      Effect5.tap(() => this.#refreshDevices().pipe(Effect5.ignore)),
-      Effect5.flatMap(
-        (stream) => Effect5.try({
-          try: () => {
-            const track = stream.getTracks().find((candidate) => candidate.kind === (source === "microphone" ? "audio" : "video"));
-            if (!track) {
-              stopStream(stream);
-              throw new TypeError(`Media capture did not return a ${source} track`);
-            }
-            for (const candidate of stream.getTracks()) if (candidate !== track) candidate.stop();
-            return track;
-          },
-          catch: (cause) => cause
+  #transitionCamera(next) {
+    const previous = this.#camera;
+    const sameOwner = "owner" in previous && "owner" in next && previous.owner === next.owner;
+    if (previous.status === "live") previous.track.removeEventListener("ended", previous.onEnded);
+    this.#camera = next;
+    if (!sameOwner && "owner" in previous) {
+      previous.owner.cancel();
+      if (previous.status === "live") previous.track.stop();
+    }
+    if (next.status === "live") next.track.addEventListener("ended", next.onEnded, { once: true });
+    this.#publish();
+    this.#retireCameraPublication(previous, next);
+  }
+  #retireCameraPublication(previous, next) {
+    if (previous.status !== "live" || previous.publication === null || previous.publication === "initial") return;
+    if (next.status === "live" && next.track === previous.track && next.publication !== null) return;
+    const media = previous.publication;
+    void Promise.resolve().then(() => media.clearPreparedLocalTrack("camera", { stopTrack: false })).then(() => this.#enablePrivateCamera(previous.owner)).catch((cause) => Effect5.runSync(Effect5.logWarning("Camera publication cleanup failed", cause)));
+  }
+  #enablePrivateCamera(owner) {
+    const state = this.#camera;
+    if (state.status === "live" && state.owner === owner && state.publication === null) state.track.enabled = true;
+  }
+  #track(source) {
+    if (source !== "camera") return this.#tracks.get(source);
+    return this.#camera.status === "live" && this.#camera.publication !== null && this.#camera.track.readyState === "live" ? this.#camera.track : void 0;
+  }
+  #hasTrack(source) {
+    return this.#track(source) !== void 0;
+  }
+  #localTracks() {
+    const tracks = new Map(this.#tracks);
+    const camera = this.#track("camera");
+    if (camera) tracks.set("camera", camera);
+    return tracks;
+  }
+  #setTrack(source, track) {
+    if (source !== "camera") {
+      this.#tracks.set(source, track);
+      return;
+    }
+    const state = this.#camera;
+    if (!("owner" in state)) throw cancelledCaptureError();
+    if (state.status === "live" && state.track !== track) throw cancelledCaptureError();
+    const onEnded = () => {
+      if (this.#camera.status === "live" && this.#camera.track === track) this.#transitionCamera({ status: "ended" });
+    };
+    this.#transitionCamera({ status: "live", owner: state.owner, track, publication: this.#ports?.media ?? "initial", onEnded });
+  }
+  #deleteTrack(source) {
+    if (source !== "camera") {
+      this.#tracks.delete(source);
+      return;
+    }
+    const state = this.#camera;
+    if (state.status !== "live") return;
+    if (state.owner.references > 0 && state.track.readyState === "live") {
+      this.#transitionCamera({ ...state, publication: null });
+    } else this.#transitionCamera({ status: "ended" });
+  }
+  #clearTracks() {
+    this.#tracks.clear();
+    this.#transitionCamera({ status: "idle" });
+  }
+  #cameraSource(purpose, acquire = (signal) => this.#captureSource("camera", signal)) {
+    return Effect5.suspend(() => {
+      this.#discardEndedCamera();
+      const current = this.#camera;
+      if (current.status === "live") return this.#liveCameraSource(current, purpose);
+      if (current.status === "capturing") return this.#borrowCamera(current.owner);
+      return this.#borrowCamera(this.#beginCameraCapture(acquire));
+    });
+  }
+  #discardEndedCamera() {
+    if (this.#camera.status === "live" && this.#camera.track.readyState !== "live") this.#transitionCamera({ status: "ended" });
+  }
+  #retireEndedMicrophone(media) {
+    const track = this.#tracks.get("microphone");
+    if (track?.readyState !== "ended") return Effect5.void;
+    return foreign2(() => media.clearPreparedLocalTrack("microphone", { stopTrack: false })).pipe(
+      Effect5.andThen(
+        Effect5.sync(() => {
+          if (this.#tracks.get("microphone") === track) this.#tracks.delete("microphone");
+        })
+      )
+    );
+  }
+  #liveCameraSource(current, purpose) {
+    if (current.publication !== null && !current.track.enabled && purpose === "preview") {
+      const track = current.track.clone();
+      track.enabled = true;
+      const release = () => {
+        this.#pendingCaptures.delete(release);
+        track.stop();
+      };
+      this.#pendingCaptures.add(release);
+      return Effect5.succeed({ track, release });
+    }
+    return this.#borrowCamera(current.owner);
+  }
+  #beginCameraCapture(acquire) {
+    const abort = new AbortController();
+    const owner = {
+      result: Deferred2.makeUnsafe(),
+      references: 0,
+      cancel: () => {
+        abort.abort();
+        Deferred2.doneUnsafe(owner.result, Effect5.fail(cancelledCaptureError()));
+      }
+    };
+    this.#transitionCamera({ status: "capturing", owner });
+    this.#fork(
+      acquire(abort.signal).pipe(
+        Effect5.tap(
+          (track) => Effect5.try({
+            try: () => {
+              const state = this.#camera;
+              if (abort.signal.aborted || !("owner" in state) || state.owner !== owner) {
+                track.stop();
+                throw cancelledCaptureError();
+              }
+              const onEnded = () => {
+                if (this.#camera.status === "live" && this.#camera.owner === owner) this.#transitionCamera({ status: "ended" });
+              };
+              this.#transitionCamera({ status: "live", owner, track, publication: state.status === "live" ? state.publication : null, onEnded });
+              if (track.readyState !== "live") {
+                this.#transitionCamera({ status: "ended" });
+                throw cancelledCaptureError();
+              }
+            },
+            catch: (cause) => cause
+          })
+        ),
+        Effect5.onExit((exit) => Deferred2.done(owner.result, exit)),
+        Effect5.ignore
+      )
+    );
+    return owner;
+  }
+  #borrowCamera(owner) {
+    owner.references++;
+    let released = false;
+    const release = () => {
+      if (released) return;
+      released = true;
+      owner.references--;
+      const current = this.#camera;
+      if (owner.references === 0 && "owner" in current && current.owner === owner && (current.status !== "live" || current.publication === null)) this.#transitionCamera({ status: "ended" });
+    };
+    return Deferred2.await(owner.result).pipe(
+      Effect5.flatMap((track) => track.readyState === "live" ? Effect5.succeed({ track, release }) : Effect5.fail(cancelledCaptureError())),
+      Effect5.onExit(
+        (exit) => Effect5.sync(() => {
+          if (Exit2.isFailure(exit)) release();
         })
       )
     );
   }
+  #useCamera(use, acquire) {
+    return Effect5.suspend(() => {
+      let preview;
+      return this.#cameraSource("publication", acquire).pipe(
+        Effect5.tap(
+          (value) => Effect5.sync(() => {
+            preview = value;
+          })
+        ),
+        Effect5.flatMap((value) => use(value.track)),
+        Effect5.ensuring(Effect5.sync(() => preview?.release()))
+      );
+    });
+  }
+  #captureForPublish(source, media, prepare) {
+    return source === "camera" ? foreign2(() => media.clearPreparedLocalTrack("camera", { stopTrack: false })).pipe(Effect5.retry({ times: 1 }), Effect5.andThen(this.#useCamera(prepare))) : this.#captureSource(source).pipe(Effect5.flatMap(prepare));
+  }
+  #captureStream(operation, use, onCaptureError = (cause) => cause, signal) {
+    return Effect5.suspend(() => {
+      let cancelled = false;
+      let captured = null;
+      const cancel = () => {
+        cancelled = true;
+        stopStream(captured);
+      };
+      this.#pendingCaptures.add(cancel);
+      signal?.addEventListener("abort", cancel, { once: true });
+      if (signal?.aborted) cancel();
+      return foreign2(async () => {
+        if (cancelled) throw cancelledCaptureError();
+        const stream = await operation();
+        captured = stream;
+        if (cancelled) {
+          stopStream(stream);
+          throw cancelledCaptureError();
+        }
+        return stream;
+      }).pipe(
+        Effect5.mapError(onCaptureError),
+        Effect5.flatMap(use),
+        Effect5.tap(() => cancelled ? Effect5.fail(cancelledCaptureError()) : Effect5.void),
+        Effect5.onExit(
+          (exit) => Effect5.sync(() => {
+            this.#pendingCaptures.delete(cancel);
+            signal?.removeEventListener("abort", cancel);
+            if (Exit2.isFailure(exit)) cancel();
+          })
+        )
+      );
+    });
+  }
+  #cancelCaptures() {
+    this.#transitionCamera({ status: "ended" });
+    for (const cancel of this.#pendingCaptures) cancel();
+    this.#pendingCaptures.clear();
+  }
+  #captureSource(source, signal) {
+    return this.#captureStream(
+      () => this.#selection.getUserMedia({ audio: source === "microphone", video: source === "camera" }),
+      (stream) => this.#refreshDevices().pipe(
+        Effect5.ignore,
+        Effect5.andThen(
+          Effect5.try({
+            try: () => {
+              const track = stream.getTracks().find((candidate) => candidate.kind === (source === "microphone" ? "audio" : "video"));
+              if (!track) throw new TypeError(`Media capture did not return a ${source} track`);
+              for (const candidate of stream.getTracks()) if (candidate !== track) candidate.stop();
+              return track;
+            },
+            catch: (cause) => cause
+          })
+        )
+      ),
+      (cause) => captureError(cause, source === "microphone" ? "setMicrophoneEnabled" : "setCameraEnabled", `${source} permission was denied`),
+      signal
+    );
+  }
   #refreshDevices() {
     return foreign2(() => this.#selection.enumerateDevices()).pipe(
       Effect5.tap(
@@ -4248,11 +4689,15 @@ var MediaControllerRuntime = class {
     );
   }
   #discardCaptured(source, track, media, prepared) {
+    if (source === "camera")
+      return Effect5.sync(() => {
+        if (this.#track(source) === track) this.#deleteTrack(source);
+      });
     const clear = prepared ? foreign2(() => media.clearPreparedLocalTrack(source)).pipe(Effect5.ignore) : Effect5.void;
     return clear.pipe(
       Effect5.andThen(
         Effect5.sync(() => {
-          if (this.#tracks.get(source) === track) this.#tracks.delete(source);
+          if (this.#track(source) === track) this.#deleteTrack(source);
           track.stop();
         })
       )
@@ -4260,7 +4705,6 @@ var MediaControllerRuntime = class {
   }
   #rollbackCapture(input) {
     if (isAccessInvalid2(input.cause)) return Effect5.fail(input.cause);
-    input.restoreIntent?.();
     const rollback = input.track ? this.#discardCaptured(input.source, input.track, input.media, input.prepared) : input.fallback;
     const captureWasUnavailable = input.action === "startScreenShare" && !input.prepared && input.track === null;
     const failure2 = isPermissionDenied(input.cause) || captureWasUnavailable ? captureError(input.cause, input.action, input.permissionMessage) : input.cause;
@@ -4270,21 +4714,33 @@ var MediaControllerRuntime = class {
     if (this.#connection.getSnapshot().state === "live" && this.#ports?.sync === ports.sync && this.#ports.media === ports.media) return;
     throw new ConnectionError({ code: "invalid_state", action, recoverable: false, message: `${action} belongs to an inactive connection` });
   }
+  #pausePublication(ports, source, revision) {
+    const state = this.#sources[source];
+    if (state.desired.revision !== revision || ports.sync.getSnapshot().control?.status === "ended") return;
+    state.forcedRevision = revision;
+    state.localEnabled = false;
+    this.#pauseTracks(source);
+    ports.media.setLocalSourceIntent?.(source, false);
+    if (ports.media.closeForcedLocalPublication) this.#fork(foreign2(() => ports.media.closeForcedLocalPublication(source)).pipe(Effect5.ignore));
+    this.#publish();
+  }
   #bind(ports) {
-    this.#unsubscribeMedia?.();
-    this.#unsubscribeRequests?.();
-    this.#unsubscribeSync?.();
+    if (ports && this.#ports?.sync === ports.sync && this.#ports.media === ports.media) return;
+    for (const unsubscribe of [this.#unsubscribeMedia, this.#unsubscribeRequests, this.#unsubscribePause, this.#unsubscribeSync]) unsubscribe?.();
     this.#unsubscribeMedia = null;
     this.#unsubscribeRequests = null;
+    this.#unsubscribePause = null;
     this.#unsubscribeSync = null;
-    if (this.#ports?.media !== ports?.media) this.#observedPublicationIds.clear();
     this.#ports = ports;
+    this.#syncLive = false;
+    this.#bindCamera(ports);
     if (!ports) {
+      this.#resetObservations();
+      this.#cancelCaptures();
       this.#screenAudioTrack?.stop();
       this.#screenAudioTrack = null;
       for (const track of this.#tracks.values()) track.stop();
-      this.#tracks.clear();
-      this.#screenEndedPending = false;
+      this.#clearTracks();
       this.#clearRequests();
       this.#publish();
       return;
@@ -4293,56 +4749,63 @@ var MediaControllerRuntime = class {
       this.#applyRemoteMediaState(ports, ports.sync.getSnapshot());
       this.#publish();
     });
+    this.#unsubscribePause = this.#subscribePauses(ports);
     this.#unsubscribeRequests = ports.sync.onDirectedRequest((request) => this.#request(request));
-    this.#unsubscribeSync = ports.sync.subscribe((snapshot) => {
-      this.#removeRequestsFromMissingParticipants(snapshot);
-      this.#applyRemoteMediaState(ports, snapshot);
-      this.#applyForcedMediaState(ports, snapshot);
-    });
+    this.#unsubscribeSync = this.#subscribeSync(ports);
     this.#applyRemoteMediaState(ports, ports.sync.getSnapshot());
-    this.#applyForcedMediaState(ports, ports.sync.getSnapshot());
     this.#publish();
   }
-  #applyRemoteMediaState(ports, snapshot) {
-    for (const publication of ports.media.getSnapshot().remoteTracks) {
-      publication.track.enabled = snapshot.media?.items.some((item) => item.participantId === publication.participantId && item.source === (publication.source === "screen_audio" ? "screen" : publication.source) && item.enabled) ?? false;
-    }
+  #subscribePauses(ports) {
+    return ports.sync.onMediaPause?.((pause) => {
+      const state = this.#sources[pause.source];
+      if (pause.revision <= state.serverSequence) return;
+      state.serverSequence = pause.revision;
+      this.#pausePublication(ports, pause.source, state.sentRevision);
+    }) ?? null;
   }
-  #applyForcedMediaState(ports, snapshot) {
-    if (!canApplyForcedMediaState(snapshot)) return;
-    for (const source of MEDIA_SOURCES) {
-      const projected = snapshot.media.items.find((item) => item.participantId === snapshot.participantId && item.source === source);
-      if (projected?.publicationId) {
-        this.#observedPublicationIds.set(source, projected.publicationId);
-        continue;
-      }
-      const previousPublicationId = this.#observedPublicationIds.get(source);
-      if (!this.#observedPublicationIds.delete(source)) continue;
-      const local = ports.media.getSnapshot().localTracks.find((publication) => publication.source === source);
-      if (local && local.publicationId !== previousPublicationId) continue;
-      this.#pauseForcedSource(ports, source);
+  #rememberPublications(snapshot) {
+    const publications = /* @__PURE__ */ new Map();
+    const own = (snapshot.media?.items ?? []).filter((item) => item.participantId === snapshot.participantId && item.enabled && item.publicationId !== null);
+    for (const item of own) {
+      if (item.source === "screen_audio" || item.publicationId === null) continue;
+      const state = this.#sources[item.source];
+      if (state.localEnabled && state.sentRevision === state.desired.revision) publications.set(item.source, { revision: state.sentRevision, publicationId: item.publicationId });
     }
+    return publications;
   }
-  #pauseForcedSource(ports, source) {
-    const pendingEnable = this.#hasPendingEnable(source);
-    if (!pendingEnable) {
-      this.#clearForcedIntent(source);
+  #pauseLostPublications(ports, snapshot, publications) {
+    for (const [source, previous] of publications) {
+      const current = snapshot.media?.items.find((item) => item.participantId === snapshot.participantId && item.source === source);
+      if (!current || !current.enabled && (current.publicationId === previous.publicationId || current.publicationId === null)) this.#pausePublication(ports, source, previous.revision);
     }
-    const track = this.#tracks.get(source);
-    if (track) track.enabled = false;
-    ports.media.setLocalSourceIntent?.(source, false);
-    if (ports.media.closeForcedLocalPublication) void ports.media.closeForcedLocalPublication(source).catch(() => void 0);
-    if (pendingEnable) ports.media.setLocalSourceIntent?.(source, true);
-    this.#publish();
   }
-  #clearForcedIntent(source) {
-    this.#intentRevisions.set(source, (this.#intentRevisions.get(source) ?? 0) + 1);
-    if (source !== "screen") this.#intent[source] = false;
-    else if (this.#screenAudioTrack) this.#screenAudioTrack.enabled = false;
+  #subscribeSync(ports) {
+    let recovering = /* @__PURE__ */ new Map();
+    let lastLive = ports.sync.getSnapshot();
+    let wasLive = lastLive.connection.phase === "live";
+    return ports.sync.subscribe((snapshot) => {
+      const live = snapshot.connection.phase === "live";
+      if (wasLive && !live) recovering = this.#rememberPublications(lastLive);
+      if (live && !wasLive) {
+        this.#pauseLostPublications(ports, snapshot, recovering);
+        recovering.clear();
+      }
+      if (live) lastLive = snapshot;
+      wasLive = live;
+      this.#removeRequestsFromMissingParticipants(snapshot);
+      this.#applyRemoteMediaState(ports, snapshot);
+      this.#reconcileIntents();
+    });
+  }
+  #bindCamera(ports) {
+    if (!ports) return;
+    const state = this.#camera;
+    if (state.status === "live" && state.publication === "initial") this.#transitionCamera({ ...state, publication: ports.media });
   }
-  #hasPendingEnable(source) {
-    const revision = this.#pendingEnables.get(source);
-    return revision !== void 0 && revision === this.#intentRevisions.get(source);
+  #applyRemoteMediaState(ports, snapshot) {
+    for (const publication of ports.media.getSnapshot().remoteTracks) {
+      publication.track.enabled = snapshot.media?.items.some((item) => item.participantId === publication.participantId && item.source === (publication.source === "screen_audio" ? "screen" : publication.source) && item.enabled) ?? false;
+    }
   }
   #request(request) {
     if (request.expires_at_ms <= this.#now()) return;
@@ -4387,10 +4850,7 @@ var MediaControllerRuntime = class {
     this.#requests = Object.freeze([]);
   }
   #handleConnectionChange() {
-    if (this.#screenEndedPending && this.#connection.getSnapshot().state === "live") {
-      this.#screenEndedPending = false;
-      this.#fork(this.#stopScreen().pipe(Effect5.ignore));
-    }
+    this.#reconcileIntents();
     this.#publish();
   }
   #handleScreenAudioEnded(track, ports) {
@@ -4404,12 +4864,8 @@ var MediaControllerRuntime = class {
       ).pipe(Effect5.ignore)
     );
   }
-  #handleScreenEnded(track = this.#tracks.get("screen")) {
-    if (!track || this.#tracks.get("screen") !== track) return;
-    if (this.#connection.getSnapshot().state === "reconnecting") {
-      this.#screenEndedPending = true;
-      return;
-    }
+  #handleScreenEnded(track = this.#track("screen")) {
+    if (!track || this.#track("screen") !== track) return;
     this.#fork(this.#stopScreen().pipe(Effect5.ignore));
   }
   #publish() {
@@ -4417,9 +4873,9 @@ var MediaControllerRuntime = class {
     const snapshot = this.#ports?.media.getSnapshot();
     const state = this.#connection.getSnapshot().state;
     const local = Object.freeze({
-      microphone: localMedia("microphone", this.#tracks, snapshot, this.#intent.microphone, state, this.#pendingSources.has("microphone")),
-      camera: localMedia("camera", this.#tracks, snapshot, this.#intent.camera, state, this.#pendingSources.has("camera")),
-      screen: localMedia("screen", this.#tracks, snapshot, false, state, this.#pendingSources.has("screen"))
+      microphone: localMedia("microphone", this.#localTracks(), snapshot, this.#sources.microphone.localEnabled, state, this.#pendingSources.has("microphone")),
+      camera: localMedia("camera", this.#localTracks(), snapshot, this.#sources.camera.localEnabled, state, this.#pendingSources.has("camera")),
+      screen: localMedia("screen", this.#localTracks(), snapshot, false, state, this.#pendingSources.has("screen"))
     });
     const remote = Object.freeze((snapshot?.remoteTracks ?? []).map((track) => Object.freeze({ participantId: track.participantId, source: track.source, publicationId: track.publicationId, track: track.track })));
     const media = Object.freeze({
@@ -4436,6 +4892,9 @@ var MediaControllerRuntime = class {
     if (!sameMediaSlice(current.media, media)) this.#store.updateMedia(media);
   }
 };
+function cancelledCaptureError() {
+  return new ConnectionError({ code: "invalid_state", action: null, recoverable: false, message: "Media capture was cancelled before its result could be used" });
+}
 function foreign2(operation) {
   return Effect5.tryPromise({ try: operation, catch: (cause) => cause });
 }
@@ -4535,12 +4994,6 @@ function isPermissionDenied(cause) {
 function isAccessInvalid2(cause) {
   return typeof cause === "object" && cause !== null && "code" in cause && (cause.code === "access.invalid" || cause.code === "invalid_access");
 }
-function isSyncRejection(cause) {
-  return isAccessInvalid2(cause) || cause instanceof V1SyncError && cause.code === "terminal_failure";
-}
-function canApplyForcedMediaState(snapshot) {
-  return !!snapshot.media && !!snapshot.participantId && snapshot.control?.status !== "ended" && snapshot.connection.phase !== "terminal";
-}
 
 // src/space-client/offline-actions.ts
 import { Context as Context7, Effect as Effect6, Layer as Layer7 } from "effect";
@@ -5470,8 +5923,8 @@ var SpaceClientCore = class {
   subscribe = (listener) => this.#store.subscribe(listener);
   join(options = {}) {
     return Effect12.sync(() => this.#requireActive()).pipe(
-      Effect12.tap(() => Effect12.sync(() => this.controllers.media.configure(options))),
       Effect12.andThen(this.#connection.configureJoin(options)),
+      Effect12.tap(() => Effect12.sync(() => this.controllers.media.configure(options))),
       Effect12.andThen(this.#connection.join()),
       Effect12.andThen(options.displayName === void 0 ? Effect12.void : this.controllers.participants.renameSelf(options.displayName)),
       Effect12.catchTag("ConnectionLifecycleFailure", (failure2) => Effect12.fail(failure2.code === "episode_ended" ? new SpaceClientError({ code: "episode.ended", recoverable: failure2.recoverable, message: failure2.message }) : failure2)),
@@ -5671,6 +6124,7 @@ export {
   InMemoryChalkWhiteboardV1PendingOperationStore,
   ChalkWhiteboardV1Client,
   createChalkWhiteboardV1Client,
+  ChalkWhiteboardViewBounds,
   makeProductionConnectionPlatformLayer,
   ConnectionLifecycleService,
   makeConnectionLifecycleLayer,