@q9labsai/chalk-client 5.0.1 → 5.2.0

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

@@ -1,12 +1,12 @@
-import {
-  AccessGrantError,
-  requireParsedAccessGrant
-} from "./chunk-2HJIJVE2.js";
 import {
   CloudflareSFUClient,
   createCloudflareSFUHTTPTransport,
   describeMediaCaptureError
-} from "./chunk-O2NOZKJP.js";
+} from "./chunk-DWKTGBHR.js";
+import {
+  AccessGrantError,
+  requireParsedAccessGrant
+} from "./chunk-HO4745TX.js";
 import {
   ChatAttachmentMimeTypeSchema,
   ChatReactionSetFrameSchema,
@@ -16,8 +16,10 @@ import {
   V1SyncError,
   createBrowserSyncLifecycle,
   createBrowserWebSocketFactory,
-  createV1SyncClient
-} from "./chunk-AVXJ4HQU.js";
+  createV1SyncClient,
+  formatSyncConnectDiagnostic,
+  scheduleSyncDialDeadline
+} from "./chunk-D2GXPX2P.js";
 
 // src/access/manager.ts
 import { Clock, Context, Data, Effect, Layer, SynchronizedRef } from "effect";
@@ -32,24 +34,24 @@ var makeConnectionAccessLayer = (provider, refreshWindowMs = DEFAULT_REFRESH_WIN
   Effect.gen(function* () {
     const state = yield* SynchronizedRef.make({ access: null });
     const automaticMediaReplacementListeners = /* @__PURE__ */ new Set();
-    const fetch = (reason, replaceMediaConnection, force) => SynchronizedRef.modifyEffect(state, (current) => fetchAccessGrant(provider, { current, reason, replaceMediaConnection, force, refreshWindowMs })).pipe(
+    const fetch2 = (reason, replaceMediaConnection, force) => SynchronizedRef.modifyEffect(state, (current) => fetchAccessGrant(provider, { current, reason, replaceMediaConnection, force, refreshWindowMs })).pipe(
       Effect.tap((result) => Effect.sync(() => notifyAutomaticMediaReplacement(automaticMediaReplacementListeners, result))),
       Effect.map((result) => result.access)
     );
-    const initialize = (reason = "join") => fetch(reason, false, false).pipe(Effect.catchTag("ConnectionAccessFailure", (failure2) => failure2.code === "access.invalid" && SynchronizedRef.getUnsafe(state).access === null ? fetch(reason, false, true) : Effect.fail(failure2)));
+    const initialize = (reason = "join") => fetch2(reason, false, false).pipe(Effect.catchTag("ConnectionAccessFailure", (failure2) => failure2.code === "access.invalid" && SynchronizedRef.getUnsafe(state).access === null ? fetch2(reason, false, true) : Effect.fail(failure2)));
     const millisecondsUntilRefresh = Effect.gen(function* () {
       const access = yield* SynchronizedRef.get(state);
       if (!access.access) return null;
       return millisecondsUntil(access.access, yield* Clock.currentTimeMillis, refreshWindowMs);
     });
-    const ensureFresh = (reason = "scheduled_refresh") => fetch(reason, false, false);
+    const ensureFresh = (reason = "scheduled_refresh") => fetch2(reason, false, false);
     return {
       current: SynchronizedRef.get(state).pipe(Effect.map((value) => value.access)),
       currentUnsafe: () => SynchronizedRef.getUnsafe(state).access,
       initialize,
       ensureFresh,
-      refresh: (reason, replaceMediaConnection) => fetch(reason, replaceMediaConnection, true),
-      refreshAfterRejection: () => fetch("access_retry", true, true),
+      refresh: (reason, replaceMediaConnection) => fetch2(reason, replaceMediaConnection, true),
+      refreshAfterRejection: () => fetch2("access_retry", true, true),
       getSyncToken: (reason = "sync_recovery") => ensureFresh(reason).pipe(Effect.map((access) => access.sync.token)),
       getMediaToken: () => ensureFresh("scheduled_refresh").pipe(Effect.map((access) => access.media.token)),
       subscribeAutomaticMediaReplacement: (listener) => Effect.sync(() => {
@@ -80,7 +82,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 +116,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;
@@ -182,16 +185,19 @@ var CHALK_CHAT_ATTACHMENT_MIME_TYPES = [
 ];
 
 // src/chat-files/types.ts
+var CHAT_FILE_REACHABILITY_MESSAGE = "Could not reach the chat attachment service (network or browser access failure).";
 var ChalkChatFileError = class extends Error {
   operation;
   code;
   recoverable;
+  stage;
   constructor(failure2, options) {
     super(failure2.message, options);
     this.name = "ChalkChatFileError";
     this.operation = failure2.operation;
     this.code = failure2.code;
     this.recoverable = failure2.recoverable;
+    this.stage = failure2.stage ?? "request";
   }
 };
 
@@ -238,15 +244,19 @@ function createChatFileRequest(options) {
   const fetchImplementation = options.fetch ?? globalThis.fetch;
   const baseUrl = options.baseUrl.replace(/\/+$/u, "");
   return async function request(operation, path, init, accepts) {
-    let response;
+    const headers = new Headers(init.headers);
     try {
-      const headers = new Headers(init.headers);
       headers.set("authorization", `Bearer ${await options.token()}`);
+    } catch (cause) {
+      throw new ChalkChatFileError({ operation, code: "unavailable", stage: "token", recoverable: true, message: CHAT_FILE_REACHABILITY_MESSAGE }, { cause });
+    }
+    let response;
+    try {
       response = await fetchImplementation(`${baseUrl}${path}`, { ...init, headers });
     } catch (cause) {
-      throw new ChalkChatFileError({ operation, code: "unavailable", recoverable: true, message: "Chat attachment storage is unavailable." }, { cause });
+      throw new ChalkChatFileError({ operation, code: "unavailable", recoverable: true, message: CHAT_FILE_REACHABILITY_MESSAGE }, { cause });
     }
-    if (!response.ok) throw responseError(response, operation);
+    if (!response.ok) throw await responseError(response, operation);
     let value;
     try {
       value = await response.json();
@@ -257,9 +267,14 @@ function createChatFileRequest(options) {
     return value;
   };
 }
-function responseError(response, operation) {
+async function responseError(response, operation) {
   const code = responseErrorCode(response.status);
-  return chatFileError(operation, code, response.status === 429 || response.status >= 500, "Chat attachment request failed.");
+  let message = "Chat attachment request failed.";
+  if (response.status === 503) {
+    const value = await response.json().catch(() => null);
+    if (isRecord(value) && isRecord(value.error) && value.error.code === "chat.storage_unavailable") message = "Chat attachment storage is unavailable.";
+  }
+  return chatFileError(operation, code, response.status === 429 || response.status >= 500, message);
 }
 function responseErrorCode(status) {
   if (status === 401) return "access.invalid";
@@ -304,71 +319,6 @@ function isAllowedMimeType(value) {
   return typeof value === "string" && CHALK_CHAT_ATTACHMENT_MIME_TYPES.includes(value);
 }
 
-// src/whiteboard/file-download-transport.ts
-function createChalkWhiteboardV1FileDownloadTransport(options) {
-  const fetchImplementation = options.fetch ?? globalThis.fetch;
-  let baseUrlEnd = options.baseUrl.length;
-  while (baseUrlEnd > 0 && options.baseUrl[baseUrlEnd - 1] === "/") baseUrlEnd -= 1;
-  const baseUrl = options.baseUrl.slice(0, baseUrlEnd);
-  return {
-    getDownloadUrl: async (fileId) => {
-      const response = await authorizedFetch(fetchImplementation, options.token, `${baseUrl}/v1/whiteboard/files/${encodeURIComponent(fileId)}/download`, { method: "GET" });
-      if (!response.ok) throw await responseError2(response, "get_file_download");
-      const value = await response.json();
-      if (!isDownloadResponse2(value)) {
-        throw whiteboardError("get_file_download", "file_transfer_failed", false, "Whiteboard download service returned an invalid response.");
-      }
-      return value;
-    }
-  };
-}
-async function authorizedFetch(fetchImplementation, token, url, init) {
-  try {
-    const authorization = await token();
-    const headers = new Headers(init.headers);
-    headers.set("authorization", `Bearer ${authorization}`);
-    return await fetchImplementation(url, { ...init, headers });
-  } catch (cause) {
-    throw new ChalkWhiteboardV1Error(
-      {
-        operation: "get_file_download",
-        code: "storage_unavailable",
-        recoverable: true,
-        message: "Whiteboard file storage is unavailable."
-      },
-      { cause }
-    );
-  }
-}
-async function responseError2(response, operation) {
-  const code = response.status === 401 || response.status === 403 ? "permission_denied" : response.status === 400 ? "invalid_payload" : response.status >= 500 || response.status === 429 ? "storage_unavailable" : "file_transfer_failed";
-  return whiteboardError(operation, code, response.status >= 500 || response.status === 429, "Whiteboard file request failed.");
-}
-function whiteboardError(operation, code, recoverable, message) {
-  return new ChalkWhiteboardV1Error({ operation, code, recoverable, message });
-}
-function isDownloadResponse2(value) {
-  return isExactObject(value, ["downloadUrl", "expiresAt"]) && isHttpUrl2(value.downloadUrl) && isDate2(value.expiresAt);
-}
-function isExactObject(value, keys) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
-}
-function isHttpUrl2(value) {
-  if (typeof value !== "string") return false;
-  try {
-    const url = new URL(value);
-    return url.protocol === "http:" || url.protocol === "https:";
-  } catch {
-    return false;
-  }
-}
-function isDate2(value) {
-  return typeof value === "string" && !Number.isNaN(Date.parse(value));
-}
-
-// src/whiteboard/v1-codec.ts
-import { Schema as Schema2 } from "effect";
-
 // src/generated/whiteboard-v1.ts
 import { Schema } from "effect";
 var WhiteboardV1ProtocolMetadata = {
@@ -383,6 +333,16 @@ var WhiteboardV1ProtocolMetadata = {
     presentation: {
       name: "presentation_v1",
       exactFields: ["name"]
+    },
+    view: {
+      name: "view_v1",
+      exactFields: ["name"],
+      extendedExactFields: ["name", "origins"],
+      ownerExactFields: ["name", "origins", "owner"]
+    },
+    drawPolicy: {
+      name: "draw_policy_v1",
+      exactFields: ["name"]
     }
   },
   identity: {
@@ -391,6 +351,7 @@ var WhiteboardV1ProtocolMetadata = {
     generationFenced: true
   },
   capabilities: ["drawWhiteboard", "manageWhiteboard"],
+  drawPolicies: ["everyone", "hosts", "picked"],
   phases: [
     {
       id: "awaiting_hello",
@@ -399,7 +360,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_draw_policy", "set_presentation", "cursor", "view", "ping"],
       heartbeatIntervalMs: 2e4,
       missedDeadlinesBeforeClose: 2
     }
@@ -429,6 +390,7 @@ var WhiteboardV1ProtocolMetadata = {
     socketQueueMaxAgeMs: 5e3,
     cursorTtlMs: 1e4,
     cursorRatePerSecond: 60,
+    viewPeopleMaxItems: 500,
     pendingOperationMaxItems: 128,
     multipartUpdateMaxParts: 128,
     multipartUpdateMaxItems: 1e4,
@@ -436,7 +398,8 @@ var WhiteboardV1ProtocolMetadata = {
     multipartUpdateTimeoutMs: 1e4,
     sceneElementMaxItems: 1e4,
     sceneJsonMaxBytes: 67108864,
-    sceneObjectMaxBytes: 268435456
+    sceneObjectMaxBytes: 268435456,
+    drawAccessMaxGrants: 1024
   },
   cursor: {
     sceneId: "uuid",
@@ -472,6 +435,9 @@ var WhiteboardV1ProtocolMetadata = {
     setDrawPermission: {
       exactFields: ["type", "operation_id", "participant_id", "can_draw"]
     },
+    setDrawPolicy: {
+      exactFields: ["type", "operation_id", "policy"]
+    },
     setPresentation: {
       exactFields: ["type", "operation_id", "presenting"]
     },
@@ -479,7 +445,18 @@ var WhiteboardV1ProtocolMetadata = {
       clientExactFields: ["type", "x", "y"],
       serverExactFields: ["type", "participant_id", "display_name", "x", "y", "occurred_at"]
     },
+    view: {
+      maxCoordinate: 1e6,
+      maxExtent: 2e6,
+      epochField: "origin_epoch",
+      inputFields: ["input_id", "move"],
+      ownerFields: ["owner_id", "owner_sequence"],
+      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: {
+      ownerField: "view_owner_id",
       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"]
     },
@@ -498,6 +475,10 @@ var WhiteboardV1ProtocolMetadata = {
     permissionUpdated: {
       exactFields: ["type", "participant_id", "can_draw"]
     },
+    drawAccess: {
+      exactFields: ["type", "policy", "can_draw", "capabilities", "grants"],
+      grantExactFields: ["participant_id", "can_draw"]
+    },
     presentationUpdated: {
       exactFields: ["type", "scene_id", "revision", "presenting"]
     },
@@ -508,9 +489,9 @@ 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"],
-  receiptOperations: ["submit_update", "clear", "set_draw_permission", "set_presentation"],
+  clientFrames: ["hello", "submit_update", "submit_update_part", "request_snapshot", "snapshot_ack", "clear", "set_draw_permission", "set_draw_policy", "set_presentation", "cursor", "view", "ping"],
+  serverFrames: ["welcome", "snapshot_page", "update", "update_part", "commit", "cursor", "view", "permission_updated", "draw_access", "presentation_updated", "reset_required", "operation_error", "view_ack", "pong"],
+  receiptOperations: ["submit_update", "clear", "set_draw_permission", "set_draw_policy", "set_presentation"],
   receiptOutcomes: ["committed", "duplicate"],
   resetReasons: ["scene_changed", "cursor_expired", "gap"],
   errorCodes: ["unavailable", "permission_denied", "invalid_payload", "stale_scene", "cursor_reset_required", "rate_limited", "overloaded", "storage_unavailable"],
@@ -612,7 +593,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":
@@ -625,23 +606,67 @@ function isClientFrame(value) {
       return hasExactKeys(value, WhiteboardV1ProtocolMetadata.frames.clear.exactFields) && isBoundedIdentifier(value.operation_id, WhiteboardV1ProtocolLimits.operationIdMinBytes, WhiteboardV1ProtocolLimits.operationIdMaxBytes) && isUuid(value.scene_id);
     case "set_draw_permission":
       return hasExactKeys(value, WhiteboardV1ProtocolMetadata.frames.setDrawPermission.exactFields) && isBoundedIdentifier(value.operation_id, WhiteboardV1ProtocolLimits.operationIdMinBytes, WhiteboardV1ProtocolLimits.operationIdMaxBytes) && isUuid(value.participant_id) && typeof value.can_draw === "boolean";
+    case "set_draw_policy":
+      return hasExactKeys(value, WhiteboardV1ProtocolMetadata.frames.setDrawPolicy.exactFields) && isBoundedIdentifier(value.operation_id, WhiteboardV1ProtocolLimits.operationIdMinBytes, WhiteboardV1ProtocolLimits.operationIdMaxBytes) && isDrawPolicy(value.policy);
     case "set_presentation":
       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 isViewInput(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 isViewInputId(input_id) {
+  return typeof input_id === "string" && /^[0-9a-fA-F-]{36}:[1-9][0-9]{0,15}$/.test(input_id) && isUuid(input_id.split(":")[0]) && Number.isSafeInteger(Number(input_id.split(":")[1]));
+}
+function isViewInput(value, fields) {
+  if (!("input_id" in value || "move" in value)) return isViewFields(value, fields);
+  const { input_id, move, ...rectangle } = value;
+  return isViewInputId(input_id) && typeof move === "boolean" && isViewFields(rectangle, fields);
+}
+function isViewOrder(value, fields) {
+  if (!("owner_id" in value || "owner_sequence" in value)) return isViewFields(value, fields);
+  const { owner_id, owner_sequence, ...rectangle } = value;
+  return isUuid(owner_id) && Number.isSafeInteger(owner_sequence) && Number(owner_sequence) > 0 && isViewFields(rectangle, fields);
+}
+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, drawPolicy } = WhiteboardV1ProtocolMetadata.extensions;
+  if (!Array.isArray(value)) return false;
+  const drawPolicyLast = value.length > 0 && isExtension(value[value.length - 1], drawPolicy);
+  const base = drawPolicyLast ? value.slice(0, -1) : value;
+  if (base.length === 0) return drawPolicyLast;
+  return (base.length === 1 || base.length === 2) && isExtension(base[0], presentation) && (base.length === 1 || isExtension(base[1], view) || hasExactKeys(base[1], view.ownerExactFields) && base[1].name === view.name && base[1].origins === true && base[1].owner === true || hasExactKeys(base[1], view.extendedExactFields) && base[1].name === view.name && base[1].origins === true);
+}
+function isDrawPolicy(value) {
+  return typeof value === "string" && WhiteboardV1ProtocolMetadata.drawPolicies.some((policy) => policy === value);
+}
+function isDrawGrant(value) {
+  return hasExactKeys(value, WhiteboardV1ProtocolMetadata.frames.drawAccess.grantExactFields) && isUuid(value.participant_id) && typeof value.can_draw === "boolean";
 }
 function isWelcome(value) {
+  if ("view_owner_id" in value) {
+    const { view_owner_id, ...welcome } = value;
+    return isUuid(view_owner_id) && isWelcome(welcome);
+  }
   const exact = hasExactRecordKeys(value, WhiteboardV1ProtocolMetadata.frames.welcome.exactFields) || hasExactRecordKeys(value, WhiteboardV1ProtocolMetadata.frames.welcome.extendedExactFields) && typeof value.presenting === "boolean";
   return exact && value.protocol === "whiteboard-v1" && isUuid(value.participant_id) && Number.isSafeInteger(value.participant_generation) && Number(value.participant_generation) > 0 && isCapabilities(value.capabilities) && isCapabilities(value.participant_capabilities) && isUuid(value.scene_id) && isUnsignedDecimal(value.revision) && typeof value.can_draw === "boolean";
 }
@@ -660,14 +685,20 @@ 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 isViewOrder(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 "draw_access":
+      return hasExactKeys(value, WhiteboardV1ProtocolMetadata.frames.drawAccess.exactFields) && isDrawPolicy(value.policy) && typeof value.can_draw === "boolean" && isCapabilities(value.capabilities) && Array.isArray(value.grants) && value.grants.length <= WhiteboardV1ProtocolLimits.drawAccessMaxGrants && value.grants.every(isDrawGrant);
     case "presentation_updated":
       return hasExactKeys(value, WhiteboardV1ProtocolMetadata.frames.presentationUpdated.exactFields) && isUuid(value.scene_id) && isUnsignedDecimal(value.revision) && typeof value.presenting === "boolean";
     case "reset_required":
       return hasExactKeys(value, WhiteboardV1ProtocolMetadata.frames.resetRequired.exactFields) && isUuid(value.scene_id) && typeof value.reason === "string" && WhiteboardV1ProtocolMetadata.resetReasons.some((reason) => reason === value.reason);
     case "operation_error":
-      return hasExactKeys(value, WhiteboardV1ProtocolMetadata.frames.operationError.exactFields) && isBoundedIdentifier(value.correlation_id, WhiteboardV1ProtocolLimits.requestIdMinBytes, WhiteboardV1ProtocolLimits.requestIdMaxBytes) && ["submit_update", "request_snapshot", "clear", "set_draw_permission", "set_presentation"].includes(String(value.operation)) && typeof value.code === "string" && WhiteboardV1ProtocolMetadata.errorCodes.some((code) => code === value.code) && typeof value.recoverable === "boolean" && typeof value.message === "string" && utf8Bytes(value.message) <= WhiteboardV1ProtocolLimits.errorMessageMaxBytes;
+      return hasExactKeys(value, WhiteboardV1ProtocolMetadata.frames.operationError.exactFields) && isBoundedIdentifier(value.correlation_id, WhiteboardV1ProtocolLimits.requestIdMinBytes, WhiteboardV1ProtocolLimits.requestIdMaxBytes) && ["submit_update", "request_snapshot", "clear", "set_draw_permission", "set_draw_policy", "set_presentation"].includes(String(value.operation)) && typeof value.code === "string" && WhiteboardV1ProtocolMetadata.errorCodes.some((code) => code === value.code) && typeof value.recoverable === "boolean" && typeof value.message === "string" && utf8Bytes(value.message) <= WhiteboardV1ProtocolLimits.errorMessageMaxBytes;
+    case "view_ack":
+      return hasExactKeys(value, ["type", "input_id"]) && isViewInputId(value.input_id);
     case "pong":
       return hasExactKeys(value, ["type"]);
     default:
@@ -685,11 +716,118 @@ function encodeWhiteboardV1Frame(frame) {
   return JSON.stringify(frame);
 }
 
+// src/whiteboard/view-bounds.ts
+var ChalkWhiteboardViewBounds = {
+  maxCoordinate: WhiteboardV1ProtocolMetadata.frames.view.maxCoordinate,
+  maxExtent: WhiteboardV1ProtocolMetadata.frames.view.maxExtent
+};
+
+// src/whiteboard/file-download-transport.ts
+function createChalkWhiteboardV1FileDownloadTransport(options) {
+  const fetchImplementation = options.fetch ?? globalThis.fetch;
+  let baseUrlEnd = options.baseUrl.length;
+  while (baseUrlEnd > 0 && options.baseUrl[baseUrlEnd - 1] === "/") baseUrlEnd -= 1;
+  const baseUrl = options.baseUrl.slice(0, baseUrlEnd);
+  return {
+    getDownloadUrl: async (fileId) => {
+      const response = await authorizedFetch(fetchImplementation, options.token, `${baseUrl}/v1/whiteboard/files/${encodeURIComponent(fileId)}/download`, { method: "GET" });
+      if (!response.ok) throw await responseError2(response, "get_file_download");
+      const value = await response.json();
+      if (!isDownloadResponse2(value)) {
+        throw whiteboardError("get_file_download", "file_transfer_failed", false, "Whiteboard download service returned an invalid response.");
+      }
+      return value;
+    }
+  };
+}
+async function authorizedFetch(fetchImplementation, token, url, init) {
+  try {
+    const authorization = await token();
+    const headers = new Headers(init.headers);
+    headers.set("authorization", `Bearer ${authorization}`);
+    return await fetchImplementation(url, { ...init, headers });
+  } catch (cause) {
+    throw new ChalkWhiteboardV1Error(
+      {
+        operation: "get_file_download",
+        code: "storage_unavailable",
+        recoverable: true,
+        message: "Whiteboard file storage is unavailable."
+      },
+      { cause }
+    );
+  }
+}
+async function responseError2(response, operation) {
+  const code = response.status === 401 || response.status === 403 ? "permission_denied" : response.status === 400 ? "invalid_payload" : response.status >= 500 || response.status === 429 ? "storage_unavailable" : "file_transfer_failed";
+  return whiteboardError(operation, code, response.status >= 500 || response.status === 429, "Whiteboard file request failed.");
+}
+function whiteboardError(operation, code, recoverable, message) {
+  return new ChalkWhiteboardV1Error({ operation, code, recoverable, message });
+}
+function isDownloadResponse2(value) {
+  return isExactObject(value, ["downloadUrl", "expiresAt"]) && isHttpUrl2(value.downloadUrl) && isDate2(value.expiresAt);
+}
+function isExactObject(value, keys) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+}
+function isHttpUrl2(value) {
+  if (typeof value !== "string") return false;
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function isDate2(value) {
+  return typeof value === "string" && !Number.isNaN(Date.parse(value));
+}
+
+// src/whiteboard/view-versions.ts
+var ChalkWhiteboardViewVersions = class {
+  #versions = /* @__PURE__ */ new Map();
+  isNew(view, participantId) {
+    const key = this.#key(view, participantId);
+    const sequence = view.ownerSequence ?? view.originSequence;
+    return key === void 0 || sequence === void 0 || sequence > (this.#versions.get(key) ?? 0);
+  }
+  remember(view, participantId) {
+    const key = this.#key(view, participantId);
+    const sequence = view.ownerSequence ?? view.originSequence;
+    if (key === void 0 || sequence === void 0 || !this.isNew(view, participantId)) return;
+    this.#versions.delete(key);
+    this.#versions.set(key, sequence);
+    if (this.#versions.size > WhiteboardV1ProtocolLimits.viewPeopleMaxItems) {
+      const oldest = this.#versions.keys().next().value;
+      if (oldest !== void 0) this.#versions.delete(oldest);
+    }
+  }
+  forgetParticipant(participantId) {
+    for (const key of this.#versions.keys()) {
+      if (key.startsWith(`${participantId}:`) || key.endsWith(`:${participantId}`)) this.#versions.delete(key);
+    }
+  }
+  clear() {
+    this.#versions.clear();
+  }
+  #key(view, participantId) {
+    if (view.ownerId && participantId) return `${view.ownerId}:${participantId}`;
+    return view.originParticipantId ? `${view.originParticipantId}:${view.originEpoch ?? ""}` : void 0;
+  }
+};
+
 // src/whiteboard/v1-codec.ts
+import { Schema as Schema2 } from "effect";
 function encodeWhiteboardV1ClientFrame(frame) {
   return encodeWhiteboardV1Frame(Schema2.decodeUnknownSync(WhiteboardV1ClientFrameSchema)(frame));
 }
 function decodeWhiteboardV1ServerFrame(wire) {
+  const frame = decodeWhiteboardV1WireFrame(wire);
+  if (frame.type === "view_ack" || frame.type === "draw_access") throw new Error("Negotiated whiteboard control frame");
+  return frame;
+}
+function decodeWhiteboardV1WireFrame(wire) {
   return Schema2.decodeUnknownSync(WhiteboardV1ServerFrameSchema)(JSON.parse(wire));
 }
 
@@ -884,15 +1022,28 @@ var MAX_TIMER_DRIFT_MS = 250;
 var MAX_SLOW_CONNECTION_BACKOFF_MS = 4e3;
 var DEFAULT_RECONNECT_DELAY_MS = 250;
 var MAX_RECONNECT_DELAY_MS = 5e3;
+var MAX_REJECTED_HELLO_RETRIES = 4;
+var CLOSE_STEPS = {
+  1008: { connecting: "retry-hello", authenticating: "retry-hello" },
+  1009: { authenticating: "step-down" }
+};
 var encoder2 = new TextEncoder();
 var ChalkWhiteboardV1Client = class {
   files;
   #options;
   #store;
   #listeners = /* @__PURE__ */ new Set();
+  #latestViews = /* @__PURE__ */ new Map();
   #summaryListeners = /* @__PURE__ */ new Set();
   #operations = /* @__PURE__ */ new Map();
+  /** Strictly increasing, so a restore replays operations made in the same millisecond in the order they were made. */
+  #lastCreatedAt = 0;
   #reservedOperationIds = /* @__PURE__ */ new Set();
+  /**
+   * Policy changes and per-person choices in the order the host made them. Only the first one is sent, and only once it
+   * is saved, so the order comes from creation and never from which save finishes first.
+   */
+  #accessChanges = [];
   #awaitingOperationIds = /* @__PURE__ */ new Set();
   #pendingStoreWrites = /* @__PURE__ */ new Set();
   #operationRetryTimers = /* @__PURE__ */ new Map();
@@ -900,6 +1051,7 @@ var ChalkWhiteboardV1Client = class {
   #updateAssembler = new WhiteboardV1UpdateAssembler();
   #updateAssemblyTimers = /* @__PURE__ */ new Map();
   #socket = null;
+  #cancelDial;
   #started = false;
   #startupGeneration = 0;
   #phase = "idle";
@@ -908,9 +1060,17 @@ var ChalkWhiteboardV1Client = class {
   #revision;
   #capabilities = [];
   #canDraw = false;
+  #drawPolicy = null;
+  #drawPermissions = [];
   #presentationSupported = false;
+  #viewsSupported = false;
   #presenting = false;
-  #useLegacyHello = false;
+  #hello = "owner-view";
+  #viewSequence = 0;
+  #viewOwnerId = null;
+  #viewVersions = new ChalkWhiteboardViewVersions();
+  #viewEpoch = crypto.randomUUID();
+  #pendingLeadingView = null;
   #summaryStatus = "unsubscribed";
   #summaryError = null;
   #latestSnapshot = null;
@@ -920,6 +1080,7 @@ var ChalkWhiteboardV1Client = class {
   #waitingForOperations = false;
   #reconnectTimer;
   #reconnectAttempt = 0;
+  #rejectedHelloRetries = 0;
   #heartbeatTimer;
   #heartbeats = [];
   #ignoredHeartbeats = 0;
@@ -957,7 +1118,9 @@ 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 = "owner-view";
+    this.#rejectedHelloRetries = 0;
+    this.#viewsSupported = false;
     this.#phase = "connecting";
     this.#publishSummary("loading", null);
     const generation = ++this.#startupGeneration;
@@ -981,11 +1144,15 @@ var ChalkWhiteboardV1Client = class {
   }
   #stopNow() {
     this.#started = false;
+    this.#viewsSupported = false;
+    this.#pendingLeadingView = 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();
@@ -1002,18 +1169,26 @@ var ChalkWhiteboardV1Client = class {
     this.#participantId = null;
     this.#capabilities = [];
     this.#canDraw = false;
+    this.#drawPolicy = null;
+    this.#drawPermissions = [];
     this.#presenting = false;
     this.#publishSummary("unsubscribed", null);
   }
   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());
@@ -1021,7 +1196,7 @@ var ChalkWhiteboardV1Client = class {
   }
   submitUpdate(input) {
     if (!this.#started || !this.#sceneId) this.#assertLive("submit_update");
-    if (!this.#canDraw || !this.#capabilities.includes("drawWhiteboard")) {
+    if (!this.#canDraw) {
       throw error(failure("submit_update", "permission_denied", false, "Whiteboard draw permission is required."));
     }
     const operationId = this.#nextId();
@@ -1034,7 +1209,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 +1217,57 @@ var ChalkWhiteboardV1Client = class {
     this.#lastCursorAt = now;
     this.#send(frame);
   }
+  get supportsViews() {
+    return this.#started && this.#viewsSupported && this.#viewExtensionEnabled;
+  }
+  get #viewExtensionEnabled() {
+    return viewsNegotiated(this.#hello);
+  }
+  get #presenceReady() {
+    return this.#phase === "live" && this.#summaryStatus === "ready" && this.#snapshots.size === 0;
+  }
+  forgetParticipant(participantId) {
+    this.#latestViews.delete(participantId);
+    this.#viewVersions.forgetParticipant(participantId);
+  }
+  sendView(view) {
+    if (!this.#started || !this.#viewExtensionEnabled) return false;
+    const frame = this.#viewFrame(view);
+    encodeWhiteboardV1ClientFrame(frame);
+    if (view.bring || view.lead !== false) this.#pendingLeadingView = { sceneId: this.#sceneId, view: { ...view }, frame };
+    if (!this.#presenceReady) return true;
+    this.#send(frame);
+    if (!this.#viewOwnerId && (view.bring || view.lead !== false)) this.#pendingLeadingView = null;
+    return true;
+  }
+  #viewFrame(view) {
+    const rectangle = { type: "view", x: view.x, y: view.y, width: view.width, height: view.height, bring: view.bring };
+    if (this.#viewOwnerId) {
+      const input = { input_id: `${this.#viewEpoch}:${++this.#viewSequence}`, move: view.lead !== false || view.bring };
+      return view.originParticipantId ? { ...rectangle, ...input, origin_participant_id: view.originParticipantId, origin_sequence: view.originSequence } : { ...rectangle, ...input };
+    }
+    if (view.bring || !viewOriginsNegotiated(this.#hello)) 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.#pendingLeadingView;
+    if (!pending) return;
+    if (pending.sceneId !== null && pending.sceneId !== this.#sceneId) {
+      this.#pendingLeadingView = null;
+      return;
+    }
+    if (!this.#viewOwnerId) {
+      this.#pendingLeadingView = null;
+      this.sendView(pending.view);
+      return;
+    }
+    const frame = pending.frame.input_id ? pending.frame : this.#viewFrame(pending.view);
+    this.#pendingLeadingView = { ...pending, frame };
+    this.#send(frame);
+  }
   requestSnapshot() {
     this.#assertLive("request_snapshot");
     return this.#requestSnapshot();
@@ -1068,12 +1294,22 @@ var ChalkWhiteboardV1Client = class {
     };
     await this.#queueOperation(frame);
   }
+  async setDrawPolicy(policy) {
+    this.#assertLive("set_draw_policy");
+    if (this.#drawPolicy === null) {
+      throw error(policyUnavailable());
+    }
+    if (!this.#capabilities.includes("manageWhiteboard")) {
+      throw error(failure("set_draw_policy", "permission_denied", false, "Whiteboard management permission is required."));
+    }
+    await this.#queueOperation({ type: "set_draw_policy", operation_id: this.#nextId(), policy });
+  }
   async setPresentation(presenting) {
     this.#assertLive("set_presentation");
     if (!this.#presentationSupported) {
       throw error(failure("set_presentation", "unavailable", true, "Whiteboard presentation is unavailable on this Sync server."));
     }
-    if (!this.#canDraw || !this.#capabilities.includes("drawWhiteboard")) {
+    if (!this.#canDraw) {
       throw error(failure("set_presentation", "permission_denied", false, "Whiteboard draw permission is required."));
     }
     const frame = {
@@ -1103,8 +1339,10 @@ var ChalkWhiteboardV1Client = class {
         void this.#store.remove(pending.operationId).catch(() => void 0);
         continue;
       }
-      if (this.#operations.size >= WhiteboardV1ProtocolLimits.pendingOperationMaxItems) return;
-      this.#operations.set(pending.operationId, { pending, retries: 0 });
+      if (this.#operationCount() >= WhiteboardV1ProtocolLimits.pendingOperationMaxItems) return;
+      this.#lastCreatedAt = Math.max(this.#lastCreatedAt, pending.createdAt);
+      if (!isAccessChange(pending.frame)) this.#operations.set(pending.operationId, { pending, retries: 0 });
+      else if (!this.#accessChange(pending.operationId)) this.#restoreAccessChange(pending);
     }
   }
   #validRestoredOperation(pending) {
@@ -1128,7 +1366,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 +1394,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");
     }
@@ -1153,7 +1405,7 @@ var ChalkWhiteboardV1Client = class {
       if (typeof data !== "string" || encoder2.encode(data).byteLength > WhiteboardV1ProtocolLimits.encodedOutboundFrameBytes) {
         throw new Error("invalid whiteboard frame size");
       }
-      const frame = decodeWhiteboardV1ServerFrame(data);
+      const frame = decodeWhiteboardV1WireFrame(data);
       if (frame.type !== "pong") {
         this.#lastProgressAt = this.#elapsedNow();
         this.#resetProbeState();
@@ -1193,13 +1445,46 @@ var ChalkWhiteboardV1Client = class {
           occurredAt: frame.occurred_at
         });
         return;
+      case "view_ack":
+        this.#requireLive();
+        if (this.#pendingLeadingView?.frame.input_id === frame.input_id) this.#pendingLeadingView = null;
+        return;
+      case "view": {
+        this.#requireLive();
+        if (this.#viewOwnerId && frame.owner_id !== this.#viewOwnerId) return;
+        const rectangle = {
+          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
+        };
+        const event = frame.owner_id ? { ...rectangle, ownerId: frame.owner_id, ownerSequence: frame.owner_sequence } : rectangle;
+        if (!this.#viewVersions.isNew(event, event.participantId)) return;
+        this.#viewVersions.remember(event, event.participantId);
+        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;
         this.#publishSummary("ready", null);
         return;
+      case "draw_access":
+        this.#requireLive();
+        this.#canDraw = frame.can_draw;
+        this.#capabilities = [...frame.capabilities];
+        this.#drawPolicy = frame.policy;
+        this.#drawPermissions = frame.grants.map((grant) => ({ participantId: grant.participant_id, canDraw: grant.can_draw }));
+        this.#publishSummary(this.#summaryStatus, this.#summaryError);
+        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 +1492,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."));
@@ -1261,25 +1547,50 @@ var ChalkWhiteboardV1Client = class {
   #welcome(frame) {
     if (this.#phase !== "authenticating") throw new Error("unexpected whiteboard welcome");
     this.#phase = "live";
+    this.#viewsSupported = this.#viewExtensionEnabled;
+    this.#adoptViewOwner("view_owner_id" in frame ? frame.view_owner_id ?? null : null);
     this.#reconnectAttempt = 0;
+    this.#rejectedHelloRetries = 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];
     this.#canDraw = frame.can_draw;
+    this.#drawPolicy = null;
+    this.#drawPermissions = [];
     this.#presentationSupported = "presenting" in frame;
     this.#presenting = "presenting" in frame ? frame.presenting : false;
-    this.#publishSummary("loading", null);
+    const refused = !drawPolicyNegotiated(this.#hello) && this.#dropPolicyChanges();
+    this.#publishSummary("loading", refused ? policyUnavailable() : null);
     this.#clearHeartbeat();
-    const pendingOperations = [...this.#operations.values()].sort((left, right) => compareChalkWhiteboardV1PendingOperations(left.pending, right.pending));
+    this.#resumePendingOperations();
+    this.#startHeartbeat(HEARTBEAT_INTERVAL_MS + Math.max(0, this.#nextSlowConnectionReplacementAt - this.#elapsedNow()));
+  }
+  #resumePendingOperations() {
+    this.#clearOperationRetryTimers();
+    for (const change of this.#accessChanges) if (change.state === "sent") change.state = "ready";
     this.#awaitingOperationIds.clear();
     this.#waitingForOperations = true;
-    for (const entry of pendingOperations) this.#awaitingOperationIds.add(entry.pending.operationId);
-    for (const entry of pendingOperations) {
-      this.#sendOperation(entry.pending.frame);
-    }
+    this.#sendInCreationOrder([...this.#operations.values()]);
     this.#requestSnapshotAfterOperations();
-    this.#startHeartbeat(HEARTBEAT_INTERVAL_MS + Math.max(0, this.#nextSlowConnectionReplacementAt - this.#elapsedNow()));
+  }
+  /** A Sync without draw_policy_v1 closes the socket on a policy change, so a change saved for a newer Sync is dropped, not replayed. */
+  #dropPolicyChanges() {
+    const dropped = this.#accessChanges.filter((change) => change.entry.pending.frame.type === "set_draw_policy");
+    for (const { entry } of dropped) {
+      const { operationId } = entry.pending;
+      this.#removeAccessChange(operationId);
+      this.#clearOperationRetryTimer(operationId);
+      entry.deferred && rejectDeferred(entry.deferred, error(policyUnavailable()));
+      this.#discardStoredOperation(operationId);
+    }
+    return dropped.length > 0;
+  }
+  #adoptViewOwner(ownerId) {
+    this.#viewOwnerId = ownerId;
+    this.#latestViews.clear();
+    this.#viewVersions.clear();
   }
   #requestSnapshotAfterOperations() {
     if (this.#phase !== "live" || !this.#waitingForOperations || this.#awaitingOperationIds.size > 0) return;
@@ -1325,6 +1636,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);
@@ -1348,46 +1660,80 @@ var ChalkWhiteboardV1Client = class {
     const pending = {
       operationId: frame.operation_id,
       frame,
-      createdAt: this.#now(),
+      createdAt: this.#lastCreatedAt = Math.max(this.#now(), this.#lastCreatedAt + 1),
       bytes: whiteboardV1PendingOperationBytes(frame)
     };
-    const queuedBytes = [...this.#operations.values()].reduce((total, entry) => total + entry.pending.bytes, 0);
+    const queuedBytes = this.#pendingEntries().reduce((total, entry) => total + entry.pending.bytes, 0);
     if (queuedBytes + pending.bytes > WhiteboardV1ProtocolLimits.multipartUpdateMaxBytes) {
       throw error(failure("submit_update", "unavailable", true, "Whiteboard operation byte capacity is full."));
     }
+    const { promise, deferred } = commitDeferred();
+    if (isAccessChange(frame)) return this.#queueAccessChange({ pending, deferred, retries: 0 }, deferred, promise);
     this.#reservedOperationIds.add(frame.operation_id);
+    const saveFailure = await this.#persist(pending);
+    this.#reservedOperationIds.delete(frame.operation_id);
+    if (saveFailure) throw saveFailure;
+    this.#operations.set(frame.operation_id, { pending, deferred, retries: 0 });
+    if (this.#phase === "live" && this.#snapshots.size === 0) {
+      if (this.#waitingForOperations) this.#awaitingOperationIds.add(frame.operation_id);
+      this.#sendOperation(frame);
+    }
+    return promise;
+  }
+  /**
+   * The change joins the list before its save starts, so a later change can't overtake it while it saves. The caller
+   * gets its one promise at once: a refusal or a rejected connection during the save settles it without waiting for
+   * the store, and a failed save settles it otherwise.
+   */
+  #queueAccessChange(entry, deferred, promise) {
+    const change = { entry, state: "saving" };
+    this.#accessChanges.push(change);
+    void this.#saveAccessChange(change, deferred);
+    return promise;
+  }
+  async #saveAccessChange(change, deferred) {
+    const { pending } = change.entry;
+    const saveFailure = await this.#persist(pending);
+    if (saveFailure) {
+      this.#removeAccessChange(pending.operationId);
+      this.#sendNextAccessChange();
+      rejectDeferred(deferred, saveFailure);
+      return;
+    }
+    if (!this.#accessChanges.includes(change)) {
+      this.#discardStoredOperation(pending.operationId);
+      return;
+    }
+    change.state = "ready";
+    this.#sendNextAccessChange();
+  }
+  /** Returns the failure instead of throwing it, so an access change can hand it to the promise its caller holds. */
+  async #persist(pending) {
     let storeWrite;
     try {
       storeWrite = this.#store.put(pending);
-    } catch (cause) {
-      throw error(failure(operationName(frame), "unavailable", true, "Unable to persist the whiteboard operation."), cause);
-    }
-    this.#pendingStoreWrites.add(storeWrite);
-    try {
+      this.#pendingStoreWrites.add(storeWrite);
       await storeWrite;
+      return void 0;
     } catch (cause) {
-      throw error(failure(operationName(frame), "unavailable", true, "Unable to persist the whiteboard operation."), cause);
+      this.#discardStoredOperation(pending.operationId);
+      return error(failure(operationName(pending.frame), "unavailable", true, "Unable to persist the whiteboard operation."), cause);
     } finally {
-      this.#pendingStoreWrites.delete(storeWrite);
-      this.#reservedOperationIds.delete(frame.operation_id);
-    }
-    let deferred;
-    const promise = new Promise((resolve, reject) => {
-      deferred = { resolve, reject, settled: false };
-    });
-    this.#operations.set(frame.operation_id, { pending, deferred, retries: 0 });
-    if (this.#phase === "live" && this.#snapshots.size === 0) {
-      if (this.#waitingForOperations) this.#awaitingOperationIds.add(frame.operation_id);
-      this.#sendOperation(frame);
+      if (storeWrite) this.#pendingStoreWrites.delete(storeWrite);
     }
-    return promise;
+  }
+  #discardStoredOperation(operationId) {
+    const cleanup = this.#store.remove(operationId).catch(() => void 0);
+    this.#pendingStoreWrites.add(cleanup);
+    void cleanup.finally(() => this.#pendingStoreWrites.delete(cleanup));
   }
   #commit(frame) {
     this.#requireLive();
-    const entry = this.#operations.get(frame.operation_id);
+    const entry = this.#sentEntry(frame.operation_id);
     if (!entry) return;
-    this.#operations.delete(frame.operation_id);
+    this.#forgetOperation(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);
@@ -1398,27 +1744,35 @@ var ChalkWhiteboardV1Client = class {
       revision: frame.revision
     });
     void this.#store.remove(frame.operation_id).catch(() => void 0);
+    this.#sendNextAccessChange();
     this.#requestSnapshotAfterOperations();
   }
   #operationError(frame) {
     this.#requireLive();
-    const entry = this.#operations.get(frame.correlation_id);
+    const entry = this.#sentEntry(frame.correlation_id);
     if (entry) {
-      if (frame.recoverable && retryableOperationCode(frame.code)) {
-        this.#scheduleOperationRetry(frame.correlation_id, entry);
-        return;
-      }
-      this.#operations.delete(frame.correlation_id);
-      this.#clearOperationRetryTimer(frame.correlation_id);
-      this.#awaitingOperationIds.delete(frame.correlation_id);
-      entry.deferred && rejectDeferred(entry.deferred, error(failure(operationName(entry.pending.frame), mapErrorCode(frame.code), frame.recoverable, frame.message)));
-      this.#publishSummary("ready", failure(operationName(entry.pending.frame), mapErrorCode(frame.code), frame.recoverable, frame.message));
-      void this.#store.remove(frame.correlation_id).catch(() => void 0);
-      this.#requestSnapshotAfterOperations();
+      this.#failOperation(entry, frame);
       return;
     }
     const snapshot = this.#snapshots.get(frame.correlation_id);
-    if (!snapshot) return;
+    if (snapshot) this.#failSnapshot(snapshot, frame);
+  }
+  #failOperation(entry, frame) {
+    if (frame.recoverable && retryableOperationCode(frame.code)) {
+      this.#scheduleOperationRetry(frame.correlation_id, entry);
+      return;
+    }
+    this.#forgetOperation(frame.correlation_id);
+    this.#clearOperationRetryTimer(frame.correlation_id);
+    this.#awaitingOperationIds.delete(frame.correlation_id);
+    const operationFailure = failure(operationName(entry.pending.frame), mapErrorCode(frame.code), frame.recoverable, frame.message);
+    entry.deferred && rejectDeferred(entry.deferred, error(operationFailure));
+    this.#publishSummary("ready", operationFailure);
+    void this.#store.remove(frame.correlation_id).catch(() => void 0);
+    this.#sendNextAccessChange();
+    this.#requestSnapshotAfterOperations();
+  }
+  #failSnapshot(snapshot, frame) {
     this.#snapshots.delete(frame.correlation_id);
     const snapshotError = error(failure("request_snapshot", mapErrorCode(frame.code), frame.recoverable, frame.message));
     this.#publishSummary(frame.recoverable ? "recovering" : "failed", failure("request_snapshot", mapErrorCode(frame.code), frame.recoverable, frame.message));
@@ -1428,20 +1782,69 @@ var ChalkWhiteboardV1Client = class {
       this.#initialSnapshot = null;
     }
     if (frame.recoverable) this.#flushQueuedOperations();
+    else this.#sendNextAccessChange();
   }
   #flushQueuedOperations() {
     if (this.#phase !== "live" || this.#snapshots.size > 0) return;
-    for (const entry of this.#operations.values()) {
-      if (!this.#awaitingOperationIds.has(entry.pending.operationId)) this.#sendOperation(entry.pending.frame);
+    this.#sendInCreationOrder([...this.#operations.values()].filter((entry) => !this.#awaitingOperationIds.has(entry.pending.operationId)));
+  }
+  #sendNextAccessChange() {
+    this.#sendInCreationOrder([]);
+  }
+  /** Sends the operations, and the first access change when it may go, in the order they were made. */
+  #sendInCreationOrder(operations) {
+    const head = this.#sendableAccessChange();
+    if (head) head.state = "sent";
+    const entries = [...operations, ...head ? [head.entry] : []].sort((left, right) => compareChalkWhiteboardV1PendingOperations(left.pending, right.pending));
+    for (const entry of entries) {
+      if (this.#waitingForOperations) this.#awaitingOperationIds.add(entry.pending.operationId);
+      this.#sendOperation(entry.pending.frame);
     }
   }
+  /**
+   * Access changes go out one at a time in the host's order, so a retried older change can't land after a newer one.
+   * Sync also stores a per-person choice according to the policy it lands under, so their order matters too.
+   */
+  #sendableAccessChange() {
+    if (this.#phase !== "live" || this.#snapshots.size > 0) return void 0;
+    const head = this.#accessChanges[0];
+    if (head?.state !== "ready" || this.#accessChanges.some((change) => change.state === "sent")) return void 0;
+    return head;
+  }
+  /** A restart keeps the changes it already holds, so a restored one goes where its creation puts it. */
+  #restoreAccessChange(pending) {
+    const later = this.#accessChanges.findIndex((change) => compareChalkWhiteboardV1PendingOperations(change.entry.pending, pending) > 0);
+    this.#accessChanges.splice(later < 0 ? this.#accessChanges.length : later, 0, { entry: { pending, retries: 0 }, state: "ready" });
+  }
+  #accessChange(operationId) {
+    return this.#accessChanges.find((change) => change.entry.pending.operationId === operationId);
+  }
+  #removeAccessChange(operationId) {
+    const index = this.#accessChanges.findIndex((change) => change.entry.pending.operationId === operationId);
+    if (index >= 0) this.#accessChanges.splice(index, 1);
+  }
+  /** The operation a receipt or an error can be about: any queued operation, or the access change that was sent. */
+  #sentEntry(operationId) {
+    const change = this.#accessChange(operationId);
+    return this.#operations.get(operationId) ?? (change?.state === "sent" ? change.entry : void 0);
+  }
+  #forgetOperation(operationId) {
+    this.#operations.delete(operationId);
+    this.#removeAccessChange(operationId);
+  }
+  #pendingEntries() {
+    return [...this.#operations.values(), ...this.#accessChanges.map((change) => change.entry)];
+  }
+  #operationCount() {
+    return this.#operations.size + this.#accessChanges.length;
+  }
   #scheduleOperationRetry(operationId, entry) {
     if (this.#operationRetryTimers.has(operationId)) return;
     entry.retries += 1;
     const timer = this.#clock().setTimeout(
       () => {
         this.#operationRetryTimers.delete(operationId);
-        if (this.#phase === "live" && this.#operations.get(operationId) === entry) this.#sendOperation(entry.pending.frame);
+        if (this.#phase === "live" && this.#sentEntry(operationId) === entry) this.#sendOperation(entry.pending.frame);
       },
       this.#options.retryDelayMs ?? Math.min(100 * 2 ** Math.min(entry.retries - 1, 4), 2e3)
     );
@@ -1449,25 +1852,41 @@ var ChalkWhiteboardV1Client = class {
   }
   #disconnected(socket, closeCode) {
     if (socket !== this.#socket) return;
-    const rejectedPresentationHello = this.#rejectedPresentationHello(closeCode);
+    const phase = this.#phase;
     this.#resetDisconnectedState();
     if (!this.#started || !this.#transportAvailable) return;
-    if (rejectedPresentationHello) {
-      this.#useLegacyHello = true;
-      this.#scheduleReconnect();
-      return;
-    }
-    if (terminalCloseCode(closeCode)) {
-      this.#failRejectedConnection(closeCode);
-      return;
-    }
-    this.#scheduleReconnect();
+    const step = CLOSE_STEPS[closeCode]?.[phase] ?? (terminalCloseCode(closeCode) ? "fail" : "reconnect");
+    if (this.#takeCloseStep(step, phase)) this.#scheduleReconnect();
+    else this.#failRejectedConnection(closeCode);
+  }
+  /** Returns false when the step has nothing left to try, so the connection fails. */
+  #takeCloseStep(step, phase) {
+    if (step === "fail") return false;
+    if (step === "step-down") return this.#stepDownHello();
+    if (step === "retry-hello") return this.#retryHello();
+    if (phase === "live") this.#hello = "owner-view";
+    return true;
   }
-  #rejectedPresentationHello(closeCode) {
-    return this.#phase === "authenticating" && !this.#useLegacyHello && terminalCloseCode(closeCode);
+  #stepDownHello() {
+    if (this.#hello === "legacy") return false;
+    this.#fallbackHello();
+    return true;
+  }
+  #retryHello() {
+    if (this.#rejectedHelloRetries >= MAX_REJECTED_HELLO_RETRIES) return false;
+    this.#rejectedHelloRetries += 1;
+    return true;
+  }
+  #fallbackHello() {
+    this.#hello = HELLO_LEVELS[Math.min(HELLO_LEVELS.indexOf(this.#hello) + 1, HELLO_LEVELS.length - 1)] ?? "legacy";
+    if (!viewsNegotiated(this.#hello)) this.#pendingLeadingView = null;
   }
   #resetDisconnectedState() {
+    this.#viewOwnerId = null;
+    this.#latestViews.clear();
+    this.#viewVersions.clear();
     this.#socket = null;
+    this.#clearDial();
     this.#clearHeartbeat();
     this.#clearUpdateAssemblies();
     this.#phase = "connecting";
@@ -1484,6 +1903,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;
@@ -1508,13 +1931,13 @@ var ChalkWhiteboardV1Client = class {
     if (this.#phase !== "live") throw new Error("whiteboard frame arrived before welcome");
   }
   #assertOperationCapacity() {
-    if (this.#operations.size + this.#reservedOperationIds.size >= WhiteboardV1ProtocolLimits.pendingOperationMaxItems) {
+    if (this.#operationCount() + this.#reservedOperationIds.size >= WhiteboardV1ProtocolLimits.pendingOperationMaxItems) {
       throw error(failure("submit_update", "unavailable", true, "Whiteboard operation capacity is full."));
     }
   }
   #nextId() {
     const id = this.#options.ids?.next() ?? crypto.randomUUID();
-    if (this.#operations.has(id) || this.#reservedOperationIds.has(id) || this.#snapshots.has(id)) {
+    if (this.#operations.has(id) || this.#accessChange(id) || this.#reservedOperationIds.has(id) || this.#snapshots.has(id)) {
       throw error(failure("submit_update", "invalid_payload", false, "Whiteboard operation ID is already pending."));
     }
     return id;
@@ -1527,11 +1950,26 @@ 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 > WhiteboardV1ProtocolLimits.viewPeopleMaxItems) {
+        const oldest = this.#latestViews.keys().next().value;
+        if (oldest !== void 0) this.#latestViews.delete(oldest);
+      }
+    }
     for (const listener of this.#listeners) listener(event);
+    if (event.type === "snapshot") {
+      for (const view of this.#latestViews.values()) {
+        for (const listener of this.#listeners) listener({ ...view, bring: false });
+      }
+    }
   }
   #publishSummary(status, summaryError) {
     this.#summaryStatus = status;
     this.#summaryError = summaryError;
+    if (status === "failed") this.#pendingLeadingView = null;
+    if (status === "ready") this.#flushPendingBring();
     const summary = this.#summary();
     try {
       this.#options.onSummary?.(summary);
@@ -1547,6 +1985,8 @@ var ChalkWhiteboardV1Client = class {
       capabilities: [...this.#capabilities],
       canDraw: this.#canDraw,
       canClear: this.#capabilities.includes("manageWhiteboard"),
+      drawPolicy: this.#drawPolicy,
+      drawPermissions: this.#drawPermissions,
       presenting: this.#presenting,
       error: this.#summaryError
     };
@@ -1645,7 +2085,7 @@ var ChalkWhiteboardV1Client = class {
     this.#snapshots.clear();
   }
   #rejectOperationCallers(value) {
-    for (const entry of this.#operations.values()) entry.deferred && rejectDeferred(entry.deferred, error({ ...value, operation: operationName(entry.pending.frame) }));
+    for (const entry of this.#pendingEntries()) entry.deferred && rejectDeferred(entry.deferred, error({ ...value, operation: operationName(entry.pending.frame) }));
   }
   #clearOperationRetryTimers() {
     for (const timer of this.#operationRetryTimers.values()) this.#clock().clearTimeout(timer);
@@ -1752,6 +2192,28 @@ function operationName(frame) {
 function retryableOperationCode(code) {
   return code === "unavailable" || code === "overloaded" || code === "rate_limited" || code === "storage_unavailable";
 }
+var HELLO_LEVELS = ["owner-view", "draw-policy", "versioned-view", "view", "presentation", "legacy"];
+function viewsNegotiated(level) {
+  return level === "owner-view" || level === "draw-policy" || level === "versioned-view" || level === "view";
+}
+function viewOriginsNegotiated(level) {
+  return level === "owner-view" || level === "draw-policy" || level === "versioned-view";
+}
+function drawPolicyNegotiated(level) {
+  return level === "owner-view" || level === "draw-policy";
+}
+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" }] };
+  if (level === "view") return { ...hello, extensions: [{ name: "presentation_v1" }, { name: "view_v1" }] };
+  if (level === "versioned-view") return { ...hello, extensions: [{ name: "presentation_v1" }, { name: "view_v1", origins: true }] };
+  if (level === "draw-policy") return { ...hello, extensions: [{ name: "presentation_v1" }, { name: "view_v1", origins: true }, { name: "draw_policy_v1" }] };
+  return { ...hello, extensions: [{ name: "presentation_v1" }, { name: "view_v1", origins: true, owner: true }, { name: "draw_policy_v1" }] };
+}
+function policyUnavailable() {
+  return failure("set_draw_policy", "unavailable", true, "The call-wide drawing policy is unavailable on this Sync server.");
+}
 function terminalCloseCode(closeCode) {
   return closeCode === 1008 || closeCode === 1009;
 }
@@ -1764,6 +2226,16 @@ function failure(operation, code, recoverable, message) {
 function error(value, cause) {
   return new ChalkWhiteboardV1Error(value, cause === void 0 ? void 0 : { cause });
 }
+function commitDeferred() {
+  let deferred;
+  const promise = new Promise((resolve, reject) => {
+    deferred = { resolve, reject, settled: false };
+  });
+  return { promise, deferred };
+}
+function isAccessChange(frame) {
+  return frame.type === "set_draw_policy" || frame.type === "set_draw_permission";
+}
 function resolveDeferred(deferred, value) {
   if (deferred.settled) return;
   deferred.settled = true;
@@ -1797,12 +2269,14 @@ var ConnectionError = class extends Error {
   code;
   action;
   recoverable;
+  sync;
   constructor(failure2, options) {
     super(failure2.message, options);
     this.name = "ConnectionError";
     this.code = failure2.code;
     this.action = failure2.action;
     this.recoverable = failure2.recoverable;
+    this.sync = failure2.sync;
   }
 };
 
@@ -1865,6 +2339,21 @@ function createDefaultConnectionDependencies(options) {
       clearTimeout: (handle) => globalThis.clearTimeout(handle)
     },
     mediaDevices: createBrowserMediaDevices(),
+    cancelPendingAdmission: async (access, signal) => {
+      const { tenantId, spaceId, episodeId, participantId } = access.subject;
+      const path = [tenantId, spaceId, episodeId, participantId].map(encodeURIComponent);
+      let baseEnd = options.apiBaseURL.length;
+      while (baseEnd > 0 && options.apiBaseURL[baseEnd - 1] === "/") baseEnd--;
+      const baseURL = options.apiBaseURL.slice(0, baseEnd);
+      const response = await fetch(`${baseURL}/v1/tenants/${path[0]}/spaces/${path[1]}/episodes/${path[2]}/participants/${path[3]}/cancel-join`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${access.media.token}` },
+        signal
+      });
+      if (!response.ok) throw new Error(`Admission cancellation failed with HTTP ${response.status}`);
+      const body = await response.json();
+      return typeof body === "object" && body !== null && "cancelled" in body && body.cancelled === true;
+    },
     createMediaClient: (input) => createMediaClient(options.apiBaseURL, input),
     createSyncClient: (input) => createSyncClient(options.syncURL, input),
     createChatFileTransport: (input) => createChatFileTransport(options.apiBaseURL, input),
@@ -1957,7 +2446,8 @@ function createSyncClient(syncURL, input) {
     token: input.token,
     mediaPlane: input.media,
     collaboration: { name: "collaboration_v2", chatCursor: { afterSequence: null, retainedFloorSequence: null } },
-    persistenceScope: `${input.access.subject.tenantId}:${input.access.subject.episodeId}:${input.access.subject.participantId}`
+    persistenceScope: `${input.access.subject.tenantId}:${input.access.subject.episodeId}:${input.access.subject.participantId}`,
+    entryConfirmation: true
   });
 }
 function createWhiteboardClient(apiBaseURL, url, input) {
@@ -2019,7 +2509,7 @@ var ConnectionDiagnostics = class {
     this.#onEvent = options.onEvent;
   }
   record(input) {
-    const event = Object.freeze({ timestamp: this.#now(), ...input });
+    const event = Object.freeze({ timestamp: this.#now(), ...input, ...input.sync ? { sync: Object.freeze({ ...input.sync }) } : {} });
     this.#events.push(event);
     if (this.#events.length > this.#limit) this.#events.splice(0, this.#events.length - this.#limit);
     try {
@@ -2123,6 +2613,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
@@ -2139,15 +2630,16 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       refreshInFlight: false,
       recoveryQueued: null,
       joinCancelled: false,
+      admissionCleanupConfirmed: true,
       closed: false,
       epoch: 0
     };
     const mediaAttempt = { expiresAt: null };
-    const foreign7 = (operation, code = "internal_error", message = "A browser transport operation failed") => Effect2.tryPromise({ try: operation, catch: (cause) => lifecycleFailure(code, true, message, cause) });
+    const foreign7 = (operation, code = "internal_error", message = "A browser transport operation failed") => Effect2.tryPromise({ try: operation, catch: (cause) => accessRejected(cause) ? lifecycleFailure("invalid_access", false, "Access was rejected", cause) : lifecycleFailure(code, true, message, cause) });
     const withinForegroundBudget = (effect, milliseconds, failure2) => Effect2.raceFirst(
       effect,
       Effect2.callback((resume) => {
-        const cancel = scheduleForegroundDeadline(platform.clock, milliseconds, () => resume(Effect2.fail(failure2)));
+        const cancel = scheduleForegroundDeadline(platform.clock, milliseconds, () => resume(Effect2.fail(typeof failure2 === "function" ? failure2() : failure2)));
         return Effect2.sync(cancel);
       })
     );
@@ -2267,8 +2759,24 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       model.syncBindingCleanup?.();
       model.syncNoticeUnresponsive = false;
       let latestSnapshot = null;
+      let observedDialTimeouts = 0;
+      let observedConnectFailure;
       let snapshotQueued = false;
+      const recordSyncDiagnostics = (snapshot) => {
+        if (sync !== model.sync) return;
+        const failure2 = snapshot.connection.connectFailure;
+        if (failure2 && failure2 !== observedConnectFailure) {
+          observedConnectFailure = failure2;
+          diagnostics.record({ event: "sync_connect_failed", state: model.state, epoch: model.epoch, code: "sync_hello_timeout", sync: failure2 });
+        }
+        const count = snapshot.connection.dialTimeoutCount ?? 0;
+        if (count > observedDialTimeouts) {
+          observedDialTimeouts = count;
+          diagnostics.record({ event: "sync_dial_timeout", state: model.state, epoch: model.epoch, attempt: count });
+        }
+      };
       const unsubscribe = sync.subscribe((snapshot) => {
+        recordSyncDiagnostics(snapshot);
         if (sync === model.sync && snapshot.connection.phase === "live") {
           const notice = snapshot.connection.noticeUnresponsive === true;
           if (notice !== model.syncNoticeUnresponsive) {
@@ -2330,7 +2838,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, () => syncStartupFailure(sync.getSnapshot())));
     const trace = (step, effect) => {
       const span = diagnostics.startSpan({ step, state: model.state, epoch: model.epoch });
       return effect.pipe(
@@ -2338,6 +2846,10 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
         Effect2.tapError(() => Effect2.sync(() => span.end({ state: model.state, epoch: model.epoch, outcome: "failed" })))
       );
     };
+    const confirmSyncEntry = (sync) => {
+      const confirmEntered = sync.confirmEntered?.bind(sync);
+      return confirmEntered ? trace("confirm_entered", foreign7(confirmEntered, "sync_start_failed", "Entry could not be confirmed")) : Effect2.void;
+    };
     const performJoin = (reason = "join", retried = false) => Effect2.gen(function* () {
       if (model.state === "live") return;
       if (model.state === "leaving" || model.closed) return yield* Effect2.fail(lifecycleFailure("invalid_state", false, "Cannot join an inactive Connection"));
@@ -2357,7 +2869,8 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
         stream = captured.stream;
         captureWarning = captured.failure;
         if (model.joinCancelled) return yield* Effect2.fail(lifecycleFailure("invalid_state", false, "Join was cancelled by Leave"));
-        const grant = yield* trace("access_initialize", access.initialize(reason));
+        const grant = yield* trace("access_initialize", reason === "access_retry" ? access.refreshAfterRejection() : access.initialize(reason));
+        model.admissionCleanupConfirmed = false;
         const media = yield* trace(
           "create_media_client",
           Effect2.try({
@@ -2388,12 +2901,20 @@ 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))))))
+            trace(
+              "start_sync",
+              foreign7(() => sync.start(), "sync_start_failed", "The sync layer could not start").pipe(
+                Effect2.mapError((failure2) => sync.getSnapshot().connection.connectFailure ? syncStartupFailure(sync.getSnapshot()) : failure2),
+                Effect2.andThen(trace("wait_for_sync_live", waitForSyncLive(sync, boundedInteger(options.syncStartupTimeoutMs, START_TIMEOUT_MS, 1, 6e4))))
+              )
+            )
           ],
           { concurrency: "unbounded", discard: true }
         );
+        if (model.joinCancelled) return yield* Effect2.fail(lifecycleFailure("invalid_state", false, "Join was cancelled by Leave"));
+        yield* confirmSyncEntry(sync);
       }).pipe(
         Effect2.matchEffect({
           onFailure: (cause) => Effect2.gen(function* () {
@@ -2407,8 +2928,9 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
             span.end({ state: model.state, epoch: model.epoch, outcome: "failed", code: failure2.code });
             const retry = !retried && failure2.code === "invalid_access";
             if (!retry) yield* recordFailure(failure2);
+            model.admissionCleanupConfirmed = yield* cancelPendingAdmission();
             yield* stopPorts();
-            if (retry) return yield* performJoin("access_retry", true);
+            if (retry) return yield* performJoin(model.admissionCleanupConfirmed ? "join" : "access_retry", true);
             yield* transition("failed");
             return yield* Effect2.fail(failure2);
           }),
@@ -2425,7 +2947,11 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       );
     });
     const performLeave = () => Effect2.gen(function* performLeaveEffect() {
-      if (model.state === "idle" || model.state === "left") return;
+      if (model.state === "idle") return;
+      if (model.state === "left") {
+        if (model.failure) return yield* Effect2.fail(lifecycleFailure("leave_unconfirmed", false, model.failure.message));
+        return;
+      }
       yield* transition("leaving");
       const confirmed = yield* leaveIsConfirmed();
       yield* stopPorts();
@@ -2434,11 +2960,27 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       yield* transition("left");
       if (!confirmed) return yield* Effect2.fail(lifecycleFailure("leave_unconfirmed", false, "The Episode left locally without a durable Leave acknowledgement"));
     });
+    const cancelPendingAdmission = () => Effect2.gen(function* () {
+      const grant = access.currentUnsafe();
+      if (!grant) return model.admissionCleanupConfirmed;
+      const cancel = platform.cancelPendingAdmission;
+      if (!cancel) return false;
+      const result = yield* Effect2.exit(
+        Effect2.tryPromise({
+          try: (signal) => cancel(grant, signal),
+          catch: (cause) => lifecycleFailure("internal_error", true, "Admission cancellation failed", cause)
+        }).pipe(Effect2.timeout(3e3))
+      );
+      return result._tag === "Success" && result.value;
+    });
     const leaveIsConfirmed = () => Effect2.gen(function* leaveIsConfirmedEffect() {
       const sync = model.sync;
-      if (!sync || model.episodeEndConfirmed || access.currentUnsafe() === null) return true;
-      const leave = foreign7(() => sync.leave()).pipe(Effect2.timeout(LEAVE_TIMEOUT_MS));
-      return (yield* Effect2.exit(leave))._tag === "Success";
+      if (model.episodeEndConfirmed) return true;
+      if (sync && (sync.getSnapshot().connection.phase === "live" || sync.getSnapshot().control !== null)) {
+        const leave = foreign7(() => sync.leave()).pipe(Effect2.timeout(LEAVE_TIMEOUT_MS));
+        if ((yield* Effect2.exit(leave))._tag === "Success") return true;
+      }
+      return yield* cancelPendingAdmission();
     });
     const publishFreshAccess = () => enqueue(
       Effect2.gen(function* () {
@@ -2652,7 +3194,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       if (snapshot.connection.phase === "idle" || snapshot.connection.phase === "stopped") return Effect2.succeed(true);
       if (snapshot.connection.phase !== "terminal") return Effect2.succeed(false);
       const failure2 = syncTerminalFailure(snapshot);
-      return failure2.recoverable ? Effect2.succeed(true) : Effect2.fail(failure2);
+      return syncAutoRecoverable(snapshot, failure2) ? Effect2.succeed(true) : Effect2.fail(failure2);
     };
     const recoverSync = (attempt) => Effect2.gen(function* () {
       const sync = model.sync;
@@ -2696,6 +3238,8 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
           else if (attempt.client === sync) attempt.started = true;
         })
       ).pipe(
+        Effect2.andThen(waitForSyncLive(sync, boundedInteger(options.recovery?.budgetMs, RECOVERY_BUDGET_MS, 1, 6e4))),
+        Effect2.andThen(Effect2.suspend(() => sync === model.sync && model.epoch === epoch && active(model) ? confirmSyncEntry(sync) : Effect2.fail(lifecycleFailure("invalid_state", false, "Sync recovery was superseded")))),
         Effect2.tapError(
           () => enqueue(
             Effect2.gen(function* () {
@@ -2708,7 +3252,6 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
           )
         )
       );
-      yield* waitForSyncLive(sync, boundedInteger(options.recovery?.budgetMs, RECOVERY_BUDGET_MS, 1, 6e4));
     });
     const handleSyncSnapshot = (sync, snapshot) => Effect2.gen(function* handleSyncSnapshotEffect() {
       if (!isCurrentSyncSnapshot(sync, snapshot)) return;
@@ -2729,7 +3272,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       }
       if (snapshot.connection.phase !== "terminal") return false;
       const failure2 = syncTerminalFailure(snapshot);
-      if (failure2.recoverable) return false;
+      if (syncAutoRecoverable(snapshot, failure2)) return false;
       yield* failForSnapshot(failure2);
       return true;
     });
@@ -2744,7 +3287,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
     });
     const syncNeedsRecovery = (snapshot) => active(model) && (snapshot.connection.phase === "connecting" || snapshot.connection.phase === "recovering" || snapshot.connection.phase === "terminal");
     const recordFailure = (failure2) => Effect2.sync(() => {
-      diagnostics.record({ event: "connection_failed", state: model.state, epoch: model.epoch, code: failure2.code });
+      diagnostics.record({ event: "connection_failed", state: model.state, epoch: model.epoch, code: failure2.code, ...failure2.sync ? { sync: failure2.sync } : {} });
     });
     const failForSnapshot = (failure2) => Effect2.gen(function* failForSnapshotEffect() {
       model.failure = toFailure(failure2);
@@ -2845,8 +3388,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 +3451,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
@@ -2935,7 +3479,7 @@ function lifecycleFailure(code, recoverable, message, cause) {
   return new ConnectionLifecycleFailure({ code, recoverable, message, ...cause === void 0 ? {} : { cause } });
 }
 function toFailure(value) {
-  return Object.freeze({ code: value.code, action: null, recoverable: value.recoverable, message: value.message });
+  return Object.freeze({ code: value.code, action: null, recoverable: value.recoverable, message: value.message, ...value.sync ? { sync: value.sync } : {} });
 }
 function accessFailure(value) {
   return lifecycleFailure(value.code === "access.invalid" ? "invalid_access" : "access_unavailable", value.code === "access.unavailable", value.code === "access.invalid" ? "Access was rejected" : "Could not reach the Space. Check your network and try again.", value.cause);
@@ -3027,10 +3571,20 @@ 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");
+  if (reason === "participant_inactive" || reason === "participant_removed" || reason === "stale_participant_generation" || reason === "access_rejected") return lifecycleFailure("invalid_access", false, "Participant access is no longer valid");
+  if (reason === "entry_timeout") return lifecycleFailure("sync_start_failed", true, "Call entry was not confirmed in time");
   return lifecycleFailure("sync_start_failed", true, "The Sync transport needs recovery");
 }
+function syncStartupFailure(snapshot) {
+  const sync = snapshot.connection.connectFailure ?? snapshot.connection.connectAttempt;
+  const message = sync?.opened === false ? "Sync could not reach the call service" : "Sync could not connect";
+  return new ConnectionLifecycleFailure({ code: "sync_hello_timeout", recoverable: true, message: `${message}${sync ? ` ${formatSyncConnectDiagnostic(sync)}` : " before the startup deadline"}`, ...sync ? { sync: Object.freeze({ ...sync }) } : {} });
+}
+function syncAutoRecoverable(snapshot, failure2) {
+  return failure2.recoverable && snapshot.connection.terminalReason !== "entry_timeout";
+}
 
 // src/space-client/errors.ts
 import { Data as Data3 } from "effect";
@@ -3045,6 +3599,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 +3623,36 @@ 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([
+  ["sync_hello_timeout", { failure: { code: "connection.sync_hello_timeout", recoverable: true, message: "Sync could not reach the call service. Try again." } }],
+  ["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)) {
+  const chatFileError2 = normalizeChatFileError(cause);
+  if (chatFileError2) return chatFileError2;
+  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
+      message: cause.message,
+      ...cause.sync ? { sync: cause.sync } : {}
     });
   }
-  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" });
@@ -3085,8 +3660,15 @@ function normalizeClientError(cause, fallback = "client.internal_error") {
   const message = cause instanceof Error ? cause.message : "The client operation failed";
   return new SpaceClientError({ code: fallback, recoverable: false, message });
 }
+function normalizeChatFileError(cause) {
+  if (!(cause instanceof ChalkChatFileError) || cause.code !== "unavailable") return null;
+  if (cause.stage === "token" && isAccessInvalid(cause.cause)) {
+    return new SpaceClientError({ code: "access.invalid", recoverable: false, message: cause.cause instanceof Error ? cause.cause.message : "Access was rejected" });
+  }
+  return new SpaceClientError({ code: cause.stage === "token" ? "access.unavailable" : "collaboration.unavailable", recoverable: cause.recoverable, message: cause.message });
+}
 function failureFromError(error2) {
-  return Object.freeze({ code: error2.code, recoverable: error2.recoverable, message: error2.message });
+  return Object.freeze({ code: error2.code, recoverable: error2.recoverable, message: error2.message, ...error2.sync ? { sync: error2.sync } : {} });
 }
 function isAccessInvalid(cause) {
   if (typeof cause !== "object" || cause === null || !("code" in cause)) return false;
@@ -3120,7 +3702,7 @@ var EMPTY = empty({
   reactions: empty({ active: empty([]) }),
   recording: empty({ current: null }),
   offline: empty({ pending: empty([]), decisionNeeded: false, policy: "send" }),
-  whiteboard: empty({ open: false, engine: empty({ status: "unsubscribed", sceneId: null, revision: null, presenting: false, error: null }) })
+  whiteboard: empty({ open: false, engine: empty({ status: "unsubscribed", sceneId: null, revision: null, presenting: false, error: null }), access: empty({ canDraw: false, policy: null, permissions: empty([]) }) })
 });
 var SpaceStore = class _SpaceStore {
   #listeners = /* @__PURE__ */ new Set();
@@ -3146,6 +3728,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 +3782,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, ...failure2.sync ? { sync: failure2.sync } : {} }) : 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 +3802,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";
@@ -3366,13 +3923,13 @@ var ChatControllerRuntime = class {
   #unsubscribeConnection = null;
   #unsubscribeEvents = null;
   #unsubscribeSnapshot = null;
-  constructor(connection, store, transport, apiBaseUrl, fetch, fork, offline) {
+  constructor(connection, store, transport, apiBaseUrl, fetch2, fork, offline) {
     this.#offline = offline;
     this.#apiBaseUrl = apiBaseUrl.replace(/\/+$/u, "");
     this.#connection = connection;
     this.#store = store;
     this.#transport = transport;
-    this.#fetch = fetch;
+    this.#fetch = fetch2;
     this.#fork = fork;
     this.#unsubscribeConnection = connection.subscribePorts((ports) => this.#bind(ports));
   }
@@ -3450,7 +4007,7 @@ var ChatControllerRuntime = class {
     });
   };
   upload = (file) => {
-    const fetch = this.#fetch;
+    const fetch2 = this.#fetch;
     return Effect4.suspend(() => {
       if (!this.#transport) {
         return Effect4.fail(new SpaceClientError({ code: "collaboration.unavailable", recoverable: false, message: "Chat file upload is unavailable" }));
@@ -3465,7 +4022,10 @@ var ChatControllerRuntime = class {
                   Effect4.flatMap(
                     (upload) => Effect4.void.pipe(
                       Effect4.andThen(
-                        foreign(() => fetch(upload.uploadUrl, { method: upload.method, headers: upload.headers, body: bytes })).pipe(
+                        Effect4.tryPromise({
+                          try: () => fetch2(upload.uploadUrl, { method: upload.method, headers: upload.headers, body: bytes }),
+                          catch: () => new SpaceClientError({ code: "collaboration.unavailable", recoverable: true, message: CHAT_FILE_REACHABILITY_MESSAGE })
+                        }).pipe(
                           Effect4.flatMap((response) => {
                             if (!response.ok) {
                               return Effect4.fail(new SpaceClientError({ code: "command.rejected", recoverable: response.status >= 500, message: `Attachment upload failed with HTTP ${response.status}` }));
@@ -3786,8 +4346,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 +4375,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 +4390,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 +4418,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 +4847,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 +5095,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 +5111,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 +5120,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 +5155,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 +5256,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 +5270,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 +5279,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 +5298,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 +5400,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";
@@ -4911,6 +5770,7 @@ var ParticipantsControllerRuntime = class {
     publish();
   }
   #publish(snapshot, collaborationCapabilities, media) {
+    if (snapshot && !controlFor(snapshot)) return;
     const audioParticipants = new Set(media?.remoteTracks.filter((track) => track.source === "screen_audio" && track.track.readyState === "live").map((track) => track.participantId));
     if (snapshot?.participantId && media?.localTracks.some((track) => track.source === "screen_audio" && track.enabled && track.track.readyState === "live")) audioParticipants.add(snapshot.participantId);
     const projected = participantsFor(snapshot, collaborationCapabilities);
@@ -5245,7 +6105,7 @@ function foreign5(operation) {
 
 // src/space-client/whiteboard-controller.ts
 import { Context as Context11, Effect as Effect10, Layer as Layer11 } from "effect";
-var EMPTY_SUMMARY = Object.freeze({ status: "unsubscribed", sceneId: null, revision: null, capabilities: Object.freeze([]), canDraw: false, canClear: false, presenting: false, error: null });
+var EMPTY_SUMMARY = Object.freeze({ status: "unsubscribed", sceneId: null, revision: null, capabilities: Object.freeze([]), canDraw: false, canClear: false, drawPolicy: null, drawPermissions: Object.freeze([]), presenting: false, error: null });
 var WhiteboardControllerService = class extends Context11.Service()("@chalk/client/WhiteboardController") {
 };
 var makeWhiteboardController = (connection, store, create) => Effect10.gen(function* () {
@@ -5268,13 +6128,22 @@ var WhiteboardControllerRuntime = class {
   #connected = false;
   #summary = EMPTY_SUMMARY;
   #unsubscribe = null;
+  #unsubscribeRoster = null;
   constructor(connection, store, transport) {
     this.#store = store;
     this.#transport = transport;
+    let roster = new Set(store.getSnapshot().participants.roster.map((person) => person.participantId));
+    this.#unsubscribeRoster = store.subscribe(() => {
+      const next = new Set(store.getSnapshot().participants.roster.map((person) => person.participantId));
+      for (const id of roster) if (!next.has(id)) transport?.forgetParticipant?.(id);
+      roster = next;
+    });
     this.#unsubscribe = connection.subscribePorts((ports) => this.#bind(ports));
   }
   transport = () => this.#transport;
   dispose() {
+    this.#unsubscribeRoster?.();
+    this.#unsubscribeRoster = null;
     this.#unsubscribe?.();
     this.#unsubscribe = null;
     this.#bind(null);
@@ -5288,6 +6157,8 @@ var WhiteboardControllerRuntime = class {
       capabilities: Object.freeze([...summary.capabilities]),
       canDraw: summary.canDraw,
       canClear: summary.canClear,
+      drawPolicy: summary.drawPolicy,
+      drawPermissions: Object.freeze(summary.drawPermissions.map((permission) => Object.freeze({ ...permission }))),
       presenting: summary.presenting,
       error: summary.error ? Object.freeze({ ...summary.error }) : null
     });
@@ -5305,14 +6176,21 @@ var WhiteboardControllerRuntime = class {
     this.#publish();
   }
   #publish() {
-    const slice = Object.freeze({ open: this.#summary.status !== "unsubscribed", engine: Object.freeze({ status: this.#summary.status, sceneId: this.#summary.sceneId, revision: this.#summary.revision, presenting: this.#summary.presenting, error: this.#summary.error }) });
+    const slice = Object.freeze({
+      open: this.#summary.status !== "unsubscribed",
+      engine: Object.freeze({ status: this.#summary.status, sceneId: this.#summary.sceneId, revision: this.#summary.revision, presenting: this.#summary.presenting, error: this.#summary.error }),
+      access: Object.freeze({ canDraw: this.#summary.canDraw, policy: this.#summary.drawPolicy, permissions: this.#summary.drawPermissions })
+    });
     const current = this.#store.getSnapshot().whiteboard;
     if (sameWhiteboard(current, slice)) return;
     this.#store.updateWhiteboard(slice);
   }
 };
 function sameWhiteboard(left, right) {
-  return left.open === right.open && left.engine.status === right.engine.status && left.engine.sceneId === right.engine.sceneId && left.engine.revision === right.engine.revision && left.engine.presenting === right.engine.presenting && sameError2(left.engine.error, right.engine.error);
+  return left.open === right.open && left.engine.status === right.engine.status && left.engine.sceneId === right.engine.sceneId && left.engine.revision === right.engine.revision && left.engine.presenting === right.engine.presenting && sameError2(left.engine.error, right.engine.error) && sameAccess(left.access, right.access);
+}
+function sameAccess(left, right) {
+  return left.canDraw === right.canDraw && left.policy === right.policy && left.permissions.length === right.permissions.length && left.permissions.every((permission, index) => permission.participantId === right.permissions[index]?.participantId && permission.canDraw === right.permissions[index]?.canDraw);
 }
 function sameError2(left, right) {
   if (left === right) return true;
@@ -5404,7 +6282,7 @@ var makeSpaceClientCoreLayer = (options, platform = {}) => {
     diagnostics: {
       onEvent: (event) => {
         platform.onConnectionDiagnostic?.(event);
-        options.logger?.debug?.("SpaceClient connection event", { event: event.event, state: event.state, epoch: event.epoch, ...event.code ? { code: event.code } : {} });
+        options.logger?.debug?.("SpaceClient connection event", { event: event.event, state: event.state, epoch: event.epoch, ...event.code ? { code: event.code } : {}, ...event.sync ? { sync: event.sync } : {} });
       }
     }
   });
@@ -5470,8 +6348,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)),
@@ -5665,7 +6543,9 @@ export {
   CHALK_CHAT_ATTACHMENT_MIME_TYPES,
   ChalkChatFileError,
   createChalkChatFileHttpTransport,
+  ChalkWhiteboardViewBounds,
   createChalkWhiteboardV1FileDownloadTransport,
+  ChalkWhiteboardViewVersions,
   encodeWhiteboardV1ClientFrame,
   decodeWhiteboardV1ServerFrame,
   InMemoryChalkWhiteboardV1PendingOperationStore,