@q9labsai/chalk-whiteboard 4.1.15 → 4.1.17

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Q9Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM,
+OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/{chunk-GCF4VS3K.js → chunk-6Q65ADBK.js}

@@ -1,5 +1,20 @@
 // src/collab/engine.ts
-import { CaptureUpdateAction as CaptureUpdateAction2, hashElementsVersion, reconcileElements, restoreElements } from "@excalidraw/excalidraw";
+import { CaptureUpdateAction as CaptureUpdateAction2, reconcileElements, restoreElements } from "@excalidraw/excalidraw";
+
+// src/collab/camera.ts
+function getWhiteboardCamera(appState) {
+  return {
+    scrollX: appState.scrollX,
+    scrollY: appState.scrollY,
+    zoom: appState.zoom
+  };
+}
+function withLocalWhiteboardCamera(sharedAppState, localAppState) {
+  return {
+    viewBackgroundColor: sharedAppState?.viewBackgroundColor ?? localAppState.viewBackgroundColor,
+    ...getWhiteboardCamera(localAppState)
+  };
+}
 
 // src/collab/files.ts
 import { CaptureUpdateAction, MIME_TYPES, newElementWith } from "@excalidraw/excalidraw";
@@ -233,6 +248,15 @@ function requireOption(value, name) {
   return value;
 }
 
+// src/collab/order.ts
+function compareCodeUnits(left, right) {
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+function compareElementOrder(left, right) {
+  return compareCodeUnits(left.index ?? "", right.index ?? "") || compareCodeUnits(left.id, right.id);
+}
+
 // src/collab/presence.ts
 var CURSOR_COLORS = [
   { stroke: "#FF5D5D", background: "rgba(255, 93, 93, 0.2)" },
@@ -315,6 +339,8 @@ var filterSyncableElements = (elements) => elements.filter((el) => {
 });
 
 // src/collab/wire.ts
+var ELEMENT_ENCODED_BYTES_LIMIT = 16384 - 64;
+var encoder = new TextEncoder();
 var wireElementKeys = ["id", "type", "version", "version_nonce", "index", "is_deleted", "payload"];
 var wireElementValidators = [
   (value) => isNonEmptyString(value.id),
@@ -336,6 +362,47 @@ function toWireElement(element) {
     payload: toJsonRecord(element)
   };
 }
+function toFittedWireElement(element) {
+  const wire = toWireElement(element);
+  if (fits(wire)) return wire;
+  const payload = fitPoints(element, wire);
+  if (!payload) throw new Error("Whiteboard element exceeds the whiteboard-v1 element size");
+  return { ...wire, payload };
+}
+function fitPoints(element, wire) {
+  if (!("points" in element) || isElbowArrow(element)) return void 0;
+  const points = element.points.map((point) => point.map(roundCoordinate));
+  const pressures = element.type === "freedraw" ? element.pressures.map(roundCoordinate) : void 0;
+  const sample = (stride) => ({ ...wire.payload, points: sampleValues(points, stride), ...pressures ? { pressures: sampleValues(pressures, stride) } : {} });
+  const lastStride = Math.max(1, points.length - 1);
+  if (!fits({ ...wire, payload: sample(lastStride) })) return void 0;
+  for (let stride = 1; stride < lastStride; stride++) {
+    const reduced = sample(stride);
+    if (fits({ ...wire, payload: reduced })) return reduced;
+  }
+  return sample(lastStride);
+}
+function isElbowArrow(element) {
+  return element.type === "arrow" && "elbowed" in element && element.elbowed;
+}
+var exponentWithoutFraction = /(^|[^\d.])\d[eE][+-]?\d/g;
+function fits(element) {
+  const json = JSON.stringify(element);
+  return encoder.encode(json).byteLength + 2 * (json.match(exponentWithoutFraction)?.length ?? 0) <= ELEMENT_ENCODED_BYTES_LIMIT;
+}
+function roundCoordinate(value) {
+  return Number(value.toFixed(2));
+}
+function sampleValues(values, stride) {
+  const sampled = [];
+  for (let index = 0; index < values.length - 1; index += stride) {
+    const value = values[index];
+    if (value !== void 0) sampled.push(value);
+  }
+  const last = values.at(-1);
+  if (last !== void 0) sampled.push(last);
+  return sampled;
+}
 function fromWireElement(element) {
   if (!isWireElement(element)) {
     throw new Error("invalid whiteboard-v1 element");
@@ -404,12 +471,16 @@ function hasExactKeys(value, keys) {
 }
 
 // src/collab/engine.ts
-var FULL_SYNC_INTERVAL_MS = 2e4;
+var SUBMISSION_RETRY_DELAY_MS = 1e3;
+var MAX_SUBMISSION_RETRY_DELAY_MS = 16e3;
 var CHANGE_DEBOUNCE_MS = 150;
+var CHANGE_MAX_WAIT_MS = 1e3;
 var CURSOR_THROTTLE_MS = 16;
 var CURSOR_STALE_MS = 1e4;
 var asArray = (value) => Array.isArray(value) ? value : [];
 var toReconcileRemoteElements = (elements) => elements;
+var isNewerVersion = (element, previous) => element.version > previous.version || element.version === previous.version && element.versionNonce < previous.versionNonce;
+var editingElementIds = (appState) => [appState.newElement?.id, appState.resizingElement?.id, appState.editingTextElement?.id];
 var ExcalidrawCollabEngine = class {
   constructor(opts) {
     this.opts = opts;
@@ -437,13 +508,16 @@ var ExcalidrawCollabEngine = class {
   sceneId = null;
   sceneGeneration = null;
   canDraw = true;
-  lastBroadcastedOrReceivedElementsHash = 0;
   broadcastedElementVersions = /* @__PURE__ */ new Map();
+  rejectedElementVersions = /* @__PURE__ */ new Map();
+  deferredRemoteElements = /* @__PURE__ */ new Map();
   submissionInFlight = false;
   dirtyDuringSubmission = false;
   disposed = false;
   changeDebounce = null;
-  fullSyncTimer = null;
+  changeDebounceDeadline = null;
+  submissionRetryTimer = null;
+  submissionRetries = 0;
   filesSync;
   presence;
   unsubPointerUp;
@@ -457,7 +531,9 @@ var ExcalidrawCollabEngine = class {
     this.sceneId = commit.sceneId;
     this.sceneGeneration = commit.sceneGeneration ?? null;
     this.broadcastedElementVersions.clear();
-    this.lastBroadcastedOrReceivedElementsHash = 0;
+    this.rejectedElementVersions.clear();
+    this.deferredRemoteElements.clear();
+    this.resetSubmissionRetries();
     this.opts.excalidrawAPI.updateScene({
       elements: [],
       captureUpdate: CaptureUpdateAction2.NEVER
@@ -466,14 +542,14 @@ var ExcalidrawCollabEngine = class {
   }
   dispose() {
     if (this.disposed) return;
-    const hasPendingChange = this.changeDebounce !== null || this.dirtyDuringSubmission;
+    const hasPendingChange = this.changeDebounce !== null || this.dirtyDuringSubmission || this.submissionRetryTimer !== null;
     this.disposed = true;
-    if (this.changeDebounce) clearTimeout(this.changeDebounce);
-    this.changeDebounce = null;
+    this.clearChangeDebounce();
     if (hasPendingChange) this.flushOnDispose();
-    if (this.fullSyncTimer) clearTimeout(this.fullSyncTimer);
-    this.fullSyncTimer = null;
+    if (this.submissionRetryTimer) clearTimeout(this.submissionRetryTimer);
+    this.submissionRetryTimer = null;
     this.dirtyDuringSubmission = false;
+    this.deferredRemoteElements.clear();
     this.filesSync.dispose();
     this.presence.dispose();
     this.unsubscribe();
@@ -481,14 +557,22 @@ var ExcalidrawCollabEngine = class {
   }
   handleChange(_elements, _appState, files) {
     if (this.disposed) return;
+    this.applyDeferredRemoteElements();
     const elementsAll = this.opts.excalidrawAPI.getSceneElementsIncludingDeleted();
     this.filesSync.handleLocalScene(elementsAll, files);
     if (!this.canDraw) return;
-    if (this.changeDebounce) clearTimeout(this.changeDebounce);
-    this.changeDebounce = setTimeout(() => {
-      this.changeDebounce = null;
-      this.flushNow();
-    }, CHANGE_DEBOUNCE_MS);
+    const now = Date.now();
+    const deadline = this.changeDebounceDeadline ?? now + CHANGE_MAX_WAIT_MS;
+    const wait = Math.min(CHANGE_DEBOUNCE_MS, deadline - now);
+    this.clearChangeDebounce();
+    this.changeDebounceDeadline = deadline;
+    this.changeDebounce = setTimeout(
+      () => {
+        this.clearChangeDebounce();
+        this.flushNow(wait < CHANGE_DEBOUNCE_MS);
+      },
+      Math.max(0, wait)
+    );
   }
   handlePointerUpdate(payload) {
     this.presence.handlePointerUpdate(payload);
@@ -546,49 +630,66 @@ var ExcalidrawCollabEngine = class {
       isSnapshot: true
     });
   }
-  flushNow() {
-    if (this.disposed) return;
+  flushNow(skipEditing = false) {
+    if (this.disposed || this.submissionRetryTimer !== null) return;
     const context = this.submissionContext();
     if (!context) return;
-    const elementsHash = hashElementsVersion(context.elements);
-    if (elementsHash === this.lastBroadcastedOrReceivedElementsHash) return;
+    const editing = skipEditing ? editingElementIds(this.opts.excalidrawAPI.getAppState()) : [];
     const syncableAll = filterSyncableElements(context.elements);
     const delta = [];
     for (const el of syncableAll) {
-      const prev = this.broadcastedElementVersions.get(el.id) ?? 0;
-      if (!prev || el.version > prev) delta.push(el);
+      if (this.isUnsubmitted(el) && !editing.includes(el.id)) delta.push(el);
     }
     if (delta.length === 0) return;
-    this.submit(context.sceneId, context.sceneGeneration ?? null, false, delta, elementsHash);
+    this.submit(context.sceneId, context.sceneGeneration ?? null, delta);
   }
   flushOnDispose() {
     const context = this.submissionContext({ allowDisposed: true, allowInFlight: true });
     if (!context) return;
-    const elementsHash = hashElementsVersion(context.elements);
-    if (elementsHash === this.lastBroadcastedOrReceivedElementsHash) return;
     const syncableAll = filterSyncableElements(context.elements);
     const delta = [];
     for (const element of syncableAll) {
-      const previousVersion = this.broadcastedElementVersions.get(element.id) ?? 0;
-      if (!previousVersion || element.version > previousVersion) delta.push(element);
+      if (this.isUnsubmitted(element)) delta.push(element);
     }
     if (delta.length === 0) return;
     this.submitFinalUpdate(context.sceneId, context.sceneGeneration ?? null, delta);
   }
-  scheduleFullSync() {
-    if (this.disposed || this.fullSyncTimer) return;
-    this.fullSyncTimer = setTimeout(() => {
-      this.fullSyncTimer = null;
-      if (this.disposed) return;
-      this.sendFullSync();
-    }, FULL_SYNC_INTERVAL_MS);
+  isUnsubmitted(element) {
+    const rejected = this.rejectedElementVersions.get(element.id);
+    if (rejected?.version === element.version && rejected.versionNonce === element.versionNonce) return false;
+    const previous = this.broadcastedElementVersions.get(element.id);
+    return !previous || isNewerVersion(element, previous);
+  }
+  applyDeferredRemoteElements() {
+    if (!this.sceneId || this.deferredRemoteElements.size === 0) return;
+    const editing = editingElementIds(this.opts.excalidrawAPI.getAppState());
+    const elements = [];
+    for (const [id, element] of this.deferredRemoteElements) {
+      if (editing.includes(id)) continue;
+      this.deferredRemoteElements.delete(id);
+      elements.push(element);
+    }
+    if (elements.length === 0) return;
+    this.applyRemoteElements({ sceneId: this.sceneId, ...this.sceneGeneration ? { sceneGeneration: this.sceneGeneration } : {}, syncAll: false, remoteElements: elements, isSnapshot: false });
   }
-  sendFullSync() {
-    if (this.disposed) return;
-    const context = this.submissionContext();
-    if (!context) return;
-    const syncableAll = filterSyncableElements(context.elements);
-    this.submit(context.sceneId, context.sceneGeneration ?? null, true, syncableAll, hashElementsVersion(context.elements));
+  clearChangeDebounce() {
+    if (this.changeDebounce !== null) clearTimeout(this.changeDebounce);
+    this.changeDebounce = null;
+    this.changeDebounceDeadline = null;
+  }
+  resetSubmissionRetries() {
+    if (this.submissionRetryTimer !== null) clearTimeout(this.submissionRetryTimer);
+    this.submissionRetryTimer = null;
+    this.submissionRetries = 0;
+  }
+  scheduleSubmissionRetry() {
+    if (this.disposed || this.submissionRetryTimer !== null) return;
+    const delay = Math.min(SUBMISSION_RETRY_DELAY_MS * 2 ** this.submissionRetries, MAX_SUBMISSION_RETRY_DELAY_MS);
+    this.submissionRetries += 1;
+    this.submissionRetryTimer = setTimeout(() => {
+      this.submissionRetryTimer = null;
+      this.flushNow();
+    }, delay);
   }
   submissionContext(options = {}) {
     if (this.disposed && !options.allowDisposed) return null;
@@ -607,41 +708,54 @@ var ExcalidrawCollabEngine = class {
       elements: this.opts.excalidrawAPI.getSceneElementsIncludingDeleted()
     };
   }
-  submit(sceneId, sceneGeneration, syncAll, elements, elementsHash) {
+  submit(sceneId, sceneGeneration, elements) {
+    const submittedElements = this.toSubmissionElements(elements);
+    if (submittedElements.length === 0) return;
     this.submissionInFlight = true;
     this.dirtyDuringSubmission = false;
-    void this.opts.submitUpdate({
-      sceneId,
-      ...sceneGeneration ? { sceneGeneration } : {},
-      syncAll,
-      elements: elements.map(toWireElement)
-    }).then((commit) => {
+    let acknowledged = false;
+    void Promise.resolve().then(
+      () => this.opts.submitUpdate({
+        sceneId,
+        ...sceneGeneration ? { sceneGeneration } : {},
+        syncAll: false,
+        elements: submittedElements
+      })
+    ).then((commit) => {
       if (this.disposed) return;
       if (commit.sceneId !== sceneId || this.sceneId !== sceneId || this.sceneGeneration !== sceneGeneration) {
         this.requestSnapshot();
         return;
       }
-      for (const element of elements) {
-        this.broadcastedElementVersions.set(element.id, element.version);
+      for (const element of submittedElements) {
+        const previous = this.broadcastedElementVersions.get(element.id);
+        const submittedVersion = { version: element.version, versionNonce: element.version_nonce };
+        if (!previous || isNewerVersion(submittedVersion, previous)) this.broadcastedElementVersions.set(element.id, submittedVersion);
       }
-      this.lastBroadcastedOrReceivedElementsHash = elementsHash;
-      this.scheduleFullSync();
-    }).catch(this.opts.onSubmissionError).finally(() => {
+      this.submissionRetries = 0;
+      acknowledged = true;
+    }).catch((cause) => {
+      if (this.sceneId === sceneId && this.sceneGeneration === sceneGeneration) this.scheduleSubmissionRetry();
+      this.opts.onSubmissionError?.(cause);
+    }).finally(() => {
       if (this.disposed) return;
       this.submissionInFlight = false;
       const shouldFlush = this.dirtyDuringSubmission;
       this.dirtyDuringSubmission = false;
-      if (!this.disposed && shouldFlush) this.flushNow();
+      if (shouldFlush) this.flushNow();
+      else if (acknowledged && this.changeDebounce === null) this.flushNow(true);
     });
   }
   submitFinalUpdate(sceneId, sceneGeneration, elements) {
+    const submittedElements = this.toSubmissionElements(elements);
+    if (submittedElements.length === 0) return;
     let submission;
     try {
       submission = this.opts.submitUpdate({
         sceneId,
         ...sceneGeneration ? { sceneGeneration } : {},
         syncAll: false,
-        elements: elements.map(toWireElement)
+        elements: submittedElements
       });
     } catch (cause) {
       this.opts.onSubmissionError?.(cause);
@@ -649,44 +763,79 @@ var ExcalidrawCollabEngine = class {
     }
     void submission.catch((cause) => this.opts.onSubmissionError?.(cause));
   }
+  toSubmissionElements(elements) {
+    const submitted = [];
+    for (const element of elements) {
+      try {
+        submitted.push(toFittedWireElement(element));
+        this.rejectedElementVersions.delete(element.id);
+      } catch (cause) {
+        const reported = this.rejectedElementVersions.has(element.id);
+        this.rejectedElementVersions.set(element.id, { version: element.version, versionNonce: element.versionNonce });
+        if (!reported) this.opts.onSubmissionError?.(new Error("One whiteboard item could not be shared. If it is very large, make it smaller or split it.", { cause }));
+      }
+    }
+    return submitted;
+  }
   applyRemoteElements(args) {
     const remoteSceneId = args.sceneId;
+    const replacingScene = this.sceneId !== null && remoteSceneId !== this.sceneId;
     if (!this.sceneId) {
       this.sceneId = remoteSceneId;
     } else if (args.isSnapshot) {
       if (remoteSceneId !== this.sceneId) {
         this.sceneId = remoteSceneId;
         this.broadcastedElementVersions.clear();
-        this.lastBroadcastedOrReceivedElementsHash = 0;
       }
     } else if (remoteSceneId !== this.sceneId) {
       if (args.syncAll && asArray(args.remoteElements).length === 0) {
         this.sceneId = remoteSceneId;
         this.broadcastedElementVersions.clear();
-        this.lastBroadcastedOrReceivedElementsHash = 0;
       } else {
         this.requestSnapshot();
         return;
       }
     }
+    if (replacingScene) {
+      this.rejectedElementVersions.clear();
+      this.clearChangeDebounce();
+      this.dirtyDuringSubmission = false;
+      this.sceneGeneration = null;
+      this.deferredRemoteElements.clear();
+      this.resetSubmissionRetries();
+    }
     if (args.sceneGeneration) this.sceneGeneration = args.sceneGeneration;
     const excalidrawAPI = this.opts.excalidrawAPI;
-    const local = excalidrawAPI.getSceneElementsIncludingDeleted();
-    const remoteElements = args.remoteElements;
-    const restoredRemote = restoreElements(remoteElements, local);
+    if (replacingScene) excalidrawAPI.history.clear();
+    const local = replacingScene ? [] : excalidrawAPI.getSceneElementsIncludingDeleted();
+    const remoteElements = [...args.remoteElements].sort(compareElementOrder);
+    const restoredRemote = restoreElements(remoteElements, null);
     const remoteForReconcile = toReconcileRemoteElements(restoredRemote);
-    const reconciled = reconcileElements(local, remoteForReconcile, excalidrawAPI.getAppState());
-    this.lastBroadcastedOrReceivedElementsHash = hashElementsVersion(reconciled);
-    this.broadcastedElementVersions.clear();
-    for (const el of reconciled) {
-      this.broadcastedElementVersions.set(el.id, el.version);
+    const appState = excalidrawAPI.getAppState();
+    const editing = editingElementIds(appState);
+    const reconciled = reconcileElements(local, remoteForReconcile, appState);
+    if (args.isSnapshot) {
+      this.broadcastedElementVersions.clear();
+      this.resetSubmissionRetries();
+    }
+    const remoteById = new Map(restoredRemote.map((element) => [element.id, element]));
+    for (const element of reconciled) {
+      const remote = remoteById.get(element.id);
+      if (remote?.version === element.version && remote.versionNonce === element.versionNonce) {
+        this.broadcastedElementVersions.set(element.id, { version: element.version, versionNonce: element.versionNonce });
+      } else if (remote && editing.includes(element.id) && isNewerVersion(remote, element)) {
+        const previous = this.deferredRemoteElements.get(element.id);
+        if (!previous || isNewerVersion(remote, previous)) this.deferredRemoteElements.set(element.id, remote);
+      }
     }
+    const hasUnsubmittedElements = reconciled.some((element) => this.isUnsubmitted(element));
     excalidrawAPI.updateScene({
       elements: reconciled,
-      appState: args.appState,
+      appState: withLocalWhiteboardCamera(args.appState, excalidrawAPI.getAppState()),
       captureUpdate: CaptureUpdateAction2.NEVER
     });
     this.filesSync.handleRemoteScene(reconciled);
+    if (args.isSnapshot && hasUnsubmittedElements) queueMicrotask(() => this.flushNow());
   }
   requestSnapshot() {
     if (this.disposed) return;
@@ -698,6 +847,7 @@ var ExcalidrawCollabEngine = class {
 };
 
 export {
+  compareElementOrder,
   toWireElement,
   fromWireElement,
   isWireElement,

package/dist/{chunk-4XG2ABSP.js → chunk-EPSMA2DY.js}

@@ -1,3 +1,7 @@
+import {
+  compareElementOrder
+} from "./chunk-6Q65ADBK.js";
+
 // src/collab/reducer.ts
 function mergeWhiteboardElements(current, incoming) {
   const merged = new Map(current.map((element) => [element.id, element]));
@@ -13,10 +17,6 @@ function wins(candidate, existing) {
   if (candidate.version !== existing.version) return candidate.version > existing.version;
   return candidate.version_nonce < existing.version_nonce;
 }
-function compareElementOrder(left, right) {
-  const byIndex = left.index.localeCompare(right.index);
-  return byIndex === 0 ? left.id.localeCompare(right.id) : byIndex;
-}
 
 export {
   mergeWhiteboardElements

package/dist/collab/camera.d.ts

@@ -0,0 +1,8 @@
+import type { AppState } from "./types.js";
+export type WhiteboardCamera = Pick<AppState, "scrollX" | "scrollY" | "zoom">;
+export type SharedWhiteboardAppState = {
+    readonly viewBackgroundColor?: string;
+};
+export type WhiteboardViewportAppState = Pick<AppState, "scrollX" | "scrollY" | "zoom" | "viewBackgroundColor">;
+export declare function getWhiteboardCamera(appState: WhiteboardCamera): WhiteboardCamera;
+export declare function withLocalWhiteboardCamera(sharedAppState: SharedWhiteboardAppState | undefined, localAppState: WhiteboardViewportAppState): WhiteboardViewportAppState;

package/dist/collab/engine.d.ts

@@ -1,3 +1,4 @@
+import { type SharedWhiteboardAppState } from "./camera.js";
 import type { WhiteboardFileSyncState, WhiteboardFileTransferOptions } from "./files.js";
 import type { AppState, BinaryFiles, ExcalidrawImperativeAPI, OrderedExcalidrawElement } from "./types.js";
 import { type WhiteboardCommit, type WhiteboardWireElement } from "./wire.js";
@@ -7,9 +8,7 @@ export type WhiteboardCollaborationEvent = {
     readonly revision: string;
     readonly sceneGeneration?: string;
     readonly elements: readonly WhiteboardWireElement[];
-    readonly appState?: {
-        readonly viewBackgroundColor?: string;
-    };
+    readonly appState?: SharedWhiteboardAppState;
 } | {
     readonly type: "update";
     readonly sceneId: string;
@@ -52,13 +51,16 @@ export declare class ExcalidrawCollabEngine {
     private sceneId;
     private sceneGeneration;
     private canDraw;
-    private lastBroadcastedOrReceivedElementsHash;
     private broadcastedElementVersions;
+    private rejectedElementVersions;
+    private deferredRemoteElements;
     private submissionInFlight;
     private dirtyDuringSubmission;
     private disposed;
     private changeDebounce;
-    private fullSyncTimer;
+    private changeDebounceDeadline;
+    private submissionRetryTimer;
+    private submissionRetries;
     private readonly filesSync;
     private readonly presence;
     private readonly unsubPointerUp;
@@ -92,15 +94,19 @@ export declare class ExcalidrawCollabEngine {
         sceneId: string;
         sceneGeneration?: string;
         elements: readonly WhiteboardWireElement[];
-        appState?: AppState;
+        appState?: SharedWhiteboardAppState;
     }): void;
     private flushNow;
     private flushOnDispose;
-    private scheduleFullSync;
-    private sendFullSync;
+    private isUnsubmitted;
+    private applyDeferredRemoteElements;
+    private clearChangeDebounce;
+    private resetSubmissionRetries;
+    private scheduleSubmissionRetry;
     private submissionContext;
     private submit;
     private submitFinalUpdate;
+    private toSubmissionElements;
     private applyRemoteElements;
     private requestSnapshot;
 }

package/dist/collab/index.js

@@ -1,12 +1,12 @@
 import {
   mergeWhiteboardElements
-} from "../chunk-4XG2ABSP.js";
+} from "../chunk-EPSMA2DY.js";
 import {
   ExcalidrawCollabEngine,
   fromWireElement,
   isWireElement,
   toWireElement
-} from "../chunk-GCF4VS3K.js";
+} from "../chunk-6Q65ADBK.js";
 export {
   ExcalidrawCollabEngine,
   fromWireElement,

package/dist/collab/order.d.ts

@@ -0,0 +1,6 @@
+type OrderedElement = {
+    readonly index: string | null;
+    readonly id: string;
+};
+export declare function compareElementOrder(left: OrderedElement, right: OrderedElement): number;
+export {};

package/dist/collab/wire.d.ts

@@ -1,4 +1,5 @@
 import type { OrderedExcalidrawElement } from "./types.js";
+export declare const ELEMENT_ENCODED_BYTES_LIMIT: number;
 export type WhiteboardJsonValue = null | boolean | number | string | readonly WhiteboardJsonValue[] | {
     readonly [key: string]: WhiteboardJsonValue;
 };
@@ -25,5 +26,10 @@ export interface WhiteboardUploadInstructions {
     readonly expiresAt: string;
 }
 export declare function toWireElement(element: OrderedExcalidrawElement): WhiteboardWireElement;
+/**
+ * The element as the engine submits it. It equals `toWireElement` while the element fits the size that Sync stores.
+ * A larger element gets its points rounded and, when that is not enough, thinned. Throws when no copy fits.
+ */
+export declare function toFittedWireElement(element: OrderedExcalidrawElement): WhiteboardWireElement;
 export declare function fromWireElement(element: WhiteboardWireElement): OrderedExcalidrawElement;
 export declare function isWireElement(value: unknown): value is WhiteboardWireElement;

package/dist/embedded/chalk-whiteboard/asset-manifest.json

@@ -1216,8 +1216,8 @@
     },
     {
       "path": "renderer.js",
-      "bytes": 8499347,
-      "sha256": "8fb16da140966885912fd55616156b73e24dafc94e7dd0996e169d202714281a"
+      "bytes": 8504846,
+      "sha256": "20644a73c951091c36858684c83bd579c6894f986bf461cf21289f0ccef4ea59"
     },
     {
       "path": "THIRD_PARTY_NOTICES.json",