@q9labsai/chalk-client 5.1.0 → 5.2.1

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

@@ -1,12 +1,12 @@
-import {
-  AccessGrantError,
-  requireParsedAccessGrant
-} from "./chunk-3ZN7IXOZ.js";
 import {
   CloudflareSFUClient,
   createCloudflareSFUHTTPTransport,
   describeMediaCaptureError
 } from "./chunk-DWKTGBHR.js";
+import {
+  AccessGrantError,
+  requireParsedAccessGrant
+} from "./chunk-GA3JDPFI.js";
 import {
   ChatAttachmentMimeTypeSchema,
   ChatReactionSetFrameSchema,
@@ -17,8 +17,9 @@ import {
   createBrowserSyncLifecycle,
   createBrowserWebSocketFactory,
   createV1SyncClient,
+  formatSyncConnectDiagnostic,
   scheduleSyncDialDeadline
-} from "./chunk-K7PNW3KI.js";
+} from "./chunk-TVNI2XUZ.js";
 
 // src/access/manager.ts
 import { Clock, Context, Data, Effect, Layer, SynchronizedRef } from "effect";
@@ -33,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(() => {
@@ -184,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";
   }
 };
 
@@ -240,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();
@@ -259,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";
@@ -306,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 = {
@@ -389,7 +337,12 @@ var WhiteboardV1ProtocolMetadata = {
     view: {
       name: "view_v1",
       exactFields: ["name"],
-      extendedExactFields: ["name", "origins"]
+      extendedExactFields: ["name", "origins"],
+      ownerExactFields: ["name", "origins", "owner"]
+    },
+    drawPolicy: {
+      name: "draw_policy_v1",
+      exactFields: ["name"]
     }
   },
   identity: {
@@ -398,6 +351,7 @@ var WhiteboardV1ProtocolMetadata = {
     generationFenced: true
   },
   capabilities: ["drawWhiteboard", "manageWhiteboard"],
+  drawPolicies: ["everyone", "hosts", "picked"],
   phases: [
     {
       id: "awaiting_hello",
@@ -406,7 +360,7 @@ var WhiteboardV1ProtocolMetadata = {
     },
     {
       id: "live",
-      accepts: ["submit_update", "submit_update_part", "request_snapshot", "snapshot_ack", "clear", "set_draw_permission", "set_presentation", "cursor", "view", "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
     }
@@ -436,6 +390,7 @@ var WhiteboardV1ProtocolMetadata = {
     socketQueueMaxAgeMs: 5e3,
     cursorTtlMs: 1e4,
     cursorRatePerSecond: 60,
+    viewPeopleMaxItems: 500,
     pendingOperationMaxItems: 128,
     multipartUpdateMaxParts: 128,
     multipartUpdateMaxItems: 1e4,
@@ -443,7 +398,8 @@ var WhiteboardV1ProtocolMetadata = {
     multipartUpdateTimeoutMs: 1e4,
     sceneElementMaxItems: 1e4,
     sceneJsonMaxBytes: 67108864,
-    sceneObjectMaxBytes: 268435456
+    sceneObjectMaxBytes: 268435456,
+    drawAccessMaxGrants: 1024
   },
   cursor: {
     sceneId: "uuid",
@@ -479,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"]
     },
@@ -490,11 +449,14 @@ var WhiteboardV1ProtocolMetadata = {
       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"]
     },
@@ -513,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"]
     },
@@ -523,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", "view", "ping"],
-  serverFrames: ["welcome", "snapshot_page", "update", "update_part", "commit", "cursor", "view", "permission_updated", "presentation_updated", "reset_required", "operation_error", "pong"],
-  receiptOperations: ["submit_update", "clear", "set_draw_permission", "set_presentation"],
+  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"],
@@ -640,18 +606,33 @@ 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 isViewFields(value, WhiteboardV1ProtocolMetadata.frames.view.clientExactFields) && isViewRect(value) && typeof value.bring === "boolean" && encodedWhiteboardV1FrameBytes(value) <= WhiteboardV1ProtocolLimits.cursorFrameBytes;
+      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];
@@ -668,10 +649,24 @@ function isExtension(value, extension) {
   return hasExactKeys(value, extension.exactFields) && value.name === extension.name;
 }
 function isExtensions(value) {
-  const { presentation, view } = WhiteboardV1ProtocolMetadata.extensions;
-  return Array.isArray(value) && (value.length === 1 || value.length === 2) && isExtension(value[0], presentation) && (value.length === 1 || isExtension(value[1], view) || hasExactKeys(value[1], view.extendedExactFields) && value[1].name === view.name && value[1].origins === true);
+  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";
 }
@@ -691,15 +686,19 @@ function isServerFrame(value) {
     case "cursor":
       return hasExactKeys(value, WhiteboardV1ProtocolMetadata.frames.cursor.serverExactFields) && isUuid(value.participant_id) && typeof value.display_name === "string" && utf8Bytes(value.display_name) > 0 && utf8Bytes(value.display_name) <= WhiteboardV1ProtocolLimits.displayNameMaxBytes && isFiniteNumber(value.x) && isFiniteNumber(value.y) && typeof value.occurred_at === "string" && !Number.isNaN(Date.parse(value.occurred_at)) && encodedWhiteboardV1FrameBytes(value) <= WhiteboardV1ProtocolLimits.cursorFrameBytes;
     case "view":
-      return isViewFields(value, WhiteboardV1ProtocolMetadata.frames.view.serverExactFields) && isUuid(value.participant_id) && typeof value.display_name === "string" && utf8Bytes(value.display_name) > 0 && utf8Bytes(value.display_name) <= WhiteboardV1ProtocolLimits.displayNameMaxBytes && isViewRect(value) && typeof value.bring === "boolean" && typeof value.occurred_at === "string" && !Number.isNaN(Date.parse(value.occurred_at)) && encodedWhiteboardV1FrameBytes(value) <= WhiteboardV1ProtocolLimits.cursorFrameBytes;
+      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:
@@ -717,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));
 }
 
@@ -916,6 +1022,11 @@ 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;
@@ -925,7 +1036,14 @@ var ChalkWhiteboardV1Client = class {
   #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();
@@ -942,13 +1060,17 @@ var ChalkWhiteboardV1Client = class {
   #revision;
   #capabilities = [];
   #canDraw = false;
+  #drawPolicy = null;
+  #drawPermissions = [];
   #presentationSupported = false;
   #viewsSupported = false;
   #presenting = false;
-  #hello = "versioned-view";
+  #hello = "owner-view";
   #viewSequence = 0;
+  #viewOwnerId = null;
+  #viewVersions = new ChalkWhiteboardViewVersions();
   #viewEpoch = crypto.randomUUID();
-  #pendingBring = null;
+  #pendingLeadingView = null;
   #summaryStatus = "unsubscribed";
   #summaryError = null;
   #latestSnapshot = null;
@@ -958,6 +1080,7 @@ var ChalkWhiteboardV1Client = class {
   #waitingForOperations = false;
   #reconnectTimer;
   #reconnectAttempt = 0;
+  #rejectedHelloRetries = 0;
   #heartbeatTimer;
   #heartbeats = [];
   #ignoredHeartbeats = 0;
@@ -995,7 +1118,8 @@ var ChalkWhiteboardV1Client = class {
     if (this.#started && this.#startPromise) return this.#startPromise;
     this.#started = true;
     globalThis.document?.addEventListener("visibilitychange", this.#visibilityChanged);
-    this.#hello = "versioned-view";
+    this.#hello = "owner-view";
+    this.#rejectedHelloRetries = 0;
     this.#viewsSupported = false;
     this.#phase = "connecting";
     this.#publishSummary("loading", null);
@@ -1021,7 +1145,7 @@ var ChalkWhiteboardV1Client = class {
   #stopNow() {
     this.#started = false;
     this.#viewsSupported = false;
-    this.#pendingBring = null;
+    this.#pendingLeadingView = null;
     this.#latestViews.clear();
     this.#removeVisibilityListener();
     this.#startupGeneration += 1;
@@ -1045,6 +1169,8 @@ var ChalkWhiteboardV1Client = class {
     this.#participantId = null;
     this.#capabilities = [];
     this.#canDraw = false;
+    this.#drawPolicy = null;
+    this.#drawPermissions = [];
     this.#presenting = false;
     this.#publishSummary("unsubscribed", null);
   }
@@ -1070,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();
@@ -1095,35 +1221,52 @@ var ChalkWhiteboardV1Client = class {
     return this.#started && this.#viewsSupported && this.#viewExtensionEnabled;
   }
   get #viewExtensionEnabled() {
-    return this.#hello === "view" || this.#hello === "versioned-view";
+    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 (!this.#presenceReady) {
-      if (view.bring) this.#pendingBring = { sceneId: this.#sceneId, view: { ...view } };
-      return true;
-    }
-    if (view.bring) this.#pendingBring = null;
+    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 (view.bring || this.#hello !== "versioned-view") return rectangle;
+    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.#pendingBring;
-    this.#pendingBring = null;
-    if (pending && (pending.sceneId === null || pending.sceneId === this.#sceneId)) this.sendView(pending.view);
+    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");
@@ -1151,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 = {
@@ -1186,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) {
@@ -1250,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();
@@ -1290,9 +1445,14 @@ 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();
-        const event = {
+        if (this.#viewOwnerId && frame.owner_id !== this.#viewOwnerId) return;
+        const rectangle = {
           type: "view",
           participantId: frame.participant_id,
           displayName: frame.display_name,
@@ -1303,6 +1463,9 @@ var ChalkWhiteboardV1Client = class {
           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;
       }
@@ -1311,6 +1474,14 @@ var ChalkWhiteboardV1Client = class {
         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();
@@ -1342,7 +1513,6 @@ var ChalkWhiteboardV1Client = class {
   }
   #update(frame) {
     this.#requireLive();
-    if (this.#sceneId !== frame.scene_id) this.#latestViews.clear();
     this.#sceneId = frame.scene_id;
     this.#revision = frame.revision;
     this.#publishSummary("ready", null);
@@ -1377,27 +1547,50 @@ var ChalkWhiteboardV1Client = class {
   #welcome(frame) {
     if (this.#phase !== "authenticating") throw new Error("unexpected whiteboard welcome");
     this.#phase = "live";
-    this.#viewsSupported = this.#hello === "view" || this.#hello === "versioned-view";
+    this.#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;
@@ -1467,45 +1660,78 @@ 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;
@@ -1518,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));
@@ -1548,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)
     );
@@ -1569,30 +1852,39 @@ var ChalkWhiteboardV1Client = class {
   }
   #disconnected(socket, closeCode) {
     if (socket !== this.#socket) return;
-    const rejectedPresentationHello = this.#rejectedPresentationHello(closeCode);
-    const wasLive = this.#phase === "live";
+    const phase = this.#phase;
     this.#resetDisconnectedState();
     if (!this.#started || !this.#transportAvailable) return;
-    if (rejectedPresentationHello) {
-      this.#fallbackHello();
-      this.#scheduleReconnect();
-      return;
-    }
-    if (terminalCloseCode(closeCode)) {
-      this.#failRejectedConnection(closeCode);
-      return;
-    }
-    if (wasLive) this.#hello = "versioned-view";
-    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.#hello !== "legacy" && 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 = this.#hello === "versioned-view" ? "view" : this.#hello === "view" ? "presentation" : "legacy";
-    if (this.#hello !== "view") this.#pendingBring = null;
+    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();
@@ -1639,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;
@@ -1661,17 +1953,22 @@ var ChalkWhiteboardV1Client = class {
     if (event.type === "view") {
       this.#latestViews.delete(event.participantId);
       this.#latestViews.set(event.participantId, event);
-      if (this.#latestViews.size > 256) {
+      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.#pendingBring = null;
+    if (status === "failed") this.#pendingLeadingView = null;
     if (status === "ready") this.#flushPendingBring();
     const summary = this.#summary();
     try {
@@ -1688,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
     };
@@ -1786,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);
@@ -1893,11 +2192,27 @@ 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" }] };
-  return { ...hello, extensions: [{ name: "presentation_v1" }, level === "versioned-view" ? { name: "view_v1", origins: true } : { name: "view_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;
@@ -1911,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;
@@ -1939,23 +2264,19 @@ function createChalkWhiteboardV1Client(options) {
   });
 }
 
-// src/whiteboard/index.ts
-var ChalkWhiteboardViewBounds = {
-  maxCoordinate: WhiteboardV1ProtocolMetadata.frames.view.maxCoordinate,
-  maxExtent: WhiteboardV1ProtocolMetadata.frames.view.maxExtent
-};
-
 // src/connection/types.ts
 var ConnectionError = class extends Error {
   code;
   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;
   }
 };
 
@@ -2018,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),
@@ -2110,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) {
@@ -2172,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 {
@@ -2284,6 +2621,7 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       initialMediaIntent: null,
       intent: { microphone: options.initialMicrophoneEnabled ?? true, camera: options.initialCameraEnabled ?? true },
       episodeEndConfirmed: false,
+      episodeEndReason: void 0,
       removedByHost: false,
       activeScope: null,
       syncBindingCleanup: null,
@@ -2293,15 +2631,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);
       })
     );
@@ -2422,13 +2761,23 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       model.syncNoticeUnresponsive = false;
       let latestSnapshot = null;
       let observedDialTimeouts = 0;
+      let observedConnectFailure;
       let snapshotQueued = false;
-      const unsubscribe = sync.subscribe((snapshot) => {
+      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 (sync === model.sync && count > observedDialTimeouts) {
+        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) {
@@ -2490,7 +2839,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_hello_timeout", 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(
@@ -2498,12 +2847,17 @@ 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"));
       model.epoch += 1;
       model.failure = null;
       model.episodeEndConfirmed = false;
+      model.episodeEndReason = void 0;
       model.removedByHost = false;
       yield* transition("joining");
       const span = diagnostics.startSpan({ step: "join", state: model.state, epoch: model.epoch });
@@ -2517,7 +2871,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({
@@ -2550,10 +2905,18 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
               "start_media",
               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* () {
@@ -2567,8 +2930,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);
           }),
@@ -2585,7 +2949,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();
@@ -2594,11 +2962,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* () {
@@ -2812,7 +3196,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;
@@ -2856,6 +3240,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* () {
@@ -2868,7 +3254,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;
@@ -2882,14 +3267,17 @@ var makeConnectionLifecycleLayerFromServices = (options) => Layer3.effect(
       const ended = episodeEnded(snapshot);
       const removed = snapshot.connection.terminalReason === "participant_removed";
       if (ended || removed || snapshot.connection.terminalReason === "participant_inactive") {
-        if (ended) model.episodeEndConfirmed = true;
+        if (ended) {
+          model.episodeEndConfirmed = true;
+          model.episodeEndReason = snapshot.control?.endReason;
+        }
         if (removed) model.removedByHost = true;
         yield* finishTerminalSnapshot();
         return true;
       }
       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;
     });
@@ -2904,7 +3292,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);
@@ -3071,6 +3459,7 @@ function snapshotFor(model, access) {
     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,
+    episodeEndReason: model.episodeEndReason,
     removedByHost: model.removedByHost
   });
 }
@@ -3096,7 +3485,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);
@@ -3190,9 +3579,18 @@ 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";
@@ -3233,6 +3631,7 @@ var INVALID_PAYLOAD_CODE_BY_ACTION = /* @__PURE__ */ new Map([
 ]);
 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 }],
@@ -3247,11 +3646,14 @@ function normalizeMediaError(cause) {
 }
 function normalizeClientError(cause, fallback = "client.internal_error", scope) {
   if (cause instanceof SpaceClientError) return cause;
+  const chatFileError2 = normalizeChatFileError(cause);
+  if (chatFileError2) return chatFileError2;
   if (cause instanceof ConnectionLifecycleFailure || isConnectionError(cause)) {
     return new SpaceClientError({
       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) {
@@ -3264,8 +3666,15 @@ function normalizeClientError(cause, fallback = "client.internal_error", scope)
   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;
@@ -3299,7 +3708,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();
@@ -3329,6 +3738,7 @@ var SpaceStore = class _SpaceStore {
       episode: snapshot.episode,
       lastError: sameError(current.lastError, error2) ? current.lastError : error2,
       episodeEnded: snapshot.episodeEnded ?? false,
+      episodeEndReason: snapshot.episodeEndReason,
       removedByHost: snapshot.removedByHost ?? false
     };
     if (sameConnection(current, next)) return;
@@ -3380,14 +3790,14 @@ 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 connectionError(failure2) {
-  return failure2 ? empty({ code: connectionErrorCode(failure2.code, failure2.action), 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 && left.syncHealth === right.syncHealth && 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.episodeEndReason === right.episodeEndReason && left.removedByHost === right.removedByHost;
 }
 function sameEpisode(left, right) {
   if (left === right) return true;
@@ -3520,13 +3930,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));
   }
@@ -3604,7 +4014,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" }));
@@ -3619,7 +4029,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}` }));
@@ -3942,6 +4355,7 @@ function chatError(message) {
 // src/space-client/media-controller.ts
 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"];
+var MEDIA_READY_TIMEOUT_MS = 1e4;
 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 };
 }
@@ -3986,8 +4400,9 @@ var MediaControllerRuntime = class {
   #tracks = /* @__PURE__ */ new Map();
   #sources = { microphone: sourceWorker(true), camera: sourceWorker(true), screen: sourceWorker(false) };
   #syncLive = false;
-  #pendingSources = /* @__PURE__ */ new Set();
+  #pendingSources = /* @__PURE__ */ new Map();
   #pendingCaptures = /* @__PURE__ */ new Set();
+  #readinessChecks = /* @__PURE__ */ new Set();
   #requestGenerations = /* @__PURE__ */ new Map();
   #camera = { status: "idle" };
   #requests = Object.freeze([]);
@@ -4015,8 +4430,8 @@ var MediaControllerRuntime = class {
     if (intent.microphone !== void 0) this.#recordIntent("microphone", intent.microphone);
     if (intent.camera !== void 0) this.#recordIntent("camera", intent.camera);
   }
-  setMicrophoneEnabled = (enabled) => this.#mediaAction(enabled, this.#set("microphone", enabled));
-  setCameraEnabled = (enabled) => this.#mediaAction(enabled, this.#set("camera", enabled));
+  setMicrophoneEnabled = (enabled) => this.#set("microphone", enabled);
+  setCameraEnabled = (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(() => {
@@ -4110,6 +4525,7 @@ var MediaControllerRuntime = class {
     this.#fork(this.#refreshDevices().pipe(Effect5.ignore));
   }
   dispose() {
+    for (const check of this.#readinessChecks) check(normalizeMediaError(cancelledCaptureError()));
     this.#cancelCaptures();
     for (const unsubscribe of [this.#unsubscribeMedia, this.#unsubscribeRequests, this.#unsubscribePause, this.#unsubscribeSync]) unsubscribe?.();
     this.#unsubscribeConnection?.();
@@ -4134,8 +4550,37 @@ var MediaControllerRuntime = class {
   #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"))));
   }
+  #waitForLive(source, revision, ports) {
+    return Effect5.suspend(() => {
+      let cleanup = () => {
+      };
+      return Effect5.callback((resume) => {
+        const check = (failure2) => {
+          if (failure2) return resume(Effect5.fail(failure2));
+          if (this.#sources[source].desired.revision !== revision) return resume(Effect5.void);
+          if (ports && (this.#ports?.sync !== ports.sync || this.#ports.media !== ports.media)) return resume(Effect5.fail(normalizeMediaError(cancelledCaptureError())));
+          const state = this.#connection.getSnapshot().state;
+          if (state === "live" && this.#ports?.sync.getSnapshot().connection.phase === "live" && this.#store.getSnapshot().connection.status === "live") return resume(Effect5.void);
+          if (state !== "joining" && state !== "reconnecting" && state !== "live") resume(Effect5.fail(normalizeMediaError(new V1SyncError("Media enable requires a live call", "not_live"))));
+        };
+        this.#readinessChecks.add(check);
+        const unsubscribe = this.#connection.subscribe(() => check());
+        const unsubscribeStore = this.#store.subscribe(() => check());
+        const unsubscribePorts = this.#connection.subscribePorts(() => check());
+        const timer = this.#connection.scheduleUnsafe(() => check(new SpaceClientError({ code: "media.timeout", recoverable: true, message: "The call did not connect in time. Try again." })), MEDIA_READY_TIMEOUT_MS);
+        cleanup = () => {
+          this.#readinessChecks.delete(check);
+          unsubscribe();
+          unsubscribeStore();
+          unsubscribePorts();
+          this.#connection.cancelScheduleUnsafe(timer);
+        };
+        check();
+      }).pipe(Effect5.ensuring(Effect5.sync(() => cleanup())));
+    });
+  }
   #set(source, enabled) {
-    return this.#act(source, enabled);
+    return Effect5.suspend(() => this.#store.getSnapshot().connection.status === "joining" ? this.#act(source, enabled) : this.#mediaAction(enabled, this.#act(source, enabled)));
   }
   #startScreen(options) {
     return this.#act("screen", true, options);
@@ -4170,19 +4615,41 @@ var MediaControllerRuntime = class {
         void state.pause.catch(() => void 0);
       }
     }
+    for (const check of this.#readinessChecks) check();
     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;
+      const ready = enabled && source !== "screen" && this.#store.getSnapshot().connection.status !== "live" ? this.#waitForLive(source, desired.revision).pipe(
+        Effect5.tapError(
+          (cause) => Effect5.sync(() => {
+            if (this.#sources[source].desired.revision === desired.revision) {
+              const cancelled = this.#recordIntent(source, false);
+              this.#sources[source].result = { revision: cancelled.revision, status: "failed", cause, cleanup: false };
+            }
           })
         )
+      ) : Effect5.void;
+      return this.#pending(
+        source,
+        ready.pipe(
+          Effect5.andThen(
+            Effect5.suspend(() => {
+              if (this.#sources[source].desired.revision !== desired.revision) return Effect5.void;
+              return this.#serialize(source, this.#work(source)).pipe(
+                Effect5.andThen(
+                  Effect5.suspend(() => {
+                    const result = this.#sources[source].result;
+                    if (result.revision === desired.revision && result.status === "failed") return Effect5.fail(result.cause);
+                    if (enabled && (source === "screen" || this.#sources[source].desired.enabled) && this.#store.getSnapshot().connection.status !== "live") return this.#mediaAction(true, Effect5.void);
+                    return Effect5.void;
+                  })
+                )
+              );
+            })
+          )
+        )
       );
     }).pipe(Effect5.mapError(normalizeMediaError));
   }
@@ -4257,18 +4724,24 @@ var MediaControllerRuntime = class {
           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
-            })
+            (track) => Effect5.sync(() => {
+              captured = track;
+            }).pipe(
+              Effect5.andThen(this.#waitForLive(source, intent.revision, ports)),
+              Effect5.andThen(
+                Effect5.try({
+                  try: () => {
+                    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)));
@@ -4384,7 +4857,7 @@ var MediaControllerRuntime = class {
     return this.#serialize("microphone", this.#serialize("camera", publish));
   }
   #send(ports, source, intent, enabled) {
-    return this.#mediaAction(
+    const command = this.#mediaAction(
       enabled,
       foreign2(async () => {
         this.#assertCurrentIntent(source, intent.revision);
@@ -4392,9 +4865,12 @@ var MediaControllerRuntime = class {
         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");
-      })
+      }).pipe(
+        Effect5.andThen(enabled && source !== "screen" ? this.#waitForLive(source, intent.revision, ports) : Effect5.void),
+        Effect5.tap(() => Effect5.try({ try: () => this.#assertActivePorts(ports, source === "screen" ? "startScreenShare" : source === "camera" ? "setCameraEnabled" : "setMicrophoneEnabled"), catch: (cause) => cause }))
+      )
     );
+    return enabled && source !== "screen" ? this.#waitForLive(source, intent.revision, ports).pipe(Effect5.andThen(command)) : command;
   }
   #reconcileIntents() {
     const live = this.#connection.getSnapshot().state === "live" && this.#ports?.sync.getSnapshot().connection.phase === "live";
@@ -4419,18 +4895,21 @@ var MediaControllerRuntime = class {
     return pause;
   }
   #serialize(source, effect) {
-    return this.#gates.get(source).withPermit(
-      Effect5.sync(() => {
-        this.#pendingSources.add(source);
-        this.#publish();
-      }).pipe(
-        Effect5.andThen(effect),
-        Effect5.ensuring(
-          Effect5.sync(() => {
-            this.#pendingSources.delete(source);
-            this.#publish();
-          })
-        )
+    return this.#gates.get(source).withPermit(this.#pending(source, effect));
+  }
+  #pending(source, effect) {
+    return Effect5.sync(() => {
+      this.#pendingSources.set(source, (this.#pendingSources.get(source) ?? 0) + 1);
+      this.#publish();
+    }).pipe(
+      Effect5.andThen(effect),
+      Effect5.ensuring(
+        Effect5.sync(() => {
+          const remaining = this.#pendingSources.get(source) - 1;
+          if (remaining === 0) this.#pendingSources.delete(source);
+          else this.#pendingSources.set(source, remaining);
+          this.#publish();
+        })
       )
     );
   }
@@ -4873,9 +5352,9 @@ var MediaControllerRuntime = class {
     const snapshot = this.#ports?.media.getSnapshot();
     const state = this.#connection.getSnapshot().state;
     const local = Object.freeze({
-      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"))
+      microphone: localMedia("microphone", this.#localTracks(), snapshot, this.#sources.microphone.localEnabled, state, this.#pendingSources.has("microphone") && this.#sources.microphone.desired.enabled),
+      camera: localMedia("camera", this.#localTracks(), snapshot, this.#sources.camera.localEnabled, state, this.#pendingSources.has("camera") && this.#sources.camera.desired.enabled),
+      screen: localMedia("screen", this.#localTracks(), snapshot, false, state, this.#pendingSources.has("screen") && this.#sources.screen.desired.enabled)
     });
     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({
@@ -4929,8 +5408,8 @@ function initialTrackEntries(microphone, camera) {
 function localMedia(source, tracks, snapshot, intended, connectionState, pending) {
   const track = tracks.get(source) ?? null;
   const publication = snapshot?.localTracks.find((candidate) => candidate.source === source);
-  if (locallyMuted(intended, track, publication)) return Object.freeze({ source, state: "disabled", track });
   if (pending) return Object.freeze({ source, state: "requesting", track });
+  if (locallyMuted(intended, track, publication)) return Object.freeze({ source, state: "disabled", track });
   if (publication?.enabled) return Object.freeze({ source, state: "enabled", track });
   if (publication && connectionState === "live") return Object.freeze({ source, state: "disabled", track });
   return Object.freeze({ source, state: localMediaState(source, track, intended, connectionState), track });
@@ -5364,6 +5843,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);
@@ -5698,7 +6178,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* () {
@@ -5721,13 +6201,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);
@@ -5741,6 +6230,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
     });
@@ -5758,14 +6249,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;
@@ -5857,7 +6355,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 } : {} });
       }
     }
   });
@@ -5913,7 +6411,7 @@ var SpaceClientCore = class {
       this.#store.updateConnection(snapshot);
       const newlyEnded = snapshot.episodeEnded && !this.#episodeEnded;
       this.#episodeEnded = snapshot.episodeEnded ?? false;
-      if (newlyEnded) this.#emit("episodeEnded", { episode });
+      if (newlyEnded) this.#emit("episodeEnded", { episode, reason: snapshot.episodeEndReason });
     });
   }
   getSnapshot = () => this.#store.getSnapshot();
@@ -6118,13 +6616,14 @@ export {
   CHALK_CHAT_ATTACHMENT_MIME_TYPES,
   ChalkChatFileError,
   createChalkChatFileHttpTransport,
+  ChalkWhiteboardViewBounds,
   createChalkWhiteboardV1FileDownloadTransport,
+  ChalkWhiteboardViewVersions,
   encodeWhiteboardV1ClientFrame,
   decodeWhiteboardV1ServerFrame,
   InMemoryChalkWhiteboardV1PendingOperationStore,
   ChalkWhiteboardV1Client,
   createChalkWhiteboardV1Client,
-  ChalkWhiteboardViewBounds,
   makeProductionConnectionPlatformLayer,
   ConnectionLifecycleService,
   makeConnectionLifecycleLayer,