@bendyline/squisq-editor-react 2.11.14 → 2.11.16

package/dist/{chunk-QY2ZFRJE.js → chunk-5TYCTE33.js}

@@ -33,7 +33,7 @@ import {
   ImageEditor,
   ImageViewer,
   ShapePalette
-} from "./chunk-V44VP242.js";
+} from "./chunk-K4Z2GIX4.js";
 import {
   BlockThumbnail,
   RecorderPanel,
@@ -41,7 +41,7 @@ import {
   documentTitleFromFileName,
   resolveBlockVisual,
   useModalDialog
-} from "./chunk-BJ3TXAIQ.js";
+} from "./chunk-4D7QMRTZ.js";
 import {
   Icon
 } from "./chunk-GS7QWYFT.js";
@@ -1026,7 +1026,7 @@ function VersionHistoryPanel() {
                 }
               ),
               visibleVersions.map((v2) => {
-                const pending = state.pendingRevert !== null && state.pendingRevert.path === v2.path;
+                const pending2 = state.pendingRevert !== null && state.pendingRevert.path === v2.path;
                 const selected = state.selected?.version.path === v2.path;
                 return /* @__PURE__ */ jsxs(
                   "li",
@@ -1054,7 +1054,7 @@ function VersionHistoryPanel() {
                           children: "Revert"
                         }
                       ) }),
-                      pending && /* @__PURE__ */ jsxs("div", { className: "squisq-version-history-confirm", children: [
+                      pending2 && /* @__PURE__ */ jsxs("div", { className: "squisq-version-history-confirm", children: [
                         /* @__PURE__ */ jsx("span", { children: "Revert to this version? Your current draft will be saved as a new snapshot first. Reverting will reset your editor undo state." }),
                         /* @__PURE__ */ jsxs("span", { className: "squisq-version-history-confirm-actions", children: [
                           /* @__PURE__ */ jsx(
@@ -27541,15 +27541,15 @@ async function loadDataPreview(bytes, ext, opts) {
 var previewCache = /* @__PURE__ */ new Map();
 function loadDataPreviewCached(path, revision, load) {
   const key = `${revision}\0${path}`;
-  let pending = previewCache.get(key);
-  if (!pending) {
+  let pending2 = previewCache.get(key);
+  if (!pending2) {
     for (const existing of previewCache.keys()) {
       if (existing.endsWith(`\0${path}`) && existing !== key) previewCache.delete(existing);
     }
-    pending = load();
-    previewCache.set(key, pending);
+    pending2 = load();
+    previewCache.set(key, pending2);
   }
-  return pending;
+  return pending2;
 }
 
 // src/dataCard/ingestAdapters.ts
@@ -27591,20 +27591,25 @@ async function ingestSidecarBytes(bytes, ext, params) {
     };
   }
   if (ext === "xlsx") {
-    const { xlsxToCellGrids, gridToTables, parseCellRef } = await import("@bendyline/squisq-formats/xlsx");
-    const grids = await xlsxToCellGrids(bytes, {
-      ...params.sheet !== void 0 ? { sheet: params.sheet } : {}
-    });
+    const { xlsxToCellGrids, gridToTables, parseCellRef, formatCellRef } = await import("@bendyline/squisq-formats/xlsx");
+    const grids = await xlsxToCellGrids(bytes);
     const bySheet = new Map(grids.sheets.map((sheet) => [sheet.name, sheet]));
-    const tables = grids.sheets.flatMap(
-      (sheet) => gridToTables(sheet.name, sheet.cells, sheet.merges)
-    );
+    const tables = grids.sheets.filter((sheet) => params.sheet === void 0 || sheet.name === params.sheet).flatMap((sheet) => gridToTables(sheet.name, sheet.cells, sheet.merges));
     const table = params.anchor && tables.find((t) => t.anchor.toUpperCase() === params.anchor.toUpperCase()) || tables.reduce(
       (best, candidate) => !best || candidate.rows.length * candidate.columns.length > best.rows.length * best.columns.length ? candidate : best,
       null
     );
     if (!table) throw new Error("no tabular data found in workbook");
     const anchor = parseCellRef(table.anchor);
+    if (params.headerRow === false && table.hasHeader) {
+      table.rows.unshift(table.columns.map((column) => column.name));
+      table.columns = table.columns.map((column, col) => ({
+        ...column,
+        name: formatCellRef(0, (anchor?.col ?? 0) + col).slice(0, -1),
+        kind: "mixed"
+      }));
+      table.hasHeader = false;
+    }
     const sheetGrid = bySheet.get(table.sheet);
     const locked = /* @__PURE__ */ new Set();
     const dateLocked = /* @__PURE__ */ new Set();
@@ -27834,6 +27839,43 @@ import { EMPTY_TABLE_VIEW_STATE } from "@bendyline/squisq/table";
 
 // src/dataCard/gridSave.ts
 import { DATA_BACKUP_PREFIX, buildDataBackupPath } from "@bendyline/squisq/versions";
+
+// src/dataCard/saveSession.ts
+var sessions = /* @__PURE__ */ new WeakMap();
+function withDataSave(options, save) {
+  const owner = options.container ?? options.mediaProvider;
+  let files = sessions.get(owner);
+  if (!files) {
+    files = /* @__PURE__ */ new Map();
+    sessions.set(owner, files);
+  }
+  let session = files.get(options.path);
+  if (!session) {
+    session = { tail: Promise.resolve() };
+    files.set(options.path, session);
+  }
+  const current = session;
+  const result = current.tail.catch(() => void 0).then(async () => {
+    let latest = await options.container?.readFile(options.path);
+    if (!latest && !options.container) {
+      const url = await options.mediaProvider.resolveUrl(options.path);
+      if (url !== options.path) {
+        const response = await fetch(url);
+        if (!response.ok)
+          throw new Error(`Could not read the current file before saving (${response.status})`);
+        latest = await response.arrayBuffer();
+      }
+    }
+    const baseline = latest ?? current.bytes ?? options.originalBytes;
+    const saved = await save(baseline);
+    if (saved.ok && saved.bytes) current.bytes = saved.bytes;
+    return saved;
+  });
+  current.tail = result;
+  return result;
+}
+
+// src/dataCard/gridSave.ts
 var BACKUPS_KEPT_PER_SIDECAR = 3;
 var FORMULA_PREFIX = /^[\t\r\n \uFEFF]*[=+\-@]/;
 function renderCell(value) {
@@ -27856,96 +27898,111 @@ async function backupOriginal(container, path, original, mime) {
   }
 }
 async function saveCsvEdits(options) {
-  const { path, originalBytes, csv, journal, mediaProvider, container } = options;
-  const notices = [];
-  const mime = path.toLowerCase().endsWith(".tsv") ? "text/tab-separated-values" : "text/csv";
-  try {
-    if (container) {
-      await backupOriginal(container, path, originalBytes, mime);
-    } else {
-      notices.push("no workspace container \u2014 saved without a backup copy");
-    }
-    const rows = csv.rows.map((row) => [...row]);
-    const offset = csv.hasHeader ? 1 : 0;
-    for (const entry of journal.entries()) {
-      const targetRow = entry.rowId + offset;
-      while (rows.length <= targetRow) rows.push([]);
-      const row = rows[targetRow];
-      while (row.length <= entry.col) row.push("");
-      row[entry.col] = neutralizeEdited(renderCell(entry.next));
-    }
-    const { serializeCsvRows } = await import("@bendyline/squisq-formats/csv");
-    const text = serializeCsvRows(rows, {
-      delimiter: csv.delimiter,
-      newline: csv.newline,
-      trailingNewline: csv.trailingNewline,
-      formulaHandling: "preserve"
-    });
-    const bytes = new TextEncoder().encode(csv.bom ? `\uFEFF${text}` : text).buffer;
-    const savedPath = await mediaProvider.addMedia(path, bytes, mime);
-    if (savedPath !== path) {
+  const { path, csv, journal, mediaProvider, container } = options;
+  const snapshot = journal.entries();
+  return withDataSave(options, async (originalBytes) => {
+    const notices = [];
+    const mime = path.toLowerCase().endsWith(".tsv") ? "text/tab-separated-values" : "text/csv";
+    try {
+      if (container) {
+        await backupOriginal(container, path, originalBytes, mime);
+      } else {
+        notices.push("no workspace container \u2014 saved without a backup copy");
+      }
+      const { parseCsv, serializeCsvRows } = await import("@bendyline/squisq-formats/csv");
+      const rows = parseCsv(new TextDecoder().decode(originalBytes), csv.delimiter);
+      const offset = csv.hasHeader ? 1 : 0;
+      for (const entry of snapshot) {
+        const targetRow = entry.rowId + offset;
+        while (rows.length <= targetRow) rows.push([]);
+        const row = rows[targetRow];
+        while (row.length <= entry.col) row.push("");
+        row[entry.col] = neutralizeEdited(renderCell(entry.next));
+      }
+      const text = serializeCsvRows(rows, {
+        delimiter: csv.delimiter,
+        newline: csv.newline,
+        trailingNewline: csv.trailingNewline,
+        formulaHandling: "preserve"
+      });
+      const bytes = new TextEncoder().encode(csv.bom ? `\uFEFF${text}` : text).buffer;
+      const savedPath = await mediaProvider.addMedia(path, bytes, mime);
+      if (savedPath !== path) {
+        return {
+          ok: false,
+          savedPath,
+          notices,
+          error: `the host saved a copy at "${savedPath}" instead of overwriting "${path}" \u2014 the document still references the original`
+        };
+      }
+      journal.acknowledge(snapshot);
+      return { ok: true, savedPath, notices, bytes };
+    } catch (err) {
       return {
         ok: false,
-        savedPath,
         notices,
-        error: `the host saved a copy at "${savedPath}" instead of overwriting "${path}" \u2014 the document still references the original`
+        error: err instanceof Error ? err.message : String(err)
       };
     }
-    journal.clear();
-    return { ok: true, savedPath, notices };
-  } catch (err) {
-    return {
-      ok: false,
-      notices,
-      error: err instanceof Error ? err.message : String(err)
-    };
-  }
+  }).catch((error) => ({
+    ok: false,
+    notices: [],
+    error: error instanceof Error ? error.message : String(error)
+  }));
 }
 var XLSX_MIME = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
 async function saveXlsxEdits(options) {
-  const { path, originalBytes, xlsx, journal, formulaEdits, mediaProvider, container } = options;
-  const notices = [];
-  try {
-    if (container) {
-      await backupOriginal(container, path, originalBytes, XLSX_MIME);
-    } else {
-      notices.push("no workspace container \u2014 saved without a backup copy");
-    }
-    const { patchXlsxCellValues, formatCellRef } = await import("@bendyline/squisq-formats/xlsx");
-    const bodyTop = xlsx.anchorRow + (xlsx.hasHeader ? 1 : 0);
-    const patches = journal.entries().map((entry) => ({
-      sheet: xlsx.sheet,
-      ref: formatCellRef(bodyTop + entry.rowId, xlsx.anchorCol + entry.col),
-      value: entry.next
-    }));
-    for (const [key, record] of formulaEdits ?? []) {
-      const [row, col] = key.split(":").map(Number);
-      patches.push({
+  const { path, xlsx, journal, mediaProvider, container } = options;
+  const snapshot = journal.entries();
+  const formulaEdits = new Map(options.formulaEdits);
+  return withDataSave(options, async (originalBytes) => {
+    const notices = [];
+    try {
+      if (container) {
+        await backupOriginal(container, path, originalBytes, XLSX_MIME);
+      } else {
+        notices.push("no workspace container \u2014 saved without a backup copy");
+      }
+      const { patchXlsxCellValues, formatCellRef } = await import("@bendyline/squisq-formats/xlsx");
+      const bodyTop = xlsx.anchorRow + (xlsx.hasHeader ? 1 : 0);
+      const patches = snapshot.filter((entry) => !formulaEdits.has(`${entry.rowId}:${entry.col}`)).map((entry) => ({
         sheet: xlsx.sheet,
-        ref: formatCellRef(bodyTop + row, xlsx.anchorCol + col),
-        formula: record.formula,
-        ...record.cachedValue !== void 0 ? { cachedValue: record.cachedValue } : {}
-      });
-    }
-    const bytes = await patchXlsxCellValues(originalBytes, patches);
-    const savedPath = await mediaProvider.addMedia(path, bytes, XLSX_MIME);
-    if (savedPath !== path) {
+        ref: formatCellRef(bodyTop + entry.rowId, xlsx.anchorCol + entry.col),
+        value: entry.next
+      }));
+      for (const [key, record] of formulaEdits ?? []) {
+        const [row, col] = key.split(":").map(Number);
+        patches.push({
+          sheet: xlsx.sheet,
+          ref: formatCellRef(bodyTop + row, xlsx.anchorCol + col),
+          ...record.formula === null ? { value: record.value ?? null, removeFormula: true } : { formula: record.formula },
+          ...record.cachedValue !== void 0 ? { cachedValue: record.cachedValue } : {}
+        });
+      }
+      const bytes = await patchXlsxCellValues(originalBytes, patches);
+      const savedPath = await mediaProvider.addMedia(path, bytes, XLSX_MIME);
+      if (savedPath !== path) {
+        return {
+          ok: false,
+          savedPath,
+          notices,
+          error: `the host saved a copy at "${savedPath}" instead of overwriting "${path}" \u2014 the document still references the original`
+        };
+      }
+      journal.acknowledge(snapshot);
+      return { ok: true, savedPath, notices, bytes };
+    } catch (err) {
       return {
         ok: false,
-        savedPath,
         notices,
-        error: `the host saved a copy at "${savedPath}" instead of overwriting "${path}" \u2014 the document still references the original`
+        error: err instanceof Error ? err.message : String(err)
       };
     }
-    journal.clear();
-    return { ok: true, savedPath, notices };
-  } catch (err) {
-    return {
-      ok: false,
-      notices,
-      error: err instanceof Error ? err.message : String(err)
-    };
-  }
+  }).catch((error) => ({
+    ok: false,
+    notices: [],
+    error: error instanceof Error ? error.message : String(error)
+  }));
 }
 
 // src/dataCard/formulaSupport.ts
@@ -28002,8 +28059,15 @@ async function createXlsxFormulaSession(meta, options = {}) {
       engine = calc.createInHouseEngine(engineConfig);
     }
   }
-  await engine.loadWorkbook(buildSeed(calc, meta));
-  const initial = await engine.evaluateAll();
+  const initial = await (async () => {
+    try {
+      await engine.loadWorkbook(buildSeed(calc, meta));
+      return await engine.evaluateAll();
+    } catch (error) {
+      engine.dispose();
+      throw error;
+    }
+  })();
   if (initial.status === "budget-exceeded") {
     engine.dispose();
     return null;
@@ -28015,7 +28079,7 @@ async function createXlsxFormulaSession(meta, options = {}) {
     col: meta.anchorCol + col
   });
   const formulas = new Map(meta.formulas);
-  const edits = /* @__PURE__ */ new Map();
+  const edits = options.edits ?? /* @__PURE__ */ new Map();
   let disposed = false;
   const readValues = async (keys) => {
     const coords = keys.map((key) => key.split(":").map(Number));
@@ -28032,6 +28096,13 @@ async function createXlsxFormulaSession(meta, options = {}) {
     const updates = [];
     keyList.forEach((key, index2) => {
       const raw = states[index2].value;
+      const formula = formulas.get(key);
+      if (formula !== void 0 && (edits.has(key) || before.get(key) !== displayValue(calc, raw))) {
+        edits.set(key, {
+          formula,
+          ...!calc.isCalcError(raw) && raw !== null ? { cachedValue: raw } : {}
+        });
+      }
       if (calc.isCalcError(raw) && raw.code === "#NAME?") return;
       const value = displayValue(calc, raw);
       if (before.get(key) !== value) {
@@ -28041,7 +28112,13 @@ async function createXlsxFormulaSession(meta, options = {}) {
     });
     return updates;
   };
-  return {
+  let mutationTail = Promise.resolve();
+  const serial = (operation) => {
+    const result = mutationTail.catch(() => void 0).then(operation);
+    mutationTail = result;
+    return result;
+  };
+  const session = {
     getFormula: (bodyRow, col) => formulas.get(`${bodyRow}:${col}`),
     isCellLocked: (bodyRow, col) => {
       const key = `${bodyRow}:${col}`;
@@ -28095,7 +28172,8 @@ async function createXlsxFormulaSession(meta, options = {}) {
       if (disposed) return [];
       const key = `${bodyRow}:${col}`;
       formulas.delete(key);
-      edits.delete(key);
+      if (meta.formulas.has(key)) edits.set(key, { formula: null, value });
+      else edits.delete(key);
       const before = await snapshotRegion();
       engine.setCellValue(toAddress(bodyRow, col), value);
       const result = await engine.evaluateAll();
@@ -28105,7 +28183,7 @@ async function createXlsxFormulaSession(meta, options = {}) {
     get dirtyCount() {
       return edits.size;
     },
-    formulaEdits: () => edits,
+    formulaEdits: () => new Map(edits),
     async discard() {
       const before = await snapshotRegion();
       const staleKeys = new Set(formulas.keys());
@@ -28115,29 +28193,49 @@ async function createXlsxFormulaSession(meta, options = {}) {
       await engine.loadWorkbook(buildSeed(calc, meta));
       await engine.evaluateAll();
       for (const key of formulas.keys()) staleKeys.add(key);
-      return diffAgainst(before, staleKeys);
-    },
-    markSaved() {
+      const updates = await diffAgainst(before, staleKeys);
       edits.clear();
+      return updates;
+    },
+    markSaved(snapshot = new Map(edits), baseline) {
+      if (baseline) meta = baseline;
+      for (const [key, record] of snapshot) {
+        if (edits.get(key) === record) edits.delete(key);
+      }
     },
     dispose() {
       disposed = true;
       engine.dispose();
+    },
+    flush: async () => {
+      await mutationTail;
     }
   };
+  return {
+    ...session,
+    get dirtyCount() {
+      return session.dirtyCount;
+    },
+    commitFormula: (...args) => serial(() => session.commitFormula(...args)),
+    noteValueEdit: (...args) => serial(() => session.noteValueEdit(...args)),
+    discard: () => serial(() => session.discard())
+  };
 }
 
-// src/dataCard/DataCardWidget.tsx
-import { jsx as jsx54, jsxs as jsxs43 } from "react/jsx-runtime";
-var XLSX_SESSION_LOCKED_REASON = "Date cells and shared-formula masters stay locked; other formulas are editable";
-var gridModulePromise = null;
+// src/dataCard/loadGridModule.ts
+var pending = null;
 function loadGridModule() {
-  gridModulePromise ?? (gridModulePromise = import("@bendyline/squisq-grid-react").catch(() => {
-    gridModulePromise = null;
+  pending ?? (pending = import("@bendyline/squisq-grid-react").catch(() => {
+    pending = null;
     return null;
   }));
-  return gridModulePromise;
+  return pending;
 }
+
+// src/dataCard/DataCardWidget.tsx
+import { jsx as jsx54, jsxs as jsxs43 } from "react/jsx-runtime";
+var XLSX_SESSION_LOCKED_REASON = "Date cells and shared-formula masters stay locked; other formulas are editable";
+var pendingFormulas = /* @__PURE__ */ new WeakMap();
 function useCardLink(editor, blockId) {
   const [version, setVersion] = useState47(0);
   useEffect38(() => {
@@ -28190,14 +28288,23 @@ function DataCardWidget({
   const [view, setView] = useState47(EMPTY_TABLE_VIEW_STATE);
   const [viewPersisted, setViewPersisted] = useState47(false);
   const [saving, setSaving] = useState47(false);
+  const savingRef = useRef39(false);
   const [saveNotice, setSaveNotice] = useState47(null);
   const [formulaDirty, setFormulaDirty] = useState47(0);
   const gridRef = useRef39(null);
   const href = link?.href ?? null;
   const cardPos = link?.pos ?? null;
+  const activeProvider = getMediaProvider();
+  const activeContainer = getContainer?.() ?? null;
+  const regionParams = href && cardPos !== null ? readHeadingViewBinding(editor, cardPos, href).params : {};
+  const regionIdentity = JSON.stringify([
+    regionParams.sheet,
+    regionParams.anchor,
+    regionParams.headerRow
+  ]);
   useEffect38(() => {
     if (!href || cardPos === null) return;
-    const provider = getMediaProvider();
+    const provider = activeProvider;
     if (!provider) {
       setState3({ kind: "meta", size: null, preview: null });
       return;
@@ -28206,6 +28313,9 @@ function DataCardWidget({
     setState3({ kind: "loading" });
     void (async () => {
       let size2 = null;
+      let loadingStore = null;
+      let loadingSession = null;
+      let retained = false;
       try {
         const entries = await provider.listMedia();
         const entry = entries.find((e2) => e2.name === href);
@@ -28249,26 +28359,61 @@ function DataCardWidget({
             ...binding.params.headerRow !== void 0 ? { headerRow: binding.params.headerRow !== "false" } : {}
           });
           if (cancelled) return;
+          const container = activeContainer;
+          const region = JSON.stringify(
+            ingested.xlsx ? [
+              ingested.xlsx.sheet,
+              ingested.xlsx.anchorRow,
+              ingested.xlsx.anchorCol,
+              ingested.xlsx.hasHeader
+            ] : [ingested.csv?.hasHeader ?? true]
+          );
+          const journal = module.journalFor(href, revision, {
+            owner: container ?? provider,
+            region
+          });
+          let formulaEdits = pendingFormulas.get(journal);
+          if (!formulaEdits) {
+            formulaEdits = /* @__PURE__ */ new Map();
+            pendingFormulas.set(journal, formulaEdits);
+          }
+          const restoredFormulas = new Map(formulaEdits);
           let formulaSession = null;
           if (ingested.xlsx) {
             try {
               const engineFactory = getCalcEngineFactory?.();
-              formulaSession = await createXlsxFormulaSession(
-                ingested.xlsx,
-                engineFactory ? { engineFactory } : {}
-              );
+              formulaSession = await createXlsxFormulaSession(ingested.xlsx, {
+                ...engineFactory ? { engineFactory } : {},
+                edits: formulaEdits
+              });
+              loadingSession = formulaSession;
             } catch {
               formulaSession = null;
             }
           }
           if (cancelled) {
-            formulaSession?.dispose();
             return;
           }
-          gridRef.current?.formulaSession?.dispose();
-          gridRef.current?.provider.dispose();
           const storeProvider = new module.TableStoreClient(ingested.ingest);
-          const journal = module.journalFor(href, revision);
+          loadingStore = storeProvider;
+          await storeProvider.describe();
+          const restoredValues = journal.entries().map(({ rowId, col, next }) => ({ rowId, col, value: next }));
+          if (restoredValues.length) await storeProvider.applyEdits(restoredValues);
+          if (formulaSession) {
+            for (const edit of restoredValues) {
+              if (restoredFormulas.has(`${edit.rowId}:${edit.col}`)) continue;
+              const updates = await formulaSession.noteValueEdit(edit.rowId, edit.col, edit.value);
+              if (updates.length) await storeProvider.applyEdits(updates);
+            }
+            for (const [key, record] of restoredFormulas) {
+              const [row, col] = key.split(":").map(Number);
+              const updates = record.formula === null ? await formulaSession.noteValueEdit(row, col, record.value ?? null) : (await formulaSession.commitFormula(row, col, record.formula)).updates ?? [];
+              if (updates.length) await storeProvider.applyEdits(updates);
+            }
+          }
+          if (cancelled) {
+            return;
+          }
           const grid2 = {
             module,
             provider: storeProvider,
@@ -28276,13 +28421,19 @@ function DataCardWidget({
             ingested,
             bytes,
             headers: ingested.ingest.headers,
-            formulaSession
+            formulaSession,
+            mediaProvider: provider,
+            container,
+            path: href
           };
+          gridRef.current?.formulaSession?.dispose();
+          gridRef.current?.provider.dispose();
           gridRef.current = grid2;
+          retained = true;
           setView(viewStateFromBinding(binding, ingested.ingest.headers));
           setViewPersisted(binding.persisted);
           setSaveNotice(null);
-          setFormulaDirty(0);
+          setFormulaDirty(formulaSession?.dirtyCount ?? 0);
           setState3({ kind: "grid", size: size2, grid: grid2 });
           return;
         }
@@ -28302,12 +28453,17 @@ function DataCardWidget({
             reason: err instanceof Error ? err.message : String(err)
           });
         }
+      } finally {
+        if (!retained) {
+          loadingStore?.dispose();
+          loadingSession?.dispose();
+        }
       }
     })();
     return () => {
       cancelled = true;
     };
-  }, [href, revision, getMediaProvider, editor]);
+  }, [href, revision, activeProvider, activeContainer, regionIdentity, editor]);
   useEffect38(
     () => () => {
       gridRef.current?.formulaSession?.dispose();
@@ -28327,34 +28483,61 @@ function DataCardWidget({
   );
   const handleSave = useCallback36(async () => {
     const grid2 = gridRef.current;
-    const provider = getMediaProvider();
+    const provider = grid2?.mediaProvider;
     if (!grid2 || !provider || !href || !grid2.ingested.csv && !grid2.ingested.xlsx) return;
+    if (savingRef.current) return;
+    savingRef.current = true;
     setSaving(true);
     try {
+      await grid2.formulaSession?.flush();
       const shared = {
-        path: href,
+        path: grid2.path,
         originalBytes: grid2.bytes,
         journal: grid2.journal,
         mediaProvider: provider,
-        container: getContainer?.() ?? null
+        container: grid2.container
       };
+      const formulaSnapshot = grid2.formulaSession?.formulaEdits();
       const result = grid2.ingested.csv ? await saveCsvEdits({ ...shared, csv: grid2.ingested.csv }) : await saveXlsxEdits({
         ...shared,
         xlsx: grid2.ingested.xlsx,
-        ...grid2.formulaSession ? { formulaEdits: grid2.formulaSession.formulaEdits() } : {}
+        ...formulaSnapshot ? { formulaEdits: formulaSnapshot } : {}
       });
-      setSaveNotice(
-        result.ok ? result.notices.length > 0 ? `saved (${result.notices.join("; ")})` : null : result.error ?? "save failed"
-      );
+      if (gridRef.current === grid2)
+        setSaveNotice(
+          result.ok ? result.notices.length > 0 ? `saved (${result.notices.join("; ")})` : null : result.error ?? "save failed"
+        );
       if (result.ok) {
-        gridRef.current?.formulaSession?.markSaved();
-        setFormulaDirty(0);
-        onMediaSaved?.();
+        if (result.bytes) {
+          grid2.bytes = result.bytes;
+          const baseline = await ingestSidecarBytes(
+            result.bytes,
+            dataExtensionOf(grid2.path),
+            grid2.ingested.xlsx ? {
+              sheet: grid2.ingested.xlsx.sheet,
+              anchor: (await import("@bendyline/squisq-formats/xlsx")).formatCellRef(
+                grid2.ingested.xlsx.anchorRow,
+                grid2.ingested.xlsx.anchorCol
+              ),
+              headerRow: grid2.ingested.xlsx.hasHeader
+            } : { headerRow: grid2.ingested.csv?.hasHeader }
+          );
+          grid2.ingested = baseline;
+        }
+        grid2.formulaSession?.markSaved(formulaSnapshot, grid2.ingested.xlsx);
+        if (gridRef.current === grid2) {
+          setFormulaDirty(grid2.formulaSession?.dirtyCount ?? 0);
+          onMediaSaved?.();
+        }
       }
+    } catch (error) {
+      if (gridRef.current === grid2)
+        setSaveNotice(error instanceof Error ? error.message : String(error));
     } finally {
+      savingRef.current = false;
       setSaving(false);
     }
-  }, [getContainer, getMediaProvider, href, onMediaSaved]);
+  }, [href, onMediaSaved]);
   if (!link || !href) return null;
   const fileName = href.split("/").pop() ?? href;
   const size = state.kind === "meta" || state.kind === "grid" ? state.size : null;
@@ -34764,8 +34947,8 @@ function playTimelineMediaAt(root, time) {
     const end = Number(el.dataset.absEnd);
     if (!Number.isFinite(start) || !Number.isFinite(end) || time < start || time >= end) return;
     try {
-      const pending = el.play();
-      pending?.catch(() => {
+      const pending2 = el.play();
+      pending2?.catch(() => {
       });
     } catch {
     }
@@ -37836,7 +38019,6 @@ import {
   useState as useState68
 } from "react";
 import { parseTableViewState as parseTableViewState2 } from "@bendyline/squisq/table";
-import { DataGrid, TableStoreClient } from "@bendyline/squisq-grid-react";
 
 // src/slideshow/slideshowDataSources.ts
 import { isDataFilePath as isDataFilePath2, resolveTemplateName as resolveTemplateName3 } from "@bendyline/squisq/doc";
@@ -37938,8 +38120,18 @@ function SlideshowDataGridRenderer({
   const source = sourceForBlock(sources, block);
   const activeSourceKey = sourceKey(source);
   const [remote, setRemote] = useState68({ key: "", status: "idle" });
+  const [gridModule, setGridModule] = useState68(null);
   useEffect59(() => {
-    if (!container || !source) {
+    let active = true;
+    void loadGridModule().then((module) => {
+      if (active) setGridModule(module);
+    });
+    return () => {
+      active = false;
+    };
+  }, []);
+  useEffect59(() => {
+    if (!container || !source || !gridModule) {
       setRemote({ key: activeSourceKey, status: "idle" });
       return;
     }
@@ -37955,7 +38147,8 @@ function SlideshowDataGridRenderer({
           ...source.anchor ? { anchor: source.anchor } : {},
           ...source.headerRow !== void 0 ? { headerRow: source.headerRow } : {}
         });
-        const provider2 = new TableStoreClient(ingest2);
+        if (cancelled) return;
+        const provider2 = new gridModule.TableStoreClient(ingest2);
         ownedProvider = provider2;
         await provider2.describe();
         if (cancelled) {
@@ -37973,7 +38166,7 @@ function SlideshowDataGridRenderer({
       cancelled = true;
       ownedProvider?.dispose();
     };
-  }, [activeSourceKey, container, mediaRevision]);
+  }, [activeSourceKey, container, mediaRevision, gridModule]);
   const currentRemote = remote.key === activeSourceKey ? remote : void 0;
   const previewRows = useMemo52(
     () => Array.isArray(layer.content.rows) ? layer.content.rows : [],
@@ -37985,8 +38178,8 @@ function SlideshowDataGridRenderer({
   );
   const useLocalGrid = (!source || currentRemote?.status === "error") && previewRows.length > (layer.content.maxVisibleRows ?? 10);
   const localProvider = useMemo52(
-    () => useLocalGrid ? new TableStoreClient({ headers: previewHeaders, cells: previewRows }) : null,
-    [previewHeaders, previewRows, useLocalGrid]
+    () => useLocalGrid && gridModule ? new gridModule.TableStoreClient({ headers: previewHeaders, cells: previewRows }) : null,
+    [previewHeaders, previewRows, useLocalGrid, gridModule]
   );
   useEffect59(() => () => localProvider?.dispose(), [localProvider]);
   const ready = currentRemote?.status === "ready" ? currentRemote : void 0;
@@ -37995,7 +38188,7 @@ function SlideshowDataGridRenderer({
   const initialView = ready?.initialView ?? EMPTY_VIEW;
   const [view, setView] = useState68(initialView);
   useEffect59(() => setView(initialView), [initialView, provider]);
-  if (!provider || !ingest) return /* @__PURE__ */ jsx77(Fragment22, { children: fallback });
+  if (!provider || !ingest || !gridModule) return /* @__PURE__ */ jsx77(Fragment22, { children: fallback });
   const { style } = layer.content;
   const rowHeight = Math.max(32, style.fontSize * 2.1);
   const footerHeight = Math.max(28, style.fontSize * 1.5);
@@ -38025,7 +38218,7 @@ function SlideshowDataGridRenderer({
     "--squisq-grid-resize-handle": style.headerBackground
   };
   return /* @__PURE__ */ jsx77("div", { className: "squisq-slideshow-data-grid", style: gridStyle, children: /* @__PURE__ */ jsx77(
-    DataGrid,
+    gridModule.DataGrid,
     {
       provider,
       view,