@pixerate/editor 0.278.0 → 0.279.1

package/dist/{chunk-DWPFGWW5.js → chunk-FKO3CY2C.js}

@@ -18,7 +18,7 @@ import {
   unionBounds,
   vectorGradientPoints,
   widthProfileAt
-} from "./chunk-HHX7ST6Z.js";
+} from "./chunk-YOM76H2V.js";
 import {
   segmentLength,
   segmentParamAtLength,

package/dist/{chunk-N4MCWQZ7.js → chunk-HN57I7KT.js}

@@ -5,7 +5,7 @@ import {
   moveAnchorHandle,
   subpathSegment,
   subpathSegmentCount
-} from "./chunk-HHX7ST6Z.js";
+} from "./chunk-YOM76H2V.js";
 import {
   segmentPoint
 } from "./chunk-WEIK3UYB.js";

package/dist/{chunk-4NZTK7LM.cjs → chunk-K4ANWBF7.cjs}

@@ -18,7 +18,7 @@
 
 
 
-var _chunkPEQWARCPcjs = require('./chunk-PEQWARCP.cjs');
+var _chunkWZYRYYXNcjs = require('./chunk-WZYRYYXN.cjs');
 
 
 
@@ -37,7 +37,7 @@ var lerpP = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
 var toP = (v) => [v.x, v.y];
 var mapP = (m, p) => [m[0] * p[0] + m[2] * p[1] + m[4], m[1] * p[0] + m[3] * p[1] + m[5]];
 var curvesOf = (c) => Math.max(0, (c.pts.length - 1) / 3) | 0;
-function subpathToMorphContour(sp, m = _chunkPEQWARCPcjs.IDENTITY_MATRIX) {
+function subpathToMorphContour(sp, m = _chunkWZYRYYXNcjs.IDENTITY_MATRIX) {
   const n = sp.anchors.length;
   if (!n) return null;
   const first = mapP(m, toP(sp.anchors[0]));
@@ -67,8 +67,8 @@ function isStraight(p0, p1, p2, p3) {
   const u2 = along(p2);
   return off(p1) < tol && off(p2) < tol && u1 >= -1e-9 && u1 <= 1 + 1e-9 && u2 >= -1e-9 && u2 <= 1 + 1e-9;
 }
-function morphContourToSubpath(c, m = _chunkPEQWARCPcjs.IDENTITY_MATRIX, closed = c.closed) {
-  const pts = _chunkPEQWARCPcjs.isIdentityMatrix.call(void 0, m) ? c.pts : c.pts.map((p) => mapP(m, p));
+function morphContourToSubpath(c, m = _chunkWZYRYYXNcjs.IDENTITY_MATRIX, closed = c.closed) {
+  const pts = _chunkWZYRYYXNcjs.isIdentityMatrix.call(void 0, m) ? c.pts : c.pts.map((p) => mapP(m, p));
   const curves = curvesOf(c);
   const dropLast = closed && c.closed && curves > 0;
   const count = dropLast ? curves : curves + 1;
@@ -84,7 +84,7 @@ function morphContourToSubpath(c, m = _chunkPEQWARCPcjs.IDENTITY_MATRIX, closed
     anchors[(k + 1) % count].in = { x: p2[0], y: p2[1] };
   }
   for (const a of anchors) {
-    const type = _chunkPEQWARCPcjs.inferAnchorType.call(void 0, a);
+    const type = _chunkWZYRYYXNcjs.inferAnchorType.call(void 0, a);
     if (type !== "corner") a.type = type;
   }
   const isClosed = closed && curves > 0;
@@ -267,7 +267,7 @@ function bestStart(fixed, free, useShapeContext) {
   return best;
 }
 function placeIn(c, from, to) {
-  const b = _chunkPEQWARCPcjs.unionBounds.call(void 0, [boundsOfPoints(c.pts)]);
+  const b = _chunkWZYRYYXNcjs.unionBounds.call(void 0, [boundsOfPoints(c.pts)]);
   const p = b ? [b.x + b.width / 2, b.y + b.height / 2] : c.pts[0];
   if (!from || !to) return p;
   const fx = from.width > 0 ? (p[0] - from.x) / from.width : 0.5;
@@ -456,7 +456,7 @@ function interpolateVectorColor(a, b, t) {
 }
 function resampleGradientStops(g, offsets) {
   return offsets.map((offset) => {
-    const s = _chunkPEQWARCPcjs.sampleVectorGradient.call(void 0, g, offset);
+    const s = _chunkWZYRYYXNcjs.sampleVectorGradient.call(void 0, g, offset);
     return s.opacity < 1 ? { offset, color: s.color, opacity: Math.round(s.opacity * 1e4) / 1e4 } : { offset, color: s.color };
   });
 }
@@ -467,11 +467,11 @@ function lerpAngle(a, b, t) {
 var lerpPoint = (a, b, t) => ({ x: lerpN(a.x, b.x, t), y: lerpN(a.y, b.y, t) });
 var sameColourModel = (a, b) => (_nullishCoalesce(a.interpolation, () => ( "srgb"))) === (_nullishCoalesce(b.interpolation, () => ( "srgb"))) && (_nullishCoalesce(a.smoothness, () => ( 0))) === (_nullishCoalesce(b.smoothness, () => ( 0)));
 function lerpStops(a, b, t) {
-  let stopsA = _chunkPEQWARCPcjs.sortedVectorGradientStops.call(void 0, a);
-  let stopsB = _chunkPEQWARCPcjs.sortedVectorGradientStops.call(void 0, b);
+  let stopsA = _chunkWZYRYYXNcjs.sortedVectorGradientStops.call(void 0, a);
+  let stopsB = _chunkWZYRYYXNcjs.sortedVectorGradientStops.call(void 0, b);
   const resampled = stopsA.length !== stopsB.length || !sameColourModel(a, b);
   if (resampled) {
-    const offs = [..._chunkPEQWARCPcjs.expandVectorGradientStops.call(void 0, a), ..._chunkPEQWARCPcjs.expandVectorGradientStops.call(void 0, b), ...stopsA, ...stopsB].map((s) => s.offset).filter(Number.isFinite).sort((x, y) => x - y);
+    const offs = [..._chunkWZYRYYXNcjs.expandVectorGradientStops.call(void 0, a), ..._chunkWZYRYYXNcjs.expandVectorGradientStops.call(void 0, b), ...stopsA, ...stopsB].map((s) => s.offset).filter(Number.isFinite).sort((x, y) => x - y);
     const common = offs.filter((o, i) => i === 0 || o - offs[i - 1] > 1e-4);
     stopsA = resampleGradientStops(a, common);
     stopsB = resampleGradientStops(b, common);
@@ -498,8 +498,8 @@ function lerpGradient(a, b, t) {
   }
   if (near.spread && near.spread !== "pad") out.spread = near.spread;
   if (near.strokeMode && near.strokeMode !== "within") out.strokeMode = near.strokeMode;
-  const ea = _chunkPEQWARCPcjs.hasExplicitGradientGeometry.call(void 0, a);
-  const eb = _chunkPEQWARCPcjs.hasExplicitGradientGeometry.call(void 0, b);
+  const ea = _chunkWZYRYYXNcjs.hasExplicitGradientGeometry.call(void 0, a);
+  const eb = _chunkWZYRYYXNcjs.hasExplicitGradientGeometry.call(void 0, b);
   if (!ea && !eb) {
     if (a.angle !== void 0 || b.angle !== void 0 || a.type === "linear" || a.type === "reflected") {
       const fallback = a.type === "linear" || a.type === "reflected" ? 180 : 90;
@@ -512,10 +512,10 @@ function lerpGradient(a, b, t) {
     }
     return out;
   }
-  const pa = _chunkPEQWARCPcjs.vectorGradientPoints.call(void 0, a);
-  const pb = _chunkPEQWARCPcjs.vectorGradientPoints.call(void 0, b);
+  const pa = _chunkWZYRYYXNcjs.vectorGradientPoints.call(void 0, a);
+  const pb = _chunkWZYRYYXNcjs.vectorGradientPoints.call(void 0, b);
   if (pa.units !== pb.units) {
-    const src = _chunkPEQWARCPcjs.explicitVectorGradient.call(void 0, near);
+    const src = _chunkWZYRYYXNcjs.explicitVectorGradient.call(void 0, near);
     return { ...src, stops: out.stops, ...out.interpolation ? { interpolation: out.interpolation } : {}, ...out.smoothness ? { smoothness: out.smoothness } : {} };
   }
   out.start = lerpPoint(pa.start, pb.start, t);
@@ -535,14 +535,14 @@ function solidLike(color, like) {
 function interpolateVectorPaint(a, b, t) {
   if (t <= 0) return a;
   if (t >= 1) return b;
-  const pa = _chunkPEQWARCPcjs.hasPaint.call(void 0, a);
-  const pb = _chunkPEQWARCPcjs.hasPaint.call(void 0, b);
+  const pa = _chunkWZYRYYXNcjs.hasPaint.call(void 0, a);
+  const pb = _chunkWZYRYYXNcjs.hasPaint.call(void 0, b);
   if (!pa && !pb) return t < 0.5 ? a : b;
   if (typeof a === "string" && pa && typeof b === "string" && pb) return interpolateVectorColor(a, b, t);
   if (!pa && typeof b === "string") return interpolateVectorColor("transparent", b, t);
   if (!pb && typeof a === "string") return interpolateVectorColor(a, "transparent", t);
-  const ga = pa && _chunkPEQWARCPcjs.isVectorGradient.call(void 0, a) ? a : null;
-  const gb = pb && _chunkPEQWARCPcjs.isVectorGradient.call(void 0, b) ? b : null;
+  const ga = pa && _chunkWZYRYYXNcjs.isVectorGradient.call(void 0, a) ? a : null;
+  const gb = pb && _chunkWZYRYYXNcjs.isVectorGradient.call(void 0, b) ? b : null;
   if (ga && gb) return _nullishCoalesce(lerpGradient(ga, gb, t), () => ( (t < 0.5 ? a : b)));
   if (gb) return _nullishCoalesce(lerpGradient(solidLike(pa ? a : null, gb), gb, t), () => ( b));
   if (ga) return _nullishCoalesce(lerpGradient(ga, solidLike(pb ? b : null, ga), t), () => ( a));
@@ -553,8 +553,8 @@ function interpolateWidthProfiles(a, b, t) {
   const at = [..._nullishCoalesce(a, () => ( [])), ..._nullishCoalesce(b, () => ( [])), { t: 0 }, { t: 1 }].map((p) => p.t).sort((x, y) => x - y);
   const ts = at.filter((v, i) => i === 0 || v - at[i - 1] > 1e-6);
   return ts.map((pos) => {
-    const x = _chunkPEQWARCPcjs.widthProfileAt.call(void 0, a, pos);
-    const y = _chunkPEQWARCPcjs.widthProfileAt.call(void 0, b, pos);
+    const x = _chunkWZYRYYXNcjs.widthProfileAt.call(void 0, a, pos);
+    const y = _chunkWZYRYYXNcjs.widthProfileAt.call(void 0, b, pos);
     return { t: pos, left: lerpN(x.left, y.left, t), right: lerpN(x.right, y.right, t) };
   });
 }
@@ -597,7 +597,7 @@ function reversedStyle(s) {
   out.endArrow = s.startArrow;
   out.startArrowScale = s.endArrowScale;
   out.endArrowScale = s.startArrowScale;
-  if (_optionalChain([s, 'access', _6 => _6.strokeWidthProfile, 'optionalAccess', _7 => _7.length])) out.strokeWidthProfile = _chunkPEQWARCPcjs.reverseWidthProfile.call(void 0, s.strokeWidthProfile);
+  if (_optionalChain([s, 'access', _6 => _6.strokeWidthProfile, 'optionalAccess', _7 => _7.length])) out.strokeWidthProfile = _chunkWZYRYYXNcjs.reverseWidthProfile.call(void 0, s.strokeWidthProfile);
   for (const k of ["startArrow", "endArrow", "startArrowScale", "endArrowScale"]) if (out[k] === void 0) delete out[k];
   return out;
 }
@@ -623,19 +623,19 @@ function styleOf(n) {
   return out;
 }
 function contoursOf(node, m) {
-  return _chunkPEQWARCPcjs.expandVectorCorners.call(void 0, node.subpaths).map((sp) => subpathToMorphContour(sp, m)).filter((c) => !!c);
+  return _chunkWZYRYYXNcjs.expandVectorCorners.call(void 0, node.subpaths).map((sp) => subpathToMorphContour(sp, m)).filter((c) => !!c);
 }
-function preparePathMorph(a, b, options, ma = _chunkPEQWARCPcjs.nodeMatrix.call(void 0, a), mb = _chunkPEQWARCPcjs.nodeMatrix.call(void 0, b)) {
+function preparePathMorph(a, b, options, ma = _chunkWZYRYYXNcjs.nodeMatrix.call(void 0, a), mb = _chunkWZYRYYXNcjs.nodeMatrix.call(void 0, b)) {
   const corr = correspondMorphContours(contoursOf(a, ma), contoursOf(b, mb), options);
   const sim = procrustes(corr.a, corr.b);
   const styleA = styleOf(a);
   const styleB = corr.reversed ? reversedStyle(styleOf(b)) : styleOf(b);
-  const rigid = !_chunkPEQWARCPcjs.isIdentityMatrix.call(void 0, ma) || !_chunkPEQWARCPcjs.isIdentityMatrix.call(void 0, mb);
+  const rigid = !_chunkWZYRYYXNcjs.isIdentityMatrix.call(void 0, ma) || !_chunkWZYRYYXNcjs.isIdentityMatrix.call(void 0, mb);
   const id = _nullishCoalesce(options.id, () => ( a.id));
   return (t) => {
     const contours = interpolateMorphContours(corr.a, corr.b, t, { linear: options.linear, rigidity: options.rigidity, similarity: sim });
-    const m = rigid ? interpolateRigidMatrix(ma, mb, t) : _chunkPEQWARCPcjs.IDENTITY_MATRIX;
-    const back = rigid ? _chunkPEQWARCPcjs.invertMatrix.call(void 0, m) : _chunkPEQWARCPcjs.IDENTITY_MATRIX;
+    const m = rigid ? interpolateRigidMatrix(ma, mb, t) : _chunkWZYRYYXNcjs.IDENTITY_MATRIX;
+    const back = rigid ? _chunkWZYRYYXNcjs.invertMatrix.call(void 0, m) : _chunkWZYRYYXNcjs.IDENTITY_MATRIX;
     const subpaths = contours.map((c, k) => {
       const closed = t <= 0 ? corr.a[k].closed : t >= 1 ? corr.b[k].closed : corr.a[k].closed && corr.b[k].closed;
       return morphContourToSubpath({ closed: corr.a[k].closed && corr.b[k].closed, pts: c.pts }, back, closed);
@@ -643,14 +643,14 @@ function preparePathMorph(a, b, options, ma = _chunkPEQWARCPcjs.nodeMatrix.call(
     const node = { id, type: "path", subpaths, ...interpolateVectorStyle(styleA, styleB, t) };
     const opacity = lerpN(_nullishCoalesce(a.opacity, () => ( 1)), _nullishCoalesce(b.opacity, () => ( 1)), t);
     if (opacity < 1) node.opacity = opacity;
-    if (rigid && !_chunkPEQWARCPcjs.isIdentityMatrix.call(void 0, m)) node.transform = m;
+    if (rigid && !_chunkWZYRYYXNcjs.isIdentityMatrix.call(void 0, m)) node.transform = m;
     return node;
   };
 }
-function flattenPaths(node, parent = _chunkPEQWARCPcjs.IDENTITY_MATRIX) {
-  const m = _chunkPEQWARCPcjs.multiplyMatrices.call(void 0, _chunkPEQWARCPcjs.nodeMatrix.call(void 0, node), parent);
+function flattenPaths(node, parent = _chunkWZYRYYXNcjs.IDENTITY_MATRIX) {
+  const m = _chunkWZYRYYXNcjs.multiplyMatrices.call(void 0, _chunkWZYRYYXNcjs.nodeMatrix.call(void 0, node), parent);
   if (node.type === "path") return [{ path: node, m, opacity: 1 }];
-  if (node.type === "text" || node.type === "instance") return flattenPaths(_chunkPEQWARCPcjs.expandVectorAppearance.call(void 0, node), parent);
+  if (node.type === "text" || node.type === "instance") return flattenPaths(_chunkWZYRYYXNcjs.expandVectorAppearance.call(void 0, node), parent);
   const o = _nullishCoalesce(node.opacity, () => ( 1));
   return node.children.filter((c) => c.visible !== false).flatMap((c) => flattenPaths(c, m)).map((e) => ({ ...e, opacity: e.opacity * o }));
 }
@@ -672,8 +672,8 @@ function createVectorMorph(a, b, options = {}) {
   }
   const pa = flattenPaths(a);
   const pb = flattenPaths(b);
-  const ba = _chunkPEQWARCPcjs.unionBounds.call(void 0, pa.map((e) => placedBounds(e.path, e.m)));
-  const bb = _chunkPEQWARCPcjs.unionBounds.call(void 0, pb.map((e) => placedBounds(e.path, e.m)));
+  const ba = _chunkWZYRYYXNcjs.unionBounds.call(void 0, pa.map((e) => placedBounds(e.path, e.m)));
+  const bb = _chunkWZYRYYXNcjs.unionBounds.call(void 0, pb.map((e) => placedBounds(e.path, e.m)));
   const id = _nullishCoalesce(options.id, () => ( a.id));
   const parts = [];
   const opacities = [];
@@ -685,10 +685,10 @@ function createVectorMorph(a, b, options = {}) {
       parts.push(preparePathMorph(x.path, y.path, sub, x.m, y.m));
       opacities.push([x.opacity, y.opacity]);
     } else if (x) {
-      parts.push(preparePathMorph(x.path, collapsedPath(x.path, x.m, ba, bb), sub, x.m, _chunkPEQWARCPcjs.IDENTITY_MATRIX));
+      parts.push(preparePathMorph(x.path, collapsedPath(x.path, x.m, ba, bb), sub, x.m, _chunkWZYRYYXNcjs.IDENTITY_MATRIX));
       opacities.push([x.opacity, x.opacity]);
     } else if (y) {
-      parts.push(preparePathMorph(collapsedPath(y.path, y.m, bb, ba), y.path, sub, _chunkPEQWARCPcjs.IDENTITY_MATRIX, y.m));
+      parts.push(preparePathMorph(collapsedPath(y.path, y.m, bb, ba), y.path, sub, _chunkWZYRYYXNcjs.IDENTITY_MATRIX, y.m));
       opacities.push([y.opacity, y.opacity]);
     }
   }

package/dist/{chunk-JV7DKLMX.js → chunk-KBH6CM3U.js}

@@ -473,6 +473,10 @@ function createAutosaveController(options) {
     return rev;
   };
   const docName = () => typeof options.name === "function" ? options.name() : options.name;
+  const readBaseVersion = () => {
+    const v = typeof options.baseVersion === "function" ? options.baseVersion() : options.baseVersion;
+    return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+  };
   const run = (action, rev) => {
     if (action.type === "writeSnapshot") {
       setInfo({ status: "saving", nextAttemptAt: null });
@@ -482,11 +486,13 @@ function createAutosaveController(options) {
         try {
           const text = serialize(getSnapshot());
           await storage.set(key, text);
+          const baseVersion = readBaseVersion();
           const meta = {
             dirty: true,
             revision: action.revision,
             time: wallClock(),
-            name: docName()
+            name: docName(),
+            ...baseVersion !== void 0 ? { baseVersion } : {}
           };
           await storage.set(metaKey, JSON.stringify(meta));
           ok = true;
@@ -607,7 +613,7 @@ function createAutosaveController(options) {
       tick();
       await whenIdle();
     },
-    async checkRecovery() {
+    async checkRecovery(checkOptions) {
       if (policy.ownsSnapshot) return null;
       let meta;
       try {
@@ -618,6 +624,12 @@ function createAutosaveController(options) {
         return null;
       }
       if (!meta || meta.dirty !== true) return null;
+      const required = checkOptions?.minimumBaseVersion ?? readBaseVersion();
+      if (required !== void 0 && (typeof meta.baseVersion === "number" ? meta.baseVersion : 0) < required) {
+        await storage.remove(metaKey).catch(() => void 0);
+        await storage.remove(key).catch(() => void 0);
+        return null;
+      }
       const text = await storage.get(key).catch(() => null);
       if (text === null) return null;
       try {
@@ -726,10 +738,36 @@ function createEditorAutosave(doc, options) {
     savedRevision: revisions.savedRevision
   });
   const unsubscribe = revisions.subscribe(() => controller.notify());
+  const retireRecovery = async () => {
+    await controller.discardRecovery();
+    controller.ready();
+    await collect();
+  };
   return {
     controller,
     revisions,
     checkRecovery: () => controller.checkRecovery(),
+    async recoverIfNewer(minimumBaseVersion) {
+      const recovery = await controller.checkRecovery(
+        minimumBaseVersion !== void 0 ? { minimumBaseVersion } : void 0
+      );
+      if (!recovery) {
+        controller.ready();
+        return null;
+      }
+      if (!recovery.snapshot) {
+        await retireRecovery();
+        return null;
+      }
+      try {
+        const report = doc.loadDocument(recovery.snapshot, { history: "reset" });
+        controller.ready();
+        return report;
+      } catch {
+        await retireRecovery();
+        return null;
+      }
+    },
     restore(recovery) {
       if (!recovery.snapshot) throw recovery.error ?? new Error("The recovered snapshot could not be read.");
       const report = doc.loadDocument(recovery.snapshot, { history: "reset" });
@@ -737,9 +775,7 @@ function createEditorAutosave(doc, options) {
       return report;
     },
     async discard() {
-      await controller.discardRecovery();
-      controller.ready();
-      await collect();
+      await retireRecovery();
     },
     async markClean() {
       revisions.markSaved();
@@ -754,6 +790,289 @@ function createEditorAutosave(doc, options) {
   };
 }
 
+// src/persistence/remoteSync.ts
+var EditorRemoteConflictError = class extends Error {
+  constructor(serverVersion) {
+    super(
+      serverVersion === void 0 ? "The document changed on the server since it was loaded; local edits were not saved." : `The document is at version ${serverVersion} on the server; local edits were not saved.`
+    );
+    this.serverVersion = serverVersion;
+    this.name = "EditorRemoteConflictError";
+  }
+  serverVersion;
+};
+var cloneSnapshot = (value) => {
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return value;
+  }
+};
+function createEditorRemoteSync(doc, options) {
+  const debounceMs = options.debounceMs ?? 500;
+  const now = options.now ?? Date.now;
+  let localVersion = options.initialVersion ?? 0;
+  let confirmedVersion = localVersion;
+  let localSequence = 0;
+  let savedSequence = 0;
+  let baselineSnapshot = cloneSnapshot(doc.getDocument());
+  let savedSnapshot = baselineSnapshot;
+  let state = "idle";
+  let lastSavedAt = null;
+  let lastError = void 0;
+  let isApplyingRemote = false;
+  let conflictRetries = 0;
+  let destroyed = false;
+  let debounceTimer = null;
+  let inFlightPromise = null;
+  const listeners = /* @__PURE__ */ new Set();
+  const getStatus = () => ({
+    status: state,
+    version: localVersion,
+    savedVersion: confirmedVersion,
+    dirty: localSequence > savedSequence,
+    lastSavedAt,
+    ...lastError !== void 0 ? { error: lastError } : {}
+  });
+  const emit = () => {
+    const currentStatus = getStatus();
+    listeners.forEach((listener) => {
+      try {
+        listener(currentStatus);
+      } catch (error) {
+        console.error("[remoteSync] Error in status listener:", error);
+      }
+    });
+  };
+  const clearTimer = () => {
+    if (debounceTimer !== null) {
+      clearTimeout(debounceTimer);
+      debounceTimer = null;
+    }
+  };
+  const hasChanged = (current, baseline) => {
+    if (options.diff) {
+      const diff = options.diff(current, baseline);
+      const empty = options.isEmptyDiff ? options.isEmptyDiff(diff, current, baseline) : JSON.stringify(current) === JSON.stringify(baseline);
+      return { changed: !empty, diff };
+    }
+    return { changed: JSON.stringify(current) !== JSON.stringify(baseline) };
+  };
+  const suppressed = (fn) => {
+    const wasApplying = isApplyingRemote;
+    isApplyingRemote = true;
+    try {
+      return fn();
+    } finally {
+      isApplyingRemote = wasApplying;
+    }
+  };
+  const executeSave = async () => {
+    if (inFlightPromise) {
+      await inFlightPromise;
+      if (localSequence > savedSequence) {
+        return executeSave();
+      }
+      return true;
+    }
+    if (localSequence <= savedSequence) {
+      return true;
+    }
+    clearTimer();
+    const targetSequence = localSequence;
+    const snapshotToSave = cloneSnapshot(baselineSnapshot);
+    const diffToSave = options.diff ? options.diff(snapshotToSave, savedSnapshot) : void 0;
+    const versionToSave = Math.max(localVersion, confirmedVersion + 1);
+    localVersion = versionToSave;
+    state = "saving";
+    lastError = void 0;
+    emit();
+    const run = (async () => {
+      try {
+        const result = await options.save({
+          document: snapshotToSave,
+          version: versionToSave,
+          baseVersion: confirmedVersion,
+          diff: diffToSave
+        });
+        if (result && typeof result === "object" && result.conflict) {
+          const serverVersion = typeof result.version === "number" ? result.version : void 0;
+          if (!options.onConflict || conflictRetries >= (options.maxConflictRetries ?? 3)) {
+            conflictRetries = 0;
+            throw new EditorRemoteConflictError(serverVersion);
+          }
+          conflictRetries++;
+          const resolution = await options.onConflict({
+            document: snapshotToSave,
+            base: savedSnapshot,
+            serverVersion,
+            apply: (fn) => suppressed(fn)
+          });
+          confirmedVersion = resolution.serverVersion;
+          localVersion = Math.max(localVersion, confirmedVersion);
+          if (resolution.serverDocument !== void 0) savedSnapshot = cloneSnapshot(resolution.serverDocument);
+          baselineSnapshot = cloneSnapshot(doc.getDocument());
+          localSequence++;
+          state = "pending";
+          emit();
+          return true;
+        }
+        conflictRetries = 0;
+        const returnedVersion = typeof result === "number" ? result : result && typeof result === "object" && typeof result.version === "number" ? result.version : versionToSave;
+        confirmedVersion = Math.max(confirmedVersion, versionToSave, returnedVersion);
+        if (returnedVersion > localVersion) {
+          localVersion = returnedVersion;
+        }
+        savedSequence = Math.max(savedSequence, targetSequence);
+        savedSnapshot = snapshotToSave;
+        lastSavedAt = now();
+        lastError = void 0;
+        if (localSequence <= savedSequence) {
+          state = "saved";
+          try {
+            await options.autosave?.markClean();
+          } catch (error) {
+            console.error("[remoteSync] autosave.markClean failed:", error);
+          }
+        } else {
+          state = "pending";
+        }
+        options.onSaved?.({ document: snapshotToSave, version: confirmedVersion });
+        emit();
+        return true;
+      } catch (error) {
+        lastError = error;
+        state = "error";
+        options.onError?.(error);
+        emit();
+        return false;
+      }
+    })();
+    inFlightPromise = run;
+    let ok;
+    try {
+      ok = await run;
+    } finally {
+      if (inFlightPromise === run) inFlightPromise = null;
+    }
+    if (ok && localSequence > savedSequence && debounceTimer === null) {
+      return executeSave();
+    }
+    return ok;
+  };
+  const scheduleSave = () => {
+    clearTimer();
+    if (debounceMs <= 0) {
+      void executeSave();
+      return;
+    }
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null;
+      if (!destroyed) {
+        void executeSave();
+      }
+    }, debounceMs);
+  };
+  const notify = () => {
+    if (isApplyingRemote || destroyed) return false;
+    const current = cloneSnapshot(doc.getDocument());
+    const { changed, diff } = hasChanged(current, baselineSnapshot);
+    if (!changed) return false;
+    const previousBaseline = baselineSnapshot;
+    baselineSnapshot = current;
+    localSequence++;
+    localVersion = Math.max(localVersion, confirmedVersion) + 1;
+    if (state !== "saving") {
+      state = "pending";
+    }
+    emit();
+    options.onLocalChange?.({
+      document: current,
+      baseline: previousBaseline,
+      diff,
+      version: localVersion
+    });
+    scheduleSave();
+    return true;
+  };
+  const flush = async () => {
+    clearTimer();
+    notify();
+    if (localSequence <= savedSequence && !inFlightPromise) {
+      return true;
+    }
+    return executeSave();
+  };
+  const unsubscribeDoc = doc.subscribe(() => {
+    notify();
+  });
+  return {
+    version: () => localVersion,
+    savedVersion: () => confirmedVersion,
+    dirty: () => localSequence > savedSequence,
+    status: getStatus,
+    baseline: () => baselineSnapshot,
+    notify,
+    applyRemote(fn, remoteVersion) {
+      const wasApplying = isApplyingRemote;
+      const wasDirty = localSequence > savedSequence;
+      isApplyingRemote = true;
+      try {
+        const result = fn();
+        baselineSnapshot = cloneSnapshot(doc.getDocument());
+        if (typeof remoteVersion === "number" && Number.isFinite(remoteVersion)) {
+          confirmedVersion = Math.max(confirmedVersion, remoteVersion);
+          localVersion = Math.max(localVersion, remoteVersion);
+        }
+        if (!wasDirty) {
+          savedSequence = localSequence;
+          savedSnapshot = baselineSnapshot;
+        }
+        emit();
+        return result;
+      } finally {
+        isApplyingRemote = wasApplying;
+      }
+    },
+    resetBaseline(remoteVersion) {
+      clearTimer();
+      baselineSnapshot = cloneSnapshot(doc.getDocument());
+      savedSnapshot = baselineSnapshot;
+      if (typeof remoteVersion === "number" && Number.isFinite(remoteVersion)) {
+        localVersion = remoteVersion;
+        confirmedVersion = remoteVersion;
+      }
+      savedSequence = localSequence;
+      lastError = void 0;
+      state = "idle";
+      emit();
+    },
+    flush,
+    async whenIdle() {
+      while (debounceTimer !== null || inFlightPromise) {
+        if (debounceTimer !== null) {
+          await flush();
+        } else if (inFlightPromise) {
+          await inFlightPromise.catch(() => false);
+        }
+      }
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      listener(getStatus());
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    destroy() {
+      destroyed = true;
+      clearTimer();
+      unsubscribeDoc();
+      listeners.clear();
+    }
+  };
+}
+
 // src/persistence/documentStore.ts
 function slugifyDocumentName(name) {
   const slug = name.normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
@@ -1067,6 +1386,8 @@ export {
   createAutosaveController,
   createRevisionTracker,
   createEditorAutosave,
+  EditorRemoteConflictError,
+  createEditorRemoteSync,
   slugifyDocumentName,
   createEditorDocumentStore,
   createDocumentToolProvider