@pixerate/editor 0.278.0 → 0.279.0

package/dist/canvas/index.js

@@ -11892,6 +11892,141 @@ var isViewport = (value) => {
   const v = value;
   return !!v && typeof v === "object" && [v.x, v.y, v.zoom].every((n3) => typeof n3 === "number" && Number.isFinite(n3)) && v.zoom > 0;
 };
+function sanitizeCanvasDocument(raw, options = {}) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return { nodes: [], edges: [] };
+  }
+  const doc = raw;
+  const keys = omitKeys(options);
+  const rawNodes = Array.isArray(doc.nodes) ? doc.nodes : [];
+  const rawEdges = Array.isArray(doc.edges) ? doc.edges : [];
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const candidate of rawNodes) {
+    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) continue;
+    const item = candidate;
+    if (typeof item.id !== "string" || item.id.length === 0) continue;
+    const pos = item.position;
+    const position = {
+      x: typeof pos?.x === "number" && Number.isFinite(pos.x) ? pos.x : 0,
+      y: typeof pos?.y === "number" && Number.isFinite(pos.y) ? pos.y : 0
+    };
+    const data = item.data && typeof item.data === "object" && !Array.isArray(item.data) ? { ...item.data } : {};
+    const cleaned = omit({ ...item, position, data }, keys.node);
+    nodeMap.set(item.id, options.normalizeNode ? options.normalizeNode(cleaned) : cleaned);
+  }
+  const hasCycle = (nodeId, parentId) => {
+    let cur = parentId;
+    const seen = /* @__PURE__ */ new Set([nodeId]);
+    while (cur) {
+      if (seen.has(cur)) return true;
+      seen.add(cur);
+      cur = nodeMap.get(cur)?.parentId;
+    }
+    return false;
+  };
+  const sanitizedNodes = [];
+  for (const node of nodeMap.values()) {
+    if (node.parentId !== void 0 && (typeof node.parentId !== "string" || !nodeMap.has(node.parentId) || hasCycle(node.id, node.parentId))) {
+      const copy = { ...node };
+      delete copy.parentId;
+      delete copy.extent;
+      nodeMap.set(node.id, copy);
+      sanitizedNodes.push(copy);
+    } else {
+      sanitizedNodes.push(node);
+    }
+  }
+  const orderedNodes = [];
+  const placedIds = /* @__PURE__ */ new Set();
+  const byId = new Map(sanitizedNodes.map((n3) => [n3.id, n3]));
+  const place2 = (node) => {
+    if (placedIds.has(node.id)) return;
+    if (node.parentId && byId.has(node.parentId)) {
+      place2(byId.get(node.parentId));
+    }
+    placedIds.add(node.id);
+    orderedNodes.push(node);
+  };
+  for (const node of sanitizedNodes) place2(node);
+  const edgeMap = /* @__PURE__ */ new Map();
+  for (const candidate of rawEdges) {
+    if (!isValidCanvasEdge(candidate)) continue;
+    if (!placedIds.has(candidate.source) || !placedIds.has(candidate.target)) continue;
+    edgeMap.set(candidate.id, omit({ ...candidate }, keys.edge));
+  }
+  const extraEntries = Object.entries(doc).filter(
+    ([k, v]) => k !== "nodes" && k !== "edges" && k !== "scenes" && k !== "viewport" && v !== void 0
+  );
+  return {
+    ...Object.fromEntries(extraEntries),
+    nodes: orderedNodes,
+    edges: [...edgeMap.values()],
+    ...Array.isArray(doc.scenes) ? { scenes: doc.scenes } : {},
+    ...isViewport(doc.viewport) ? { viewport: { ...doc.viewport } } : {}
+  };
+}
+function calculateGraphDifferences(currentState, baselineState, options) {
+  const currentNodes = currentState.nodes ?? [];
+  const currentEdges = currentState.edges ?? [];
+  const baselineNodes = baselineState.nodes ?? [];
+  const baselineEdges = baselineState.edges ?? [];
+  const keys = omitKeys(options);
+  const baselineNodeMap = new Map(baselineNodes.map((n3) => [n3.id, n3]));
+  const baselineEdgeMap = new Map(baselineEdges.map((e) => [e.id, e]));
+  const currentNodeMap = new Map(currentNodes.map((n3) => [n3.id, n3]));
+  const currentEdgeMap = new Map(currentEdges.map((e) => [e.id, e]));
+  const removedNodes = baselineNodes.filter((oldNode) => !currentNodeMap.has(oldNode.id));
+  const removedEdges = baselineEdges.filter((oldEdge) => !currentEdgeMap.has(oldEdge.id));
+  const changedNodes = currentNodes.filter((newNode) => {
+    const oldNode = baselineNodeMap.get(newNode.id);
+    if (!oldNode) return true;
+    return JSON.stringify(omit(newNode, keys.node)) !== JSON.stringify(omit(oldNode, keys.node));
+  });
+  const changedEdges = currentEdges.filter((newEdge) => {
+    const oldEdge = baselineEdgeMap.get(newEdge.id);
+    if (!oldEdge) return true;
+    return JSON.stringify(omit(newEdge, keys.edge)) !== JSON.stringify(omit(oldEdge, keys.edge));
+  });
+  return { changedNodes, changedEdges, removedNodes, removedEdges };
+}
+function applyGraphDifferences(state, diff) {
+  const removedNodeIds = new Set((diff.removedNodes ?? []).map((n3) => n3.id));
+  const removedEdgeIds = new Set((diff.removedEdges ?? []).map((e) => e.id));
+  const changedNodeMap = new Map((diff.changedNodes ?? []).map((n3) => [n3.id, n3]));
+  const changedEdgeMap = new Map((diff.changedEdges ?? []).map((e) => [e.id, e]));
+  const existingNodeIds = /* @__PURE__ */ new Set();
+  const nextNodes = state.nodes.filter((n3) => !removedNodeIds.has(n3.id)).map((n3) => {
+    existingNodeIds.add(n3.id);
+    const updated = changedNodeMap.get(n3.id);
+    if (!updated) return n3;
+    return {
+      ...updated,
+      ...n3.selected !== void 0 ? { selected: n3.selected } : {},
+      ...n3.measured !== void 0 && updated.measured === void 0 ? { measured: n3.measured } : {}
+    };
+  });
+  for (const [id, node] of changedNodeMap) {
+    if (!existingNodeIds.has(id) && !removedNodeIds.has(id)) {
+      nextNodes.push({ ...node, selected: false });
+    }
+  }
+  const existingEdgeIds = /* @__PURE__ */ new Set();
+  const nextEdges = state.edges.filter((e) => !removedEdgeIds.has(e.id)).map((e) => {
+    existingEdgeIds.add(e.id);
+    const updated = changedEdgeMap.get(e.id);
+    if (!updated) return e;
+    return {
+      ...updated,
+      ...e.selected !== void 0 ? { selected: e.selected } : {}
+    };
+  });
+  for (const [id, edge] of changedEdgeMap) {
+    if (!existingEdgeIds.has(id) && !removedEdgeIds.has(id)) {
+      nextEdges.push({ ...edge, selected: false });
+    }
+  }
+  return { nodes: nextNodes, edges: nextEdges };
+}
 function checkCanvasDocument(document2) {
   const hint = "A canvas document is { nodes: [{ id, position: { x, y }, data }], edges: [{ id, source, target }], scenes?, viewport? } as get_canvas_document returns it.";
   const value = document2;
@@ -11919,9 +12054,16 @@ function checkCanvasDocument(document2) {
   if (value.viewport !== void 0 && !isViewport(value.viewport)) throw new Error(`viewport must be { x, y, zoom } with finite numbers and a zoom above 0. ${hint}`);
 }
 function createCanvasEditorDocument(options) {
-  const { history, scenes: scenes2 } = options;
+  const { history, scenes: scenes2, extras } = options;
   const keys = omitKeys(options);
+  const snapshotExtras = () => {
+    if (!extras) return {};
+    const raw = extras.get();
+    if (!raw || typeof raw !== "object") return {};
+    return Object.fromEntries(Object.entries(raw).filter(([, v]) => v !== void 0));
+  };
   const snapshot = () => ({
+    ...snapshotExtras(),
     nodes: options.getNodes().map((n3) => omit(n3, keys.node)),
     edges: options.getEdges().map((e) => omit(e, keys.edge)),
     ...scenes2 ? { scenes: scenes2.toJSON().scenes } : {},
@@ -11932,6 +12074,7 @@ function createCanvasEditorDocument(options) {
     options.setEdges(doc.edges.map((e) => ({ ...e })));
     if (scenes2) scenes2.load(doc.scenes ?? []);
     if (doc.viewport) options.setViewport?.({ ...doc.viewport });
+    extras?.load?.(doc);
   };
   const check = (document2) => {
     checkCanvasDocument(document2);
@@ -11963,6 +12106,7 @@ function createCanvasEditorDocument(options) {
     subscribe: (listener) => {
       const offs = [history.subscribe(() => listener())];
       if (scenes2) offs.push(scenes2.subscribe(() => listener()));
+      if (extras?.subscribe) offs.push(extras.subscribe(() => listener()));
       if (options.subscribe) offs.push(options.subscribe(listener));
       return () => offs.forEach((off) => off());
     },
@@ -12895,6 +13039,7 @@ export {
   applyAnimation,
   applyAnimationOverrides,
   applyConstraints,
+  applyGraphDifferences,
   applyNodeUpdates,
   applyShapeCombination,
   applyShapeReplacement,
@@ -12921,6 +13066,7 @@ export {
   calculateCurvedPath,
   calculateDagreReflowDisplacement,
   calculateDirectionalDisplacement,
+  calculateGraphDifferences,
   calculateReflowDisplacement,
   canCombineShapeNodes,
   canOffsetShapeNodes,
@@ -13273,6 +13419,7 @@ export {
   runCanvasNodeEffect,
   runMultiNodeTransition,
   sampleAnimationFrames,
+  sanitizeCanvasDocument,
   scaleKeyframes,
   sceneColor,
   segmentBounds,

package/dist/chart/index.cjs

@@ -6,7 +6,7 @@ require('../chunk-QEUI6OGE.cjs');
 
 
 var _chunkKIJIONZFcjs = require('../chunk-KIJIONZF.cjs');
-require('../chunk-T2HUQBRC.cjs');
+require('../chunk-DK33HLA2.cjs');
 
 
 

package/dist/chart/index.js

@@ -6,7 +6,7 @@ import {
   CommandRegistry,
   createCommandToolProvider
 } from "../chunk-HAEB3MZD.js";
-import "../chunk-JV7DKLMX.js";
+import "../chunk-KBH6CM3U.js";
 import {
   CATEGORY_REF,
   CHART_UPDATE_PROPERTIES,

package/dist/{chunk-T2HUQBRC.cjs → chunk-DK33HLA2.cjs}

@@ -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 = _nullishCoalesce(_optionalChain([checkOptions, 'optionalAccess', _6 => _6.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 (e7) {
+        await retireRecovery();
+        return null;
+      }
+    },
     restore(recovery) {
       if (!recovery.snapshot) throw _nullishCoalesce(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";
+  }
+  
+};
+var cloneSnapshot = (value) => {
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch (e8) {
+    return value;
+  }
+};
+function createEditorRemoteSync(doc, options) {
+  const debounceMs = _nullishCoalesce(options.debounceMs, () => ( 500));
+  const now = _nullishCoalesce(options.now, () => ( Date.now));
+  let localVersion = _nullishCoalesce(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 >= (_nullishCoalesce(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 _optionalChain([options, 'access', _7 => _7.autosave, 'optionalAccess', _8 => _8.markClean, 'call', _9 => _9()]);
+          } catch (error) {
+            console.error("[remoteSync] autosave.markClean failed:", error);
+          }
+        } else {
+          state = "pending";
+        }
+        _optionalChain([options, 'access', _10 => _10.onSaved, 'optionalCall', _11 => _11({ document: snapshotToSave, version: confirmedVersion })]);
+        emit();
+        return true;
+      } catch (error) {
+        lastError = error;
+        state = "error";
+        _optionalChain([options, 'access', _12 => _12.onError, 'optionalCall', _13 => _13(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();
+    _optionalChain([options, 'access', _14 => _14.onLocalChange, 'optionalCall', _15 => _15({
+      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);
@@ -783,7 +1102,7 @@ function createEditorDocumentStore(options) {
         if (data && Array.isArray(data.items)) {
           items = data.items.filter((item) => item && typeof item.key === "string" && typeof item.kind === "string");
         }
-      } catch (e7) {
+      } catch (e9) {
         items = [];
       }
     }
@@ -892,7 +1211,7 @@ function createDocumentToolProvider(doc, options = {}) {
     annotations: { title: `Get the ${noun} document`, ...READ },
     handler: () => {
       const document = doc.getDocument();
-      const size = _nullishCoalesce(_optionalChain([JSON, 'access', _6 => _6.stringify, 'call', _7 => _7(document), 'optionalAccess', _8 => _8.length]), () => ( 0));
+      const size = _nullishCoalesce(_optionalChain([JSON, 'access', _16 => _16.stringify, 'call', _17 => _17(document), 'optionalAccess', _18 => _18.length]), () => ( 0));
       if (size > maxChars) {
         throw new Error(`The ${noun} document is ${size} characters of JSON, over the ${maxChars} limit for this tool. Use the editor's read tools to look at parts of it.`);
       }
@@ -959,7 +1278,7 @@ function createDocumentToolProvider(doc, options = {}) {
       }),
       annotations: { title: `Save the ${noun}`, ...OVERWRITE },
       handler: async ({ name }) => {
-        const entry = await s.save(doc, _nullishCoalesce(_nullishCoalesce(name, () => ( _optionalChain([options, 'access', _9 => _9.name, 'optionalCall', _10 => _10()]))), () => ( `Untitled ${noun}`)));
+        const entry = await s.save(doc, _nullishCoalesce(_nullishCoalesce(name, () => ( _optionalChain([options, 'access', _19 => _19.name, 'optionalCall', _20 => _20()]))), () => ( `Untitled ${noun}`)));
         return { key: entry.key, name: entry.name, savedAt: entry.savedAt, revision: doc.revision() };
       }
     },
@@ -1044,7 +1363,7 @@ function createDocumentToolProvider(doc, options = {}) {
       load,
       ...options.history === false ? [] : [undo, redo],
       ...store ? storeTools(store) : [],
-      ..._optionalChain([store, 'optionalAccess', _11 => _11.collectAssetGarbage]) && doc.assets ? assetTools(store) : []
+      ..._optionalChain([store, 'optionalAccess', _21 => _21.collectAssetGarbage]) && doc.assets ? assetTools(store) : []
     ]
   };
 }
@@ -1070,4 +1389,6 @@ function createDocumentToolProvider(doc, options = {}) {
 
 
 
-exports.exponentialBackoff = exponentialBackoff; exports.createRecoveryPolicy = createRecoveryPolicy; exports.StorageUnavailableError = StorageUnavailableError; exports.InjectedStorageError = InjectedStorageError; exports.withStorageFailures = withStorageFailures; exports.createMemoryStorage = createMemoryStorage; exports.isLocalStorageAvailable = isLocalStorageAvailable; exports.createLocalStorageAdapter = createLocalStorageAdapter; exports.isIndexedDbAvailable = isIndexedDbAvailable; exports.createIndexedDbAdapter = createIndexedDbAdapter; exports.isOpfsAvailable = isOpfsAvailable; exports.createOpfsAdapter = createOpfsAdapter; exports.recoveryMetaKey = recoveryMetaKey; exports.formatRecoveryMessage = formatRecoveryMessage; exports.createAutosaveController = createAutosaveController; exports.createRevisionTracker = createRevisionTracker; exports.createEditorAutosave = createEditorAutosave; exports.slugifyDocumentName = slugifyDocumentName; exports.createEditorDocumentStore = createEditorDocumentStore; exports.createDocumentToolProvider = createDocumentToolProvider;
+
+
+exports.exponentialBackoff = exponentialBackoff; exports.createRecoveryPolicy = createRecoveryPolicy; exports.StorageUnavailableError = StorageUnavailableError; exports.InjectedStorageError = InjectedStorageError; exports.withStorageFailures = withStorageFailures; exports.createMemoryStorage = createMemoryStorage; exports.isLocalStorageAvailable = isLocalStorageAvailable; exports.createLocalStorageAdapter = createLocalStorageAdapter; exports.isIndexedDbAvailable = isIndexedDbAvailable; exports.createIndexedDbAdapter = createIndexedDbAdapter; exports.isOpfsAvailable = isOpfsAvailable; exports.createOpfsAdapter = createOpfsAdapter; exports.recoveryMetaKey = recoveryMetaKey; exports.formatRecoveryMessage = formatRecoveryMessage; exports.createAutosaveController = createAutosaveController; exports.createRevisionTracker = createRevisionTracker; exports.createEditorAutosave = createEditorAutosave; exports.EditorRemoteConflictError = EditorRemoteConflictError; exports.createEditorRemoteSync = createEditorRemoteSync; exports.slugifyDocumentName = slugifyDocumentName; exports.createEditorDocumentStore = createEditorDocumentStore; exports.createDocumentToolProvider = createDocumentToolProvider;