@pixerate/editor 0.278.0 → 0.279.0

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

package/dist/persistence/autosave.d.cts

@@ -21,6 +21,8 @@ export interface RecoveryMeta {
     time?: number;
     /** Document name, for the "Restore unsaved changes from …?" prompt. */
     name?: string;
+    /** The server / host version the edits in the snapshot were made on (`baseVersion` option). */
+    baseVersion?: number;
 }
 export interface AutosaveRecovery<T = unknown> {
     /** The parsed snapshot (`undefined` when `deserialize` threw; see `error`). */
@@ -65,6 +67,18 @@ export interface AutosaveControllerOptions<T> {
     clearTimeout?: (handle: any) => void;
     /** Start hydrated, i.e. as if `ready()` was already called (default `false`). */
     ready?: boolean;
+    /**
+     * The server / host version of the document that is loaded now. It is stored in each
+     * snapshot's meta, and `checkRecovery` retires (deletes and does not return) a snapshot whose
+     * edits were made on an older version, so it never overwrites newer server state. A snapshot
+     * without a stored version counts as version 0.
+     */
+    baseVersion?: number | (() => number | undefined);
+}
+/** Options for `AutosaveController.checkRecovery`. */
+export interface CheckRecoveryOptions {
+    /** Retire snapshots made on a version older than this (default the `baseVersion` option). */
+    minimumBaseVersion?: number;
 }
 export interface AutosaveController<T = unknown> {
     /** Current status. */
@@ -91,7 +105,7 @@ export interface AutosaveController<T = unknown> {
      * A dirty snapshot left by an earlier session, or `null`. Returns `null` once
      * this session has written its own snapshot.
      */
-    checkRecovery(): Promise<AutosaveRecovery<T> | null>;
+    checkRecovery(options?: CheckRecoveryOptions): Promise<AutosaveRecovery<T> | null>;
     /** Deletes an earlier session's snapshot. No-op once this session wrote its own. */
     discardRecovery(): Promise<boolean>;
     /** Runs one scheduling step now (normally driven by `notify` and timers). */

package/dist/persistence/autosave.d.ts

@@ -21,6 +21,8 @@ export interface RecoveryMeta {
     time?: number;
     /** Document name, for the "Restore unsaved changes from …?" prompt. */
     name?: string;
+    /** The server / host version the edits in the snapshot were made on (`baseVersion` option). */
+    baseVersion?: number;
 }
 export interface AutosaveRecovery<T = unknown> {
     /** The parsed snapshot (`undefined` when `deserialize` threw; see `error`). */
@@ -65,6 +67,18 @@ export interface AutosaveControllerOptions<T> {
     clearTimeout?: (handle: any) => void;
     /** Start hydrated, i.e. as if `ready()` was already called (default `false`). */
     ready?: boolean;
+    /**
+     * The server / host version of the document that is loaded now. It is stored in each
+     * snapshot's meta, and `checkRecovery` retires (deletes and does not return) a snapshot whose
+     * edits were made on an older version, so it never overwrites newer server state. A snapshot
+     * without a stored version counts as version 0.
+     */
+    baseVersion?: number | (() => number | undefined);
+}
+/** Options for `AutosaveController.checkRecovery`. */
+export interface CheckRecoveryOptions {
+    /** Retire snapshots made on a version older than this (default the `baseVersion` option). */
+    minimumBaseVersion?: number;
 }
 export interface AutosaveController<T = unknown> {
     /** Current status. */
@@ -91,7 +105,7 @@ export interface AutosaveController<T = unknown> {
      * A dirty snapshot left by an earlier session, or `null`. Returns `null` once
      * this session has written its own snapshot.
      */
-    checkRecovery(): Promise<AutosaveRecovery<T> | null>;
+    checkRecovery(options?: CheckRecoveryOptions): Promise<AutosaveRecovery<T> | null>;
     /** Deletes an earlier session's snapshot. No-op once this session wrote its own. */
     discardRecovery(): Promise<boolean>;
     /** Runs one scheduling step now (normally driven by `notify` and timers). */

package/dist/persistence/editorAutosave.d.cts

@@ -11,6 +11,12 @@ export interface EditorAutosaveOptions extends Omit<AutosaveControllerOptions<Ed
      * saved state needs no snapshot. Without it, every change counts until `markClean()`.
      */
     dirty?: DirtyFlagSource;
+    /**
+     * The server / host version of the loaded document, stored with each snapshot.
+     * `checkRecovery` / `recoverIfNewer` retire snapshots made on an older version instead of
+     * offering them (see `AutosaveControllerOptions.baseVersion`).
+     */
+    baseVersion?: number | (() => number | undefined);
     /**
      * For documents with `assets`: after `markClean` or `discard` retire a snapshot, delete the
      * stored assets nothing refers to any more (`collectEditorAssetGarbage`, best effort, keeping
@@ -21,8 +27,13 @@ export interface EditorAutosaveOptions extends Omit<AutosaveControllerOptions<Ed
 export interface EditorAutosave {
     readonly controller: AutosaveController<EditorDocumentFile>;
     readonly revisions: RevisionTracker;
-    /** An earlier session's unsaved snapshot of this document, or `null`. */
+    /** An earlier session's unsaved snapshot of this document, or `null` (snapshots made on a version older than `baseVersion` are retired). */
     checkRecovery(): Promise<AutosaveRecovery<EditorDocumentFile> | null>;
+    /**
+     * Checks for an earlier session's unsaved snapshot, restoring it into `doc` if it is valid and
+     * at least as new as `baseVersion`, or retiring it and starting autosave cleanly if stale/invalid.
+     */
+    recoverIfNewer(minimumBaseVersion?: number): Promise<LoadReport | null>;
     /** Loads a recovered snapshot into the document and starts autosaving. */
     restore(recovery: AutosaveRecovery<EditorDocumentFile>): LoadReport;
     /** Deletes the earlier session's snapshot and starts autosaving. */

package/dist/persistence/editorAutosave.d.ts

@@ -11,6 +11,12 @@ export interface EditorAutosaveOptions extends Omit<AutosaveControllerOptions<Ed
      * saved state needs no snapshot. Without it, every change counts until `markClean()`.
      */
     dirty?: DirtyFlagSource;
+    /**
+     * The server / host version of the loaded document, stored with each snapshot.
+     * `checkRecovery` / `recoverIfNewer` retire snapshots made on an older version instead of
+     * offering them (see `AutosaveControllerOptions.baseVersion`).
+     */
+    baseVersion?: number | (() => number | undefined);
     /**
      * For documents with `assets`: after `markClean` or `discard` retire a snapshot, delete the
      * stored assets nothing refers to any more (`collectEditorAssetGarbage`, best effort, keeping
@@ -21,8 +27,13 @@ export interface EditorAutosaveOptions extends Omit<AutosaveControllerOptions<Ed
 export interface EditorAutosave {
     readonly controller: AutosaveController<EditorDocumentFile>;
     readonly revisions: RevisionTracker;
-    /** An earlier session's unsaved snapshot of this document, or `null`. */
+    /** An earlier session's unsaved snapshot of this document, or `null` (snapshots made on a version older than `baseVersion` are retired). */
     checkRecovery(): Promise<AutosaveRecovery<EditorDocumentFile> | null>;
+    /**
+     * Checks for an earlier session's unsaved snapshot, restoring it into `doc` if it is valid and
+     * at least as new as `baseVersion`, or retiring it and starting autosave cleanly if stale/invalid.
+     */
+    recoverIfNewer(minimumBaseVersion?: number): Promise<LoadReport | null>;
     /** Loads a recovered snapshot into the document and starts autosaving. */
     restore(recovery: AutosaveRecovery<EditorDocumentFile>): LoadReport;
     /** Deletes the earlier session's snapshot and starts autosaving. */

package/dist/persistence/index.cjs

@@ -19,7 +19,9 @@
 
 
 
-var _chunkT2HUQBRCcjs = require('../chunk-T2HUQBRC.cjs');
+
+
+var _chunkDK33HLA2cjs = require('../chunk-DK33HLA2.cjs');
 
 
 
@@ -92,4 +94,6 @@ require('../chunk-2BSBFBOA.cjs');
 
 
 
-exports.EDITOR_ASSET_PREFIX = _chunkSJ2CPTQCcjs.EDITOR_ASSET_PREFIX; exports.EDITOR_DOCUMENT_FORMAT = _chunkSJ2CPTQCcjs.EDITOR_DOCUMENT_FORMAT; exports.EditorDocumentLoadError = _chunkSJ2CPTQCcjs.EditorDocumentLoadError; exports.InjectedStorageError = _chunkT2HUQBRCcjs.InjectedStorageError; exports.StorageUnavailableError = _chunkT2HUQBRCcjs.StorageUnavailableError; exports.collectAssetRefs = _chunkSJ2CPTQCcjs.collectAssetRefs; exports.collectEditorAssetGarbage = _chunkSJ2CPTQCcjs.collectEditorAssetGarbage; exports.collectRetiredEditorAssets = _chunkSJ2CPTQCcjs.collectRetiredEditorAssets; exports.createAutosaveController = _chunkT2HUQBRCcjs.createAutosaveController; exports.createDocumentToolProvider = _chunkT2HUQBRCcjs.createDocumentToolProvider; exports.createEditorAssetRegistry = _chunkSJ2CPTQCcjs.createEditorAssetRegistry; exports.createEditorAutosave = _chunkT2HUQBRCcjs.createEditorAutosave; exports.createEditorDocumentStore = _chunkT2HUQBRCcjs.createEditorDocumentStore; exports.createIndexedDbAdapter = _chunkT2HUQBRCcjs.createIndexedDbAdapter; exports.createLoadReport = _chunkSJ2CPTQCcjs.createLoadReport; exports.createLocalStorageAdapter = _chunkT2HUQBRCcjs.createLocalStorageAdapter; exports.createMemoryStorage = _chunkT2HUQBRCcjs.createMemoryStorage; exports.createOpfsAdapter = _chunkT2HUQBRCcjs.createOpfsAdapter; exports.createRecoveryPolicy = _chunkT2HUQBRCcjs.createRecoveryPolicy; exports.createRevisionTracker = _chunkT2HUQBRCcjs.createRevisionTracker; exports.defineEditorDocument = _chunkSJ2CPTQCcjs.defineEditorDocument; exports.exponentialBackoff = _chunkT2HUQBRCcjs.exponentialBackoff; exports.externalizeAssets = _chunkSJ2CPTQCcjs.externalizeAssets; exports.formatRecoveryMessage = _chunkT2HUQBRCcjs.formatRecoveryMessage; exports.hasLoadProblems = _chunkSJ2CPTQCcjs.hasLoadProblems; exports.internalizeAssets = _chunkSJ2CPTQCcjs.internalizeAssets; exports.isEditorDocumentFile = _chunkSJ2CPTQCcjs.isEditorDocumentFile; exports.isIndexedDbAvailable = _chunkT2HUQBRCcjs.isIndexedDbAvailable; exports.isInlineAsset = _chunkSJ2CPTQCcjs.isInlineAsset; exports.isLocalStorageAvailable = _chunkT2HUQBRCcjs.isLocalStorageAvailable; exports.isOpfsAvailable = _chunkT2HUQBRCcjs.isOpfsAvailable; exports.loadDocument = _chunkSJ2CPTQCcjs.loadDocument; exports.loadSections = _chunkSJ2CPTQCcjs.loadSections; exports.migrateDocument = _chunkSJ2CPTQCcjs.migrateDocument; exports.parseEditorDocument = _chunkSJ2CPTQCcjs.parseEditorDocument; exports.persistEditorAssets = _chunkSJ2CPTQCcjs.persistEditorAssets; exports.preloadEditorAssets = _chunkSJ2CPTQCcjs.preloadEditorAssets; exports.recoveryMetaKey = _chunkT2HUQBRCcjs.recoveryMetaKey; exports.serializeEditorDocument = _chunkSJ2CPTQCcjs.serializeEditorDocument; exports.slugifyDocumentName = _chunkT2HUQBRCcjs.slugifyDocumentName; exports.toEditorDocumentFile = _chunkSJ2CPTQCcjs.toEditorDocumentFile; exports.tryCollectEditorAssetGarbage = _chunkSJ2CPTQCcjs.tryCollectEditorAssetGarbage; exports.withEditorAssets = _chunkSJ2CPTQCcjs.withEditorAssets; exports.withStorageFailures = _chunkT2HUQBRCcjs.withStorageFailures;
+
+
+exports.EDITOR_ASSET_PREFIX = _chunkSJ2CPTQCcjs.EDITOR_ASSET_PREFIX; exports.EDITOR_DOCUMENT_FORMAT = _chunkSJ2CPTQCcjs.EDITOR_DOCUMENT_FORMAT; exports.EditorDocumentLoadError = _chunkSJ2CPTQCcjs.EditorDocumentLoadError; exports.EditorRemoteConflictError = _chunkDK33HLA2cjs.EditorRemoteConflictError; exports.InjectedStorageError = _chunkDK33HLA2cjs.InjectedStorageError; exports.StorageUnavailableError = _chunkDK33HLA2cjs.StorageUnavailableError; exports.collectAssetRefs = _chunkSJ2CPTQCcjs.collectAssetRefs; exports.collectEditorAssetGarbage = _chunkSJ2CPTQCcjs.collectEditorAssetGarbage; exports.collectRetiredEditorAssets = _chunkSJ2CPTQCcjs.collectRetiredEditorAssets; exports.createAutosaveController = _chunkDK33HLA2cjs.createAutosaveController; exports.createDocumentToolProvider = _chunkDK33HLA2cjs.createDocumentToolProvider; exports.createEditorAssetRegistry = _chunkSJ2CPTQCcjs.createEditorAssetRegistry; exports.createEditorAutosave = _chunkDK33HLA2cjs.createEditorAutosave; exports.createEditorDocumentStore = _chunkDK33HLA2cjs.createEditorDocumentStore; exports.createEditorRemoteSync = _chunkDK33HLA2cjs.createEditorRemoteSync; exports.createIndexedDbAdapter = _chunkDK33HLA2cjs.createIndexedDbAdapter; exports.createLoadReport = _chunkSJ2CPTQCcjs.createLoadReport; exports.createLocalStorageAdapter = _chunkDK33HLA2cjs.createLocalStorageAdapter; exports.createMemoryStorage = _chunkDK33HLA2cjs.createMemoryStorage; exports.createOpfsAdapter = _chunkDK33HLA2cjs.createOpfsAdapter; exports.createRecoveryPolicy = _chunkDK33HLA2cjs.createRecoveryPolicy; exports.createRevisionTracker = _chunkDK33HLA2cjs.createRevisionTracker; exports.defineEditorDocument = _chunkSJ2CPTQCcjs.defineEditorDocument; exports.exponentialBackoff = _chunkDK33HLA2cjs.exponentialBackoff; exports.externalizeAssets = _chunkSJ2CPTQCcjs.externalizeAssets; exports.formatRecoveryMessage = _chunkDK33HLA2cjs.formatRecoveryMessage; exports.hasLoadProblems = _chunkSJ2CPTQCcjs.hasLoadProblems; exports.internalizeAssets = _chunkSJ2CPTQCcjs.internalizeAssets; exports.isEditorDocumentFile = _chunkSJ2CPTQCcjs.isEditorDocumentFile; exports.isIndexedDbAvailable = _chunkDK33HLA2cjs.isIndexedDbAvailable; exports.isInlineAsset = _chunkSJ2CPTQCcjs.isInlineAsset; exports.isLocalStorageAvailable = _chunkDK33HLA2cjs.isLocalStorageAvailable; exports.isOpfsAvailable = _chunkDK33HLA2cjs.isOpfsAvailable; exports.loadDocument = _chunkSJ2CPTQCcjs.loadDocument; exports.loadSections = _chunkSJ2CPTQCcjs.loadSections; exports.migrateDocument = _chunkSJ2CPTQCcjs.migrateDocument; exports.parseEditorDocument = _chunkSJ2CPTQCcjs.parseEditorDocument; exports.persistEditorAssets = _chunkSJ2CPTQCcjs.persistEditorAssets; exports.preloadEditorAssets = _chunkSJ2CPTQCcjs.preloadEditorAssets; exports.recoveryMetaKey = _chunkDK33HLA2cjs.recoveryMetaKey; exports.serializeEditorDocument = _chunkSJ2CPTQCcjs.serializeEditorDocument; exports.slugifyDocumentName = _chunkDK33HLA2cjs.slugifyDocumentName; exports.toEditorDocumentFile = _chunkSJ2CPTQCcjs.toEditorDocumentFile; exports.tryCollectEditorAssetGarbage = _chunkSJ2CPTQCcjs.tryCollectEditorAssetGarbage; exports.withEditorAssets = _chunkSJ2CPTQCcjs.withEditorAssets; exports.withStorageFailures = _chunkDK33HLA2cjs.withStorageFailures;

package/dist/persistence/index.d.cts

@@ -5,6 +5,7 @@ export * from "./migrate.cjs";
 export * from "./revisions.cjs";
 export * from "./editorDocument.cjs";
 export * from "./editorAutosave.cjs";
+export * from "./remoteSync.cjs";
 export * from "./documentStore.cjs";
 export * from "./documentTools.cjs";
 export * from "./assets.cjs";

package/dist/persistence/index.d.ts

@@ -5,6 +5,7 @@ export * from "./migrate.js";
 export * from "./revisions.js";
 export * from "./editorDocument.js";
 export * from "./editorAutosave.js";
+export * from "./remoteSync.js";
 export * from "./documentStore.js";
 export * from "./documentTools.js";
 export * from "./assets.js";

package/dist/persistence/index.js

@@ -1,10 +1,12 @@
 import {
+  EditorRemoteConflictError,
   InjectedStorageError,
   StorageUnavailableError,
   createAutosaveController,
   createDocumentToolProvider,
   createEditorAutosave,
   createEditorDocumentStore,
+  createEditorRemoteSync,
   createIndexedDbAdapter,
   createLocalStorageAdapter,
   createMemoryStorage,
@@ -19,7 +21,7 @@ import {
   recoveryMetaKey,
   slugifyDocumentName,
   withStorageFailures
-} from "../chunk-JV7DKLMX.js";
+} from "../chunk-KBH6CM3U.js";
 import {
   EDITOR_ASSET_PREFIX,
   EDITOR_DOCUMENT_FORMAT,
@@ -51,6 +53,7 @@ export {
   EDITOR_ASSET_PREFIX,
   EDITOR_DOCUMENT_FORMAT,
   EditorDocumentLoadError,
+  EditorRemoteConflictError,
   InjectedStorageError,
   StorageUnavailableError,
   collectAssetRefs,
@@ -61,6 +64,7 @@ export {
   createEditorAssetRegistry,
   createEditorAutosave,
   createEditorDocumentStore,
+  createEditorRemoteSync,
   createIndexedDbAdapter,
   createLoadReport,
   createLocalStorageAdapter,