@devmm/puredocs-excel 1.0.6 → 1.0.8

package/dist/index.js

@@ -1,4 +1,4 @@
-import { unzipSync, zipSync } from 'fflate';
+import { unzipSync, zipSync, deflateSync, deflate } from 'fflate';
 
 var __typeError = (msg) => {
   throw TypeError(msg);
@@ -194,6 +194,124 @@ function listEntries(entries, prefix) {
   }
   return results.sort();
 }
+
+// src/io/zip-container.ts
+var LOCAL_HEADER = 67324752;
+var CENTRAL_HEADER = 33639248;
+var END_OF_CENTRAL_DIR = 101010256;
+var DOS_DATE = 33;
+var DOS_TIME = 0;
+var MAX_ENTRIES = 65535;
+var MAX_BYTES = 4294967295;
+var CRC_TABLE = (() => {
+  const table = new Int32Array(256);
+  for (let i = 0; i < 256; i++) {
+    let c = i;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    table[i] = c;
+  }
+  return table;
+})();
+function crc32(data) {
+  let c = -1;
+  for (let i = 0; i < data.length; i++) {
+    c = c >>> 8 ^ CRC_TABLE[(c ^ data[i]) & 255];
+  }
+  return (c ^ -1) >>> 0;
+}
+function exceedsZipLimits(parts) {
+  if (parts.length > MAX_ENTRIES) return true;
+  let total = 0;
+  for (const p of parts) {
+    total += 30 + utf8Length(p.name) * 2 + 46 + p.deflated.length;
+    if (total > MAX_BYTES || p.rawSize > MAX_BYTES) return true;
+  }
+  return false;
+}
+function buildZipContainer(parts) {
+  const names = parts.map((p) => encodeName(p.name));
+  let localSize = 0;
+  let centralSize = 0;
+  for (let i = 0; i < parts.length; i++) {
+    localSize += 30 + names[i].bytes.length + parts[i].deflated.length;
+    centralSize += 46 + names[i].bytes.length;
+  }
+  const out = new Uint8Array(localSize + centralSize + 22);
+  const view = new DataView(out.buffer);
+  const offsets = [];
+  let at = 0;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    const name = names[i];
+    offsets.push(at);
+    view.setUint32(at, LOCAL_HEADER, true);
+    view.setUint16(at + 4, 20, true);
+    view.setUint16(at + 6, name.utf8Flag, true);
+    view.setUint16(at + 8, 8, true);
+    view.setUint16(at + 10, DOS_TIME, true);
+    view.setUint16(at + 12, DOS_DATE, true);
+    view.setUint32(at + 14, part.crc, true);
+    view.setUint32(at + 18, part.deflated.length, true);
+    view.setUint32(at + 22, part.rawSize, true);
+    view.setUint16(at + 26, name.bytes.length, true);
+    view.setUint16(at + 28, 0, true);
+    at += 30;
+    out.set(name.bytes, at);
+    at += name.bytes.length;
+    out.set(part.deflated, at);
+    at += part.deflated.length;
+  }
+  const centralStart = at;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    const name = names[i];
+    view.setUint32(at, CENTRAL_HEADER, true);
+    view.setUint16(at + 4, 20, true);
+    view.setUint16(at + 6, 20, true);
+    view.setUint16(at + 8, name.utf8Flag, true);
+    view.setUint16(at + 10, 8, true);
+    view.setUint16(at + 12, DOS_TIME, true);
+    view.setUint16(at + 14, DOS_DATE, true);
+    view.setUint32(at + 16, part.crc, true);
+    view.setUint32(at + 20, part.deflated.length, true);
+    view.setUint32(at + 24, part.rawSize, true);
+    view.setUint16(at + 28, name.bytes.length, true);
+    view.setUint16(at + 30, 0, true);
+    view.setUint16(at + 32, 0, true);
+    view.setUint16(at + 34, 0, true);
+    view.setUint16(at + 36, 0, true);
+    view.setUint32(at + 38, 0, true);
+    view.setUint32(at + 42, offsets[i], true);
+    at += 46;
+    out.set(name.bytes, at);
+    at += name.bytes.length;
+  }
+  view.setUint32(at, END_OF_CENTRAL_DIR, true);
+  view.setUint16(at + 4, 0, true);
+  view.setUint16(at + 6, 0, true);
+  view.setUint16(at + 8, parts.length, true);
+  view.setUint16(at + 10, parts.length, true);
+  view.setUint32(at + 12, at - centralStart, true);
+  view.setUint32(at + 16, centralStart, true);
+  view.setUint16(at + 20, 0, true);
+  return out;
+}
+function encodeName(name) {
+  const bytes = new TextEncoder().encode(name);
+  let ascii = true;
+  for (let i = 0; i < bytes.length; i++) {
+    if (bytes[i] > 127) {
+      ascii = false;
+      break;
+    }
+  }
+  return { bytes, utf8Flag: ascii ? 0 : 2048 };
+}
+function utf8Length(name) {
+  return new TextEncoder().encode(name).length;
+}
+
+// src/io/zip-writer.ts
 function zipXlsx(entries) {
   const zippable = {};
   for (const [path, content] of entries) {
@@ -208,6 +326,95 @@ function zipXlsx(entries) {
     );
   }
 }
+var ASYNC_MIN_BYTES = 512 * 1024;
+function createDeflateCache() {
+  return /* @__PURE__ */ new Map();
+}
+function compress(name, source, bytes) {
+  return {
+    name,
+    source,
+    deflated: deflateSync(bytes, { level: 6 }),
+    crc: crc32(bytes),
+    rawSize: bytes.length
+  };
+}
+function zipXlsxCached(entries, cache) {
+  const parts = collectParts(entries, cache);
+  pruneCache(entries, cache);
+  return exceedsZipLimits(parts) ? zipXlsx(entries) : buildZipContainer(parts);
+}
+async function zipXlsxCachedAsync(entries, cache) {
+  const order = [];
+  const ready = /* @__PURE__ */ new Map();
+  const jobs = [];
+  const todo = [];
+  let todoBytes = 0;
+  for (const [path, content] of entries) {
+    order.push(path);
+    const cached = cache.get(path);
+    if (cached && cached.source === content) {
+      ready.set(path, cached);
+      continue;
+    }
+    const bytes = typeof content === "string" ? encodeUtf8(content) : content;
+    todo.push({ path, content, bytes });
+    todoBytes += bytes.length;
+  }
+  if (todoBytes <= ASYNC_MIN_BYTES) {
+    for (const { path, content, bytes } of todo) {
+      const compressed = compress(path, content, bytes);
+      cache.set(path, compressed);
+      ready.set(path, compressed);
+    }
+  } else {
+    for (const { path, content, bytes } of todo) {
+      jobs.push(deflateAsync(bytes).then((deflated) => ({
+        name: path,
+        source: content,
+        deflated,
+        crc: crc32(bytes),
+        rawSize: bytes.length
+      })));
+    }
+  }
+  for (const part of await Promise.all(jobs)) {
+    cache.set(part.name, part);
+    ready.set(part.name, part);
+  }
+  pruneCache(entries, cache);
+  const parts = order.map((path) => ready.get(path));
+  return exceedsZipLimits(parts) ? zipXlsx(entries) : buildZipContainer(parts);
+}
+function deflateAsync(bytes) {
+  return new Promise((resolve, reject) => {
+    deflate(bytes, { level: 6 }, (err, data) => {
+      if (err) reject(new Error(`Failed to create xlsx: ${err.message}`));
+      else resolve(data);
+    });
+  });
+}
+function collectParts(entries, cache) {
+  const parts = [];
+  for (const [path, content] of entries) {
+    const cached = cache.get(path);
+    if (cached && cached.source === content) {
+      parts.push(cached);
+      continue;
+    }
+    const bytes = typeof content === "string" ? encodeUtf8(content) : content;
+    const part = compress(path, content, bytes);
+    cache.set(path, part);
+    parts.push(part);
+  }
+  return parts;
+}
+function pruneCache(entries, cache) {
+  if (cache.size === entries.size) return;
+  for (const path of [...cache.keys()]) {
+    if (!entries.has(path)) cache.delete(path);
+  }
+}
 function setXmlEntry(entries, path, xml2) {
   entries.set(path, xml2);
 }
@@ -300,7 +507,8 @@ var REL_TYPES = {
   drawing: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing",
   hyperlink: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink",
   comments: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments",
-  vmlDrawing: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing"
+  vmlDrawing: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing",
+  calcChain: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/calcChain"
 };
 var CONTENT_TYPES = {
   workbook: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml",
@@ -312,7 +520,8 @@ var CONTENT_TYPES = {
   relationships: "application/vnd.openxmlformats-package.relationships+xml",
   coreProperties: "application/vnd.openxmlformats-package.core-properties+xml",
   comments: "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml",
-  vmlDrawing: "application/vnd.openxmlformats-officedocument.vmlDrawing"
+  vmlDrawing: "application/vnd.openxmlformats-officedocument.vmlDrawing",
+  calcChain: "application/vnd.openxmlformats-officedocument.spreadsheetml.calcChain+xml"
 };
 
 // src/io/ooxml-templates.ts
@@ -345,18 +554,20 @@ var ROOT_RELS = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
   <Relationship Id="rId1" Type="${REL_TYPES.officeDocument}" Target="xl/workbook.xml"/>
 </Relationships>`;
-function buildWorkbookRels(sheetCount) {
+function buildWorkbookRels(sheetCount, includeCalcChain = false) {
   const sheetRels = Array.from(
     { length: sheetCount },
     (_, i) => `  <Relationship Id="rId${i + 1}" Type="${REL_TYPES.worksheet}" Target="worksheets/sheet${i + 1}.xml"/>`
   ).join("\n");
   const stylesId = sheetCount + 1;
   const sharedId = sheetCount + 2;
+  const calcChainRel = includeCalcChain ? `
+  <Relationship Id="rId${sheetCount + 3}" Type="${REL_TYPES.calcChain}" Target="calcChain.xml"/>` : "";
   return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
 ${sheetRels}
   <Relationship Id="rId${stylesId}" Type="${REL_TYPES.styles}" Target="styles.xml"/>
-  <Relationship Id="rId${sharedId}" Type="${REL_TYPES.sharedStrings}" Target="sharedStrings.xml"/>
+  <Relationship Id="rId${sharedId}" Type="${REL_TYPES.sharedStrings}" Target="sharedStrings.xml"/>${calcChainRel}
 </Relationships>`;
 }
 function buildWorkbookXml(sheets, definedNames = []) {
@@ -961,8 +1172,12 @@ var ExcelBorderEdge = class _ExcelBorderEdge {
   cacheKey() {
     return `${this.style}:${this.color?.toString() ?? "null"}`;
   }
+  /** An independent copy. ExcelColor is immutable, so it is shared. */
+  clone() {
+    return new _ExcelBorderEdge(this.style, this.color);
+  }
 };
-var _ExcelBorder = class _ExcelBorder {
+var ExcelBorder = class _ExcelBorder {
   constructor() {
     this.left = new ExcelBorderEdge();
     this.right = new ExcelBorderEdge();
@@ -1002,6 +1217,33 @@ var _ExcelBorder = class _ExcelBorder {
     b.right = new ExcelBorderEdge(style, color);
     return b;
   }
+  /**
+   * A border with no edges set.
+   *
+   * A fresh instance per access, not a shared singleton. `ExcelBorder` is mutable
+   * (`border.left.style = …` is the normal way to use it), so a shared instance
+   * handed to two styles let an edit through one of them reach the other — and,
+   * once anything had assigned `none` and then modified it, every later
+   * `ExcelBorder.none` came back already carrying that edge.
+   */
+  static get none() {
+    return new _ExcelBorder();
+  }
+  /**
+   * A deep copy: the edges are new objects, so mutating the copy cannot reach the
+   * original. {@link CellStyle.clone} relies on this.
+   */
+  clone() {
+    const b = new _ExcelBorder();
+    b.left = this.left.clone();
+    b.right = this.right.clone();
+    b.top = this.top.clone();
+    b.bottom = this.bottom.clone();
+    b.diagonal = this.diagonal.clone();
+    b.diagonalDown = this.diagonalDown;
+    b.diagonalUp = this.diagonalUp;
+    return b;
+  }
   // ── Serialisation ─────────────────────────────────────────────────────────
   toXml() {
     const dd = this.diagonalDown ? ' diagonalDown="1"' : "";
@@ -1047,8 +1289,6 @@ var _ExcelBorder = class _ExcelBorder {
     ].join("|");
   }
 };
-_ExcelBorder.none = new _ExcelBorder();
-var ExcelBorder = _ExcelBorder;
 
 // src/style/excel-alignment.ts
 var ExcelHorizontalAlignment = /* @__PURE__ */ ((ExcelHorizontalAlignment3) => {
@@ -1341,7 +1581,7 @@ var _CellStyle = class _CellStyle {
     const s = new _CellStyle();
     if (this.font) s.font = this.font.clone();
     s.fill = this.fill;
-    s.border = this.border;
+    s.border = this.border?.clone();
     s.alignment = this.alignment ? Object.assign(new ExcelAlignment(), this.alignment) : void 0;
     s.numberFormat = this.numberFormat;
     s.isLocked = this.isLocked;
@@ -1364,8 +1604,46 @@ ensureAlignment_fn = function() {
 };
 var CellStyle = _CellStyle;
 
+// src/model/oa-date.ts
+var OA_EPOCH_MS = Date.UTC(1899, 11, 30, 0, 0, 0, 0);
+var MS_PER_DAY = 864e5;
+function toOADate(date) {
+  const utcMs = Date.UTC(
+    date.getFullYear(),
+    date.getMonth(),
+    date.getDate(),
+    date.getHours(),
+    date.getMinutes(),
+    date.getSeconds(),
+    date.getMilliseconds()
+  );
+  return (utcMs - OA_EPOCH_MS) / MS_PER_DAY;
+}
+function fromOADate(oaDate) {
+  const ms = OA_EPOCH_MS + oaDate * MS_PER_DAY;
+  const d = new Date(ms);
+  return new Date(
+    d.getUTCFullYear(),
+    d.getUTCMonth(),
+    d.getUTCDate(),
+    d.getUTCHours(),
+    d.getUTCMinutes(),
+    d.getUTCSeconds(),
+    d.getUTCMilliseconds()
+  );
+}
+var DATE_FORMAT_IDS = /* @__PURE__ */ new Set([14, 15, 16, 17, 18, 19, 20, 21, 22, 45, 46, 47]);
+function isDateFormatId(formatId) {
+  return DATE_FORMAT_IDS.has(formatId);
+}
+function isDateFormatCode(formatCode) {
+  const lower = formatCode.toLowerCase();
+  return lower.includes("y") || lower.includes("d") || lower.includes("m") && !lower.includes("mm:") || // m = month unless part of mm:ss
+  lower.includes("h") || lower.includes("am") || lower.includes("pm");
+}
+
 // src/style/style-manager.ts
-var _StyleManager_instances, initDefaults_fn, getOrCreateFont_fn, getOrCreateFill_fn, getOrCreateBorder_fn, getOrCreateNumFmt_fn, cellFormatKey_fn, cfToXml_fn;
+var _numFmtMapCache, _dateStyleMemo, _StyleManager_instances, numFmtMap_fn, invalidateFormatCaches_fn, initDefaults_fn, getOrCreateFont_fn, getOrCreateFill_fn, getOrCreateBorder_fn, getOrCreateNumFmt_fn, cellFormatKey_fn, cfToXml_fn;
 var StyleManager = class {
   constructor() {
     __privateAdd(this, _StyleManager_instances);
@@ -1384,6 +1662,21 @@ var StyleManager = class {
     this.cellXfCache = /* @__PURE__ */ new Map();
     this.nextCustomNumFmtId = 164;
     this.isDirty = false;
+    /**
+     * `numFmtId` → format code for the custom (≥164) formats, materialised once.
+     * Rebuilding it per lookup made every numeric cell read O(custom formats),
+     * and reading a cell's value has to consult it to tell dates from numbers.
+     * Invalidated whenever `numFmts` changes — see {@link #invalidateFormatCaches}.
+     */
+    __privateAdd(this, _numFmtMapCache);
+    /**
+     * cellXf index → does its number format render a date? Memoised because
+     * {@link Cell.getValue} asks this for every numeric cell, and answering it
+     * from scratch reconstructs a whole CellStyle. Entries stay valid because
+     * `cellXfs` and `numFmts` are append-only: an existing index never changes
+     * meaning.
+     */
+    __privateAdd(this, _dateStyleMemo, /* @__PURE__ */ new Map());
     __privateMethod(this, _StyleManager_instances, initDefaults_fn).call(this);
   }
   // ── Public API ─────────────────────────────────────────────────────────────
@@ -1435,10 +1728,7 @@ var StyleManager = class {
     const borderEntry = this.borders[cf.borderId];
     if (borderEntry && cf.applyBorder) s.border = borderEntry.border;
     if (cf.applyNumFmt) {
-      const customMap = new Map(
-        this.numFmts.map((n) => [n.id, n.code])
-      );
-      s.numberFormat = ExcelNumberFormat.fromFormatId(cf.numFmtId, customMap);
+      s.numberFormat = ExcelNumberFormat.fromFormatId(cf.numFmtId, __privateMethod(this, _StyleManager_instances, numFmtMap_fn).call(this));
     }
     if (cf.alignment && cf.applyAlign) s.alignment = cf.alignment;
     if (cf.applyProt) {
@@ -1447,6 +1737,29 @@ var StyleManager = class {
     }
     return s;
   }
+  /**
+   * Whether the cellXf at `styleIndex` formats its value as a date. This is the
+   * one style question the value-reading path has to ask, so it is answered
+   * without reconstructing a CellStyle: the result is derived from the stored
+   * format id/code and memoised per index.
+   *
+   * Equivalent to `getCellStyle(i).numberFormat` being date-like, by
+   * construction — both read the same `applyNumFmt`/`numFmtId` pair through
+   * {@link ExcelNumberFormat.fromFormatId}.
+   */
+  isDateStyle(styleIndex) {
+    const memo = __privateGet(this, _dateStyleMemo).get(styleIndex);
+    if (memo !== void 0) return memo;
+    const cf = this.cellXfs[styleIndex];
+    if (!cf) return false;
+    let isDate = false;
+    if (cf.applyNumFmt) {
+      const fmt = ExcelNumberFormat.fromFormatId(cf.numFmtId, __privateMethod(this, _StyleManager_instances, numFmtMap_fn).call(this));
+      isDate = isDateFormatId(fmt.formatId) || isDateFormatCode(fmt.formatCode);
+    }
+    __privateGet(this, _dateStyleMemo).set(styleIndex, isDate);
+    return isDate;
+  }
   // ── XML serialisation ──────────────────────────────────────────────────────
   /** Builds the complete xl/styles.xml string. */
   buildStylesXml() {
@@ -1476,6 +1789,7 @@ ${cellXfsXml}
     this.numFmtCache.clear();
     this.cellXfCache.clear();
     this.nextCustomNumFmtId = 164;
+    __privateMethod(this, _StyleManager_instances, invalidateFormatCaches_fn).call(this);
     const root = parseXml(stylesXml);
     for (const el of getElementsByTagName(root, "numFmt")) {
       const id = parseInt(getAttr(el, "numFmtId") ?? "0", 10);
@@ -1534,9 +1848,23 @@ ${cellXfsXml}
     }
     if (this.fonts.length === 0) __privateMethod(this, _StyleManager_instances, initDefaults_fn).call(this);
     if (this.cellXfs.length === 0) __privateMethod(this, _StyleManager_instances, initDefaults_fn).call(this);
+    __privateMethod(this, _StyleManager_instances, invalidateFormatCaches_fn).call(this);
   }
 };
+_numFmtMapCache = new WeakMap();
+_dateStyleMemo = new WeakMap();
 _StyleManager_instances = new WeakSet();
+numFmtMap_fn = function() {
+  if (!__privateGet(this, _numFmtMapCache)) {
+    __privateSet(this, _numFmtMapCache, new Map(this.numFmts.map((n) => [n.id, n.code])));
+  }
+  return __privateGet(this, _numFmtMapCache);
+};
+/** Drops the derived format caches after `numFmts` or `cellXfs` changed. */
+invalidateFormatCaches_fn = function() {
+  __privateSet(this, _numFmtMapCache, void 0);
+  __privateGet(this, _dateStyleMemo).clear();
+};
 // ── Private helpers ────────────────────────────────────────────────────────
 initDefaults_fn = function() {
   const defaultFont = new ExcelFont({ name: "Calibri", size: 11 });
@@ -1609,6 +1937,7 @@ getOrCreateNumFmt_fn = function(fmt) {
   const id = this.nextCustomNumFmtId++;
   this.numFmts.push({ id, code: fmt.formatCode });
   this.numFmtCache.set(fmt.formatCode, id);
+  __privateMethod(this, _StyleManager_instances, invalidateFormatCaches_fn).call(this);
   this.isDirty = true;
   return id;
 };
@@ -2021,56 +2350,54 @@ function parseRangeRef(rangeReference) {
   };
 }
 
-// src/model/oa-date.ts
-var OA_EPOCH_MS = Date.UTC(1899, 11, 30, 0, 0, 0, 0);
-var MS_PER_DAY = 864e5;
-function toOADate(date) {
-  const utcMs = Date.UTC(
-    date.getFullYear(),
-    date.getMonth(),
-    date.getDate(),
-    date.getHours(),
-    date.getMinutes(),
-    date.getSeconds(),
-    date.getMilliseconds()
-  );
-  return (utcMs - OA_EPOCH_MS) / MS_PER_DAY;
-}
-function fromOADate(oaDate) {
-  const ms = OA_EPOCH_MS + oaDate * MS_PER_DAY;
-  const d = new Date(ms);
-  return new Date(
-    d.getUTCFullYear(),
-    d.getUTCMonth(),
-    d.getUTCDate(),
-    d.getUTCHours(),
-    d.getUTCMinutes(),
-    d.getUTCSeconds(),
-    d.getUTCMilliseconds()
-  );
-}
-var DATE_FORMAT_IDS = /* @__PURE__ */ new Set([14, 15, 16, 17, 18, 19, 20, 21, 22, 45, 46, 47]);
-function isDateFormatId(formatId) {
-  return DATE_FORMAT_IDS.has(formatId);
+// src/model/cell.ts
+function readCellValue(data, sharedStrings, styles) {
+  const raw = data.rawValue;
+  if (raw === void 0 || raw === "") return null;
+  switch (data.dataType) {
+    case "s": {
+      const idx = parseInt(raw, 10);
+      return sharedStrings.tryGetString(idx) ?? raw;
+    }
+    case "b":
+      return raw === "1";
+    case "str":
+      return raw;
+    default: {
+      const num = parseFloat(raw);
+      if (isNaN(num)) return raw;
+      if (styles.isDateStyle(data.styleIndex)) {
+        try {
+          return fromOADate(num);
+        } catch {
+          return num;
+        }
+      }
+      return num;
+    }
+  }
 }
-function isDateFormatCode(formatCode) {
-  const lower = formatCode.toLowerCase();
-  return lower.includes("y") || lower.includes("d") || lower.includes("m") && !lower.includes("mm:") || // m = month unless part of mm:ss
-  lower.includes("h") || lower.includes("am") || lower.includes("pm");
+function buildCellXml(data) {
+  const style = data.styleIndex > 0 ? ` s="${data.styleIndex}"` : "";
+  const formulaXml = data.formula ? data.arrayRef ? `<f t="array" ref="${data.arrayRef}" aca="1" ca="1">${escXml(data.formula)}</f>` : `<f>${escXml(data.formula)}</f>` : "";
+  const valueXml = data.rawValue !== void 0 && data.rawValue !== "" ? `<v>${escXml(data.rawValue)}</v>` : "";
+  const type = data.dataType && (formulaXml || valueXml) ? ` t="${data.dataType}"` : "";
+  if (!formulaXml && !valueXml && data.styleIndex === 0) return "";
+  return `<c r="${data.reference}"${style}${type}>${formulaXml}${valueXml}</c>`;
 }
-
-// src/model/cell.ts
-var _data, _sharedStrings, _styles, _Cell_instances, isDateStyle_fn;
+var _data, _sharedStrings, _styles, _version, _Cell_instances, touch_fn;
 var Cell = class {
   /** @internal */
-  constructor(data, sharedStrings, styles) {
+  constructor(data, sharedStrings, styles, version) {
     __privateAdd(this, _Cell_instances);
     __privateAdd(this, _data);
     __privateAdd(this, _sharedStrings);
     __privateAdd(this, _styles);
+    __privateAdd(this, _version);
     __privateSet(this, _data, data);
     __privateSet(this, _sharedStrings, sharedStrings);
     __privateSet(this, _styles, styles);
+    __privateSet(this, _version, version);
   }
   // ── Identity ───────────────────────────────────────────────────────────────
   /** Cell reference string e.g. "A1". */
@@ -2086,6 +2413,7 @@ var Cell = class {
     return parseCellRef(__privateGet(this, _data).reference).column;
   }
   setValue(value) {
+    __privateMethod(this, _Cell_instances, touch_fn).call(this);
     __privateGet(this, _data).formula = void 0;
     if (value === null || value === void 0) {
       __privateGet(this, _data).dataType = void 0;
@@ -2123,29 +2451,7 @@ var Cell = class {
    * Date detection is based on the cell's number format.
    */
   getValue() {
-    if (__privateGet(this, _data).rawValue === void 0 || __privateGet(this, _data).rawValue === "") return null;
-    switch (__privateGet(this, _data).dataType) {
-      case "s": {
-        const idx = parseInt(__privateGet(this, _data).rawValue, 10);
-        return __privateGet(this, _sharedStrings).tryGetString(idx) ?? __privateGet(this, _data).rawValue;
-      }
-      case "b":
-        return __privateGet(this, _data).rawValue === "1";
-      case "str":
-        return __privateGet(this, _data).rawValue;
-      default: {
-        const num = parseFloat(__privateGet(this, _data).rawValue);
-        if (isNaN(num)) return __privateGet(this, _data).rawValue;
-        if (__privateMethod(this, _Cell_instances, isDateStyle_fn).call(this)) {
-          try {
-            return fromOADate(num);
-          } catch {
-            return num;
-          }
-        }
-        return num;
-      }
-    }
+    return readCellValue(__privateGet(this, _data), __privateGet(this, _sharedStrings), __privateGet(this, _styles));
   }
   /**
    * Returns the display text of the cell value (always a string).
@@ -2183,6 +2489,7 @@ var Cell = class {
    */
   setFormula(formula) {
     if (!formula) throw new Error("Formula cannot be empty.");
+    __privateMethod(this, _Cell_instances, touch_fn).call(this);
     __privateGet(this, _data).formula = formula.startsWith("=") ? formula.slice(1) : formula;
     __privateGet(this, _data).rawValue = void 0;
     __privateGet(this, _data).dataType = void 0;
@@ -2195,6 +2502,7 @@ var Cell = class {
    * plain scalar formula. Serialises as `<f t="array" ref="…">`.
    */
   setArrayRef(spillRef) {
+    __privateMethod(this, _Cell_instances, touch_fn).call(this);
     __privateGet(this, _data).arrayRef = spillRef ?? void 0;
     return this;
   }
@@ -2212,6 +2520,7 @@ var Cell = class {
    * added to the shared-string table.
    */
   setComputedValue(value) {
+    __privateMethod(this, _Cell_instances, touch_fn).call(this);
     if (value === null || value === void 0) {
       __privateGet(this, _data).dataType = void 0;
       __privateGet(this, _data).rawValue = void 0;
@@ -2251,6 +2560,7 @@ var Cell = class {
   }
   /** Replaces the entire cell style. */
   set style(value) {
+    __privateMethod(this, _Cell_instances, touch_fn).call(this);
     __privateGet(this, _data).styleIndex = __privateGet(this, _styles).getOrCreateCellFormatIndex(value);
   }
   /**
@@ -2261,6 +2571,7 @@ var Cell = class {
    * cell.applyStyle(s => s.setBold(true).setFontColor(ExcelColor.red))
    */
   applyStyle(action) {
+    __privateMethod(this, _Cell_instances, touch_fn).call(this);
     const s = __privateGet(this, _styles).getCellStyle(__privateGet(this, _data).styleIndex).clone();
     action(s);
     __privateGet(this, _data).styleIndex = __privateGet(this, _styles).getOrCreateCellFormatIndex(s);
@@ -2303,6 +2614,7 @@ var Cell = class {
   // ── Clear ──────────────────────────────────────────────────────────────────
   /** Clears the cell value and formula, preserving style. */
   clear() {
+    __privateMethod(this, _Cell_instances, touch_fn).call(this);
     __privateGet(this, _data).rawValue = void 0;
     __privateGet(this, _data).dataType = void 0;
     __privateGet(this, _data).formula = void 0;
@@ -2310,19 +2622,14 @@ var Cell = class {
   }
   /** Clears the cell value, formula, AND style. */
   clearAll() {
+    __privateMethod(this, _Cell_instances, touch_fn).call(this);
     this.clear();
     __privateGet(this, _data).styleIndex = 0;
   }
   // ── XML serialisation ──────────────────────────────────────────────────────
   /** @internal Builds the <c> XML element string for this cell. */
   toXml() {
-    const ref = __privateGet(this, _data).reference;
-    const style = __privateGet(this, _data).styleIndex > 0 ? ` s="${__privateGet(this, _data).styleIndex}"` : "";
-    const formulaXml = __privateGet(this, _data).formula ? __privateGet(this, _data).arrayRef ? `<f t="array" ref="${__privateGet(this, _data).arrayRef}" aca="1" ca="1">${escXml(__privateGet(this, _data).formula)}</f>` : `<f>${escXml(__privateGet(this, _data).formula)}</f>` : "";
-    const valueXml = __privateGet(this, _data).rawValue !== void 0 && __privateGet(this, _data).rawValue !== "" ? `<v>${escXml(__privateGet(this, _data).rawValue)}</v>` : "";
-    const type = __privateGet(this, _data).dataType && (formulaXml || valueXml) ? ` t="${__privateGet(this, _data).dataType}"` : "";
-    if (!formulaXml && !valueXml && __privateGet(this, _data).styleIndex === 0) return "";
-    return `<c r="${ref}"${style}${type}>${formulaXml}${valueXml}</c>`;
+    return buildCellXml(__privateGet(this, _data));
   }
   /** @internal Parses a <c> XML element into CellData. */
   static fromXmlElement(el, ref) {
@@ -2331,29 +2638,35 @@ var Cell = class {
     let rawValue;
     let formula;
     let arrayRef;
+    let sharedIndex;
     for (const child of el.children) {
       const tag = child.tagName.replace(/^.*:/, "");
       if (tag === "v") rawValue = child.textContent;
       if (tag === "f") {
         formula = child.textContent;
-        if (child.attributes && child.attributes["t"] === "array" && child.attributes["ref"]) {
-          arrayRef = child.attributes["ref"];
+        const attrs = child.attributes;
+        const type = attrs?.["t"];
+        if (type === "array" && attrs?.["ref"]) {
+          arrayRef = attrs["ref"];
+        }
+        if (type === "shared" && attrs?.["si"] !== void 0) {
+          const si = parseInt(attrs["si"], 10);
+          if (!Number.isNaN(si)) sharedIndex = si;
         }
       }
     }
-    return { reference: ref, dataType, rawValue, formula, arrayRef, styleIndex };
+    if (formula === "") formula = void 0;
+    return { reference: ref, dataType, rawValue, formula, arrayRef, styleIndex, sharedIndex };
   }
 };
 _data = new WeakMap();
 _sharedStrings = new WeakMap();
 _styles = new WeakMap();
+_version = new WeakMap();
 _Cell_instances = new WeakSet();
-// ── Private helpers ────────────────────────────────────────────────────────
-isDateStyle_fn = function() {
-  const style = __privateGet(this, _styles).getCellStyle(__privateGet(this, _data).styleIndex);
-  if (!style.numberFormat) return false;
-  if (isDateFormatId(style.numberFormat.formatId)) return true;
-  return isDateFormatCode(style.numberFormat.formatCode);
+/** Records that this cell's stored data changed. */
+touch_fn = function() {
+  if (__privateGet(this, _version)) __privateGet(this, _version).v++;
 };
 function escXml(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -2620,6 +2933,219 @@ function shiftFormulaRefs(formula, shift, formulaSheet) {
   return { text: out + formula.slice(flushed), changed: true, hasRefError };
 }
 
+// src/model/formula-ref-translate.ts
+function isWordChar2(code) {
+  return code >= 65 && code <= 90 || // A-Z
+  code >= 97 && code <= 122 || // a-z
+  code >= 48 && code <= 57 || // 0-9
+  code === 95 || // _
+  code === 46 || // .
+  code === 36;
+}
+function parseCellComponent2(word) {
+  const m = /^(\$?)([A-Za-z]{1,3})(\$?)(\d+)$/.exec(word);
+  if (!m) return null;
+  const col = columnNumber(m[2]);
+  const row = parseInt(m[4], 10);
+  if (col > EXCEL_MAX_COLUMNS || row < 1 || row > EXCEL_MAX_ROWS) return null;
+  return { colAbs: m[1] === "$", col, rowAbs: m[3] === "$", row };
+}
+function parseColComponent2(word) {
+  const m = /^(\$?)([A-Za-z]{1,3})$/.exec(word);
+  if (!m) return null;
+  const col = columnNumber(m[2]);
+  return col > EXCEL_MAX_COLUMNS ? null : { abs: m[1] === "$", col };
+}
+function parseRowComponent2(word) {
+  const m = /^(\$?)(\d+)$/.exec(word);
+  if (!m) return null;
+  const row = parseInt(m[2], 10);
+  return row < 1 || row > EXCEL_MAX_ROWS ? null : { abs: m[1] === "$", row };
+}
+function move(index, delta, abs, max) {
+  if (abs || delta === 0) return index;
+  const moved = index + delta;
+  return moved < 1 || moved > max ? null : moved;
+}
+function translateFormulaRefs(formula, dRow, dCol) {
+  if (dRow === 0 && dCol === 0) return { text: formula, hasRefError: false };
+  const n = formula.length;
+  let out = "";
+  let flushed = 0;
+  let hasRefError = false;
+  let i = 0;
+  const replace = (start, text) => {
+    if (text.length === i - start && formula.startsWith(text, start)) return;
+    out += formula.slice(flushed, start) + text;
+    flushed = i;
+  };
+  const readWord = () => {
+    let j = i;
+    while (j < n && isWordChar2(formula.charCodeAt(j))) j++;
+    const w = formula.slice(i, j);
+    i = j;
+    return w;
+  };
+  const readQuoted = () => {
+    let j = i + 1;
+    while (j < n) {
+      if (formula[j] === "'") {
+        if (formula[j + 1] === "'") {
+          j += 2;
+          continue;
+        }
+        j++;
+        break;
+      }
+      j++;
+    }
+    const q = formula.slice(i, j);
+    i = j;
+    return q;
+  };
+  const emitCell2 = (c, row, col) => `${c.colAbs ? "$" : ""}${columnLetter(col)}${c.rowAbs ? "$" : ""}${row}`;
+  const consumeRef = (refStart, rewrite = true) => {
+    const first = readWord();
+    const firstCell = parseCellComponent2(first);
+    const firstCol = firstCell ? null : parseColComponent2(first);
+    const firstRow = firstCell || firstCol ? null : parseRowComponent2(first);
+    if (!firstCell && !firstCol && !firstRow) return;
+    let secondCell = null;
+    let secondCol = null;
+    let secondRow = null;
+    let isRange = false;
+    if (formula[i] === ":" && i + 1 < n && isWordChar2(formula.charCodeAt(i + 1))) {
+      const save = i;
+      i++;
+      const w = readWord();
+      if (firstCell) secondCell = parseCellComponent2(w);
+      else if (firstCol) secondCol = parseColComponent2(w);
+      else if (firstRow) secondRow = parseRowComponent2(w);
+      if (secondCell || secondCol || secondRow) isRange = true;
+      else i = save;
+    }
+    if (!isRange && formula[i] === "(") return;
+    if (!rewrite) {
+      if (formula[i] === "#") i++;
+      return;
+    }
+    const dead = () => {
+      if (formula[i] === "#") i++;
+      replace(refStart, "#REF!");
+      hasRefError = true;
+    };
+    if (isRange) {
+      if (firstCell && secondCell) {
+        const r1 = move(firstCell.row, dRow, firstCell.rowAbs, EXCEL_MAX_ROWS);
+        const c1 = move(firstCell.col, dCol, firstCell.colAbs, EXCEL_MAX_COLUMNS);
+        const r2 = move(secondCell.row, dRow, secondCell.rowAbs, EXCEL_MAX_ROWS);
+        const c2 = move(secondCell.col, dCol, secondCell.colAbs, EXCEL_MAX_COLUMNS);
+        if (r1 === null || c1 === null || r2 === null || c2 === null) {
+          dead();
+          return;
+        }
+        replace(refStart, `${emitCell2(firstCell, r1, c1)}:${emitCell2(secondCell, r2, c2)}`);
+        return;
+      }
+      if (firstCol && secondCol) {
+        const c1 = move(firstCol.col, dCol, firstCol.abs, EXCEL_MAX_COLUMNS);
+        const c2 = move(secondCol.col, dCol, secondCol.abs, EXCEL_MAX_COLUMNS);
+        if (c1 === null || c2 === null) {
+          dead();
+          return;
+        }
+        replace(refStart, `${firstCol.abs ? "$" : ""}${columnLetter(c1)}:${secondCol.abs ? "$" : ""}${columnLetter(c2)}`);
+        return;
+      }
+      if (firstRow && secondRow) {
+        const r1 = move(firstRow.row, dRow, firstRow.abs, EXCEL_MAX_ROWS);
+        const r2 = move(secondRow.row, dRow, secondRow.abs, EXCEL_MAX_ROWS);
+        if (r1 === null || r2 === null) {
+          dead();
+          return;
+        }
+        replace(refStart, `${firstRow.abs ? "$" : ""}${r1}:${secondRow.abs ? "$" : ""}${r2}`);
+        return;
+      }
+      return;
+    }
+    if (!firstCell) return;
+    const row = move(firstCell.row, dRow, firstCell.rowAbs, EXCEL_MAX_ROWS);
+    const col = move(firstCell.col, dCol, firstCell.colAbs, EXCEL_MAX_COLUMNS);
+    if (row === null || col === null) {
+      dead();
+      return;
+    }
+    replace(refStart, emitCell2(firstCell, row, col));
+  };
+  while (i < n) {
+    const ch = formula[i];
+    if (ch === '"') {
+      let j = i + 1;
+      while (j < n) {
+        if (formula[j] === '"') {
+          if (formula[j + 1] === '"') {
+            j += 2;
+            continue;
+          }
+          j++;
+          break;
+        }
+        j++;
+      }
+      i = j;
+      continue;
+    }
+    if (ch === "'") {
+      readQuoted();
+      if (formula[i] === "!") {
+        i++;
+        consumeRef(i);
+      }
+      continue;
+    }
+    if (isWordChar2(formula.charCodeAt(i))) {
+      const start = i;
+      readWord();
+      if (formula[i] === "!") {
+        i++;
+        consumeRef(i);
+        continue;
+      }
+      if (formula[i] === ":") {
+        const save = i;
+        i++;
+        const w2 = i < n && isWordChar2(formula.charCodeAt(i)) ? readWord() : "";
+        if (w2 && formula[i] === "!") {
+          i++;
+          consumeRef(i, false);
+          continue;
+        }
+        i = save;
+      }
+      if (formula[i] === "[") {
+        let depth = 0;
+        let j = i;
+        while (j < n) {
+          if (formula[j] === "[") depth++;
+          else if (formula[j] === "]" && --depth === 0) {
+            j++;
+            break;
+          }
+          j++;
+        }
+        i = j;
+        continue;
+      }
+      i = start;
+      consumeRef(start);
+      continue;
+    }
+    i++;
+  }
+  return { text: out + formula.slice(flushed), hasRefError };
+}
+
 // src/model/range.ts
 var _sheet, _startRow, _startColumn, _endRow, _endColumn, _address, _Range_instances, forEach_fn, forEachExisting_fn;
 var Range = class {
@@ -2850,7 +3376,7 @@ var PROTECTION_ATTRS = [
   ["allowEditObjects", "objects"],
   ["allowEditScenarios", "scenarios"]
 ];
-var _sharedStrings2, _styles2, _name, _rows, _cols, _mergeCells, _pane, _autoFilter, _dataValidations, _visibility, _drawings, _protection, _protectionCredentials, _hyperlinks, _comments, _commentsDirty, _pendingHyperlinkRels, _preservedTail, _preservedRels, _Worksheet_instances, takeCellData_fn, takeCellDataAt_fn, deleteCellData_fn, applyStructural_fn, shiftRowsAndCells_fn, shiftRows_fn, shiftColumns_fn, maxPopulatedRow_fn, shiftSpillRanges_fn, shiftSpillRange_fn, rewriteFormulas_fn, shiftMerges_fn, shiftAutoFilter_fn, shiftValidations_fn, shiftHyperlinks_fn, shiftComments_fn, shiftColDefs_fn, relIdBase_fn, activeTail_fn, buildTailXml_fn, buildSheetProtectionXml_fn, buildHyperlinksXml_fn, buildColsXml_fn, buildSheetDataXml_fn, buildMergeCellsXml_fn, buildDataValidationsXml_fn, buildSheetViewXml_fn, splitColSpan_fn, insertColDef_fn, findColDefIndex_fn, findColDef_fn, pruneColDefs_fn, getOrCreateRow_fn;
+var _sharedStrings2, _styles2, _name, _rows, _cols, _mergeCells, _pane, _autoFilter, _dataValidations, _visibility, _drawings, _protection, _protectionCredentials, _hyperlinks, _comments, _commentsDirty, _pendingHyperlinkRels, _preservedTail, _preservedRels, _version2, _usedBoundsMemo, _xmlMemo, _Worksheet_instances, touch_fn2, findCellData_fn, computeUsedBounds_fn, takeCellData_fn, takeCellDataAt_fn, deleteCellData_fn, applyStructural_fn, shiftRowsAndCells_fn, shiftRows_fn, shiftColumns_fn, maxPopulatedRow_fn, shiftSpillRanges_fn, shiftSpillRange_fn, rewriteFormulas_fn, shiftMerges_fn, shiftAutoFilter_fn, shiftValidations_fn, shiftHyperlinks_fn, shiftComments_fn, shiftColDefs_fn, relIdBase_fn, activeTail_fn, buildTailXml_fn, buildSheetProtectionXml_fn, buildHyperlinksXml_fn, resolveSharedFormulas_fn, buildColsXml_fn, buildSheetDataXml_fn, buildMergeCellsXml_fn, buildDataValidationsXml_fn, buildSheetViewXml_fn, splitColSpan_fn, insertColDef_fn, findColDefIndex_fn, findColDef_fn, pruneColDefs_fn, getOrCreateRow_fn;
 var Worksheet = class {
   /** @internal */
   constructor(name, sharedStrings, styles) {
@@ -2892,10 +3418,26 @@ var Worksheet = class {
     // comment anchors survive open→save. See io/preserved-parts.ts.
     __privateAdd(this, _preservedTail, []);
     __privateAdd(this, _preservedRels, []);
+    /**
+     * Mutation counter for this sheet, shared with every {@link Cell} view it
+     * hands out (a Cell writes directly into the stored CellData). Everything
+     * derived from the sheet's contents — the used-range memo, the cached
+     * worksheet XML — is keyed on it, so every mutator must bump it. The test
+     * `worksheet-version.test.ts` walks the public surface to keep that true.
+     */
+    __privateAdd(this, _version2, { v: 0 });
+    /** Memoised {@link usedBounds}, valid while `#version.v` is unchanged. */
+    __privateAdd(this, _usedBoundsMemo);
+    /** Memoised {@link buildXml} output, valid while `#version.v` is unchanged. */
+    __privateAdd(this, _xmlMemo);
     __privateSet(this, _name, name);
     __privateSet(this, _sharedStrings2, sharedStrings);
     __privateSet(this, _styles2, styles);
   }
+  /** @internal Current mutation count — see {@link #version}. */
+  get version() {
+    return __privateGet(this, _version2).v;
+  }
   // ── Identity ───────────────────────────────────────────────────────────────
   get name() {
     return __privateGet(this, _name);
@@ -2917,10 +3459,11 @@ var Worksheet = class {
     const rowData = __privateMethod(this, _Worksheet_instances, getOrCreateRow_fn).call(this, row);
     let cellData = rowData.cells.get(ref);
     if (!cellData) {
+      __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
       cellData = { reference: ref, styleIndex: 0 };
       rowData.cells.set(ref, cellData);
     }
-    return new Cell(cellData, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2));
+    return new Cell(cellData, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2), __privateGet(this, _version2));
   }
   tryGetCell(refOrRow, column) {
     let rowData;
@@ -2936,7 +3479,7 @@ var Worksheet = class {
     }
     const cellData = rowData.cells.get(ref);
     if (!cellData) return null;
-    return new Cell(cellData, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2));
+    return new Cell(cellData, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2), __privateGet(this, _version2));
   }
   cell(refOrRow, column) {
     return typeof refOrRow === "string" ? this.getCell(refOrRow) : this.getCell(refOrRow, column);
@@ -2948,15 +3491,28 @@ var Worksheet = class {
   }
   /** Gets the raw value of a cell (for formula evaluation). */
   getCellValue(reference) {
-    return this.tryGetCell(reference)?.getValue() ?? null;
+    const cd = __privateMethod(this, _Worksheet_instances, findCellData_fn).call(this, reference);
+    return cd ? readCellValue(cd, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2)) : null;
+  }
+  /**
+   * Value of a cell addressed by 1-based row/column. The reference-string
+   * overload has to build (and the callee re-parse) a string per cell; a range
+   * read walking a rectangle already knows the coordinates, and on a real
+   * workbook that is tens of millions of strings per recalculation.
+   */
+  getCellValueAt(row, column) {
+    const rowData = __privateGet(this, _rows).get(row);
+    if (!rowData) return null;
+    const cd = rowData.cells.get(cellRefFromRowCol(row, column));
+    return cd ? readCellValue(cd, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2)) : null;
   }
   /** Formula text (without leading '=') of a cell, or null if it has none. */
   getCellFormula(reference) {
-    return this.tryGetCell(reference)?.getFormula() ?? null;
+    return __privateMethod(this, _Worksheet_instances, findCellData_fn).call(this, reference)?.formula ?? null;
   }
   /** Spill range (e.g. "A1:A3") of a dynamic-array anchor, or null. Supports A1#. */
   getSpillRange(reference) {
-    return this.tryGetCell(reference)?.getArrayRef() ?? null;
+    return __privateMethod(this, _Worksheet_instances, findCellData_fn).call(this, reference)?.arrayRef ?? null;
   }
   /**
    * Iterates the populated rows of the sheet in ascending row order, yielding
@@ -2972,7 +3528,7 @@ var Worksheet = class {
   *rows() {
     const populated = [...__privateGet(this, _rows).values()].filter((row) => row.cells.size > 0).sort((a, b) => a.rowIndex - b.rowIndex);
     for (const row of populated) {
-      const cells = [...row.cells.values()].map((cd) => ({ cd, col: columnFromRef(cd.reference, refSplit(cd.reference)) })).sort((a, b) => a.col - b.col).map(({ cd }) => new Cell(cd, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2)));
+      const cells = [...row.cells.values()].map((cd) => ({ cd, col: columnFromRef(cd.reference, refSplit(cd.reference)) })).sort((a, b) => a.col - b.col).map(({ cd }) => new Cell(cd, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2), __privateGet(this, _version2)));
       yield { rowIndex: row.rowIndex, cells };
     }
   }
@@ -2997,7 +3553,7 @@ var Worksheet = class {
       for (const cd of row.cells.values()) {
         const col = columnFromRef(cd.reference, refSplit(cd.reference));
         if (col < startColumn || col > endColumn) continue;
-        action(new Cell(cd, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2)), row.rowIndex, col);
+        action(new Cell(cd, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2), __privateGet(this, _version2)), row.rowIndex, col);
       }
     };
     if (endRow - startRow + 1 <= __privateGet(this, _rows).size) {
@@ -3016,6 +3572,7 @@ var Worksheet = class {
    * the public {@link moveCell} has to do. Used by bulk range moves.
    */
   moveCellRC(fromRow, fromColumn, toRow, toColumn) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     if (fromRow === toRow && fromColumn === toColumn) return;
     const fromRef = cellRefFromRowCol(fromRow, fromColumn);
     const toRef = cellRefFromRowCol(toRow, toColumn);
@@ -3037,21 +3594,16 @@ var Worksheet = class {
    * cheaper when a dense shape is not actually required.
    */
   get usedBounds() {
-    let rowCount = 0;
-    let columnCount = 0;
-    for (const row of __privateGet(this, _rows).values()) {
-      if (row.cells.size === 0) continue;
-      if (row.rowIndex > rowCount) rowCount = row.rowIndex;
-      for (const ref of row.cells.keys()) {
-        const col = columnFromRef(ref, refSplit(ref));
-        if (col > columnCount) columnCount = col;
-      }
-    }
-    return { rowCount, columnCount };
+    const memo = __privateGet(this, _usedBoundsMemo);
+    if (memo && memo.at === __privateGet(this, _version2).v) return memo.value;
+    const value = __privateMethod(this, _Worksheet_instances, computeUsedBounds_fn).call(this);
+    __privateSet(this, _usedBoundsMemo, { at: __privateGet(this, _version2).v, value });
+    return value;
   }
   // ── Layout ─────────────────────────────────────────────────────────────────
   /** Sets the width of a column (1-based index). */
   setColumnWidth(columnIndex, width) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     if (columnIndex < 1) throw new RangeError("Column index must be >= 1.");
     if (width <= 0) throw new RangeError("Width must be > 0.");
     const def = __privateMethod(this, _Worksheet_instances, splitColSpan_fn).call(this, columnIndex) ?? __privateMethod(this, _Worksheet_instances, insertColDef_fn).call(this, { min: columnIndex, max: columnIndex, customWidth: false });
@@ -3064,6 +3616,7 @@ var Worksheet = class {
    * {@link getColumnWidth} returns `undefined`. A hidden column stays hidden.
    */
   resetColumnWidth(columnIndex) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     if (columnIndex < 1) throw new RangeError("Column index must be >= 1.");
     const def = __privateMethod(this, _Worksheet_instances, splitColSpan_fn).call(this, columnIndex);
     if (!def) return;
@@ -3076,6 +3629,7 @@ var Worksheet = class {
    * file as `<col hidden="1">` and keep any explicit width.
    */
   setColumnHidden(columnIndex, hidden = true) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     if (columnIndex < 1) throw new RangeError("Column index must be >= 1.");
     const def = __privateMethod(this, _Worksheet_instances, splitColSpan_fn).call(this, columnIndex);
     if (def) {
@@ -3102,6 +3656,7 @@ var Worksheet = class {
   }
   /** Auto-fits column width based on content (approximate). */
   autoFitColumn(columnIndex) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     this.autoFitColumns(columnIndex, columnIndex);
   }
   /**
@@ -3109,6 +3664,7 @@ var Worksheet = class {
    * populated cells, instead of re-scanning the sheet once per column.
    */
   autoFitColumns(firstColumn, lastColumn) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     if (firstColumn < 1) throw new RangeError("Column index must be >= 1.");
     if (lastColumn < firstColumn) return;
     const maxLen = /* @__PURE__ */ new Map();
@@ -3123,6 +3679,7 @@ var Worksheet = class {
   }
   /** Sets the height of a row (1-based index). */
   setRowHeight(rowIndex, height) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     if (rowIndex < 1) throw new RangeError("Row index must be >= 1.");
     if (height <= 0) throw new RangeError("Height must be > 0.");
     const row = __privateMethod(this, _Worksheet_instances, getOrCreateRow_fn).call(this, rowIndex);
@@ -3143,6 +3700,7 @@ var Worksheet = class {
    * {@link getRowHeight} returns `undefined`. A hidden row stays hidden.
    */
   resetRowHeight(rowIndex) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     if (rowIndex < 1) throw new RangeError("Row index must be >= 1.");
     const row = __privateGet(this, _rows).get(rowIndex);
     if (!row) return;
@@ -3152,6 +3710,7 @@ var Worksheet = class {
   }
   /** Shows or hides a row (1-based index). Hidden rows affect SUBTOTAL(101-111). */
   setRowHidden(rowIndex, hidden = true) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     if (rowIndex < 1) throw new RangeError("Row index must be >= 1.");
     __privateMethod(this, _Worksheet_instances, getOrCreateRow_fn).call(this, rowIndex).hidden = hidden;
   }
@@ -3202,6 +3761,7 @@ var Worksheet = class {
    * ws.insertRows(3, 2); // pushes row 3 and below down by two rows
    */
   insertRows(at, count = 1) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     return __privateMethod(this, _Worksheet_instances, applyStructural_fn).call(this, "row", "insert", at, count);
   }
   /**
@@ -3211,6 +3771,7 @@ var Worksheet = class {
    * for the shifting rules and known limitations.
    */
   deleteRows(at, count = 1) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     return __privateMethod(this, _Worksheet_instances, applyStructural_fn).call(this, "row", "delete", at, count);
   }
   /**
@@ -3219,6 +3780,7 @@ var Worksheet = class {
    * shift with the columns.
    */
   insertColumns(at, count = 1) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     return __privateMethod(this, _Worksheet_instances, applyStructural_fn).call(this, "col", "insert", at, count);
   }
   /**
@@ -3226,6 +3788,7 @@ var Worksheet = class {
    * Column-level counterpart to {@link deleteRows}.
    */
   deleteColumns(at, count = 1) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     return __privateMethod(this, _Worksheet_instances, applyStructural_fn).call(this, "col", "delete", at, count);
   }
   /**
@@ -3234,6 +3797,7 @@ var Worksheet = class {
    * like `'Data'!A5` stay correct. Cell positions here do not change.
    */
   applyExternalShift(shift) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     return { refErrors: __privateMethod(this, _Worksheet_instances, rewriteFormulas_fn).call(this, shift) };
   }
   /**
@@ -3246,6 +3810,7 @@ var Worksheet = class {
    * ws.moveCell('A1', 'C5');
    */
   moveCell(from, to) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     const fromRef = normalizeRef(from);
     const toRef = normalizeRef(to);
     if (fromRef === toRef) return;
@@ -3277,6 +3842,7 @@ var Worksheet = class {
    * ws.copyCell('A1', 'C5');
    */
   copyCell(from, to) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     const fromRef = normalizeRef(from);
     const toRef = normalizeRef(to);
     if (fromRef === toRef) return;
@@ -3292,11 +3858,13 @@ var Worksheet = class {
   }
   /** Merges cells in the given range (e.g. "A1:B2"). */
   mergeCells(rangeReference) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     if (!rangeReference) throw new Error("Range reference cannot be empty.");
     __privateGet(this, _mergeCells).push({ ref: rangeReference });
   }
   /** Removes a merge for the given range reference. */
   unmergeCells(rangeReference) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     __privateSet(this, _mergeCells, __privateGet(this, _mergeCells).filter((m) => m.ref !== rangeReference));
   }
   /**
@@ -3313,12 +3881,14 @@ var Worksheet = class {
    * @param column Number of columns to freeze (0 = none)
    */
   freezePanes(row, column) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     if (row < 0) throw new RangeError("Row must be >= 0.");
     if (column < 0) throw new RangeError("Column must be >= 0.");
     __privateSet(this, _pane, row === 0 && column === 0 ? void 0 : { row, column });
   }
   /** Sets auto-filter on the given range. */
   setAutoFilter(rangeReference) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     __privateSet(this, _autoFilter, { ref: rangeReference });
   }
   /**
@@ -3327,10 +3897,12 @@ var Worksheet = class {
    * @param listFormula Formula for the dropdown list (e.g. "'Sheet2'!$A$1:$A$10")
    */
   addDropdownValidation(cellRange, listFormula) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     __privateGet(this, _dataValidations).push({ sqref: cellRange, formula: listFormula });
   }
   /** Sets the visibility state of this worksheet. */
   setVisibility(state) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     __privateSet(this, _visibility, state);
   }
   get visibility() {
@@ -3352,10 +3924,12 @@ var Worksheet = class {
    * ws.protect({ allowSort: true, allowAutoFilter: true });
    */
   protect(options) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     __privateSet(this, _protection, { ...PROTECTION_DEFAULTS, ...options });
   }
   /** Turns off sheet protection, discarding any password read from a file. */
   unprotect() {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     __privateSet(this, _protection, void 0);
     __privateSet(this, _protectionCredentials, "");
   }
@@ -3386,6 +3960,7 @@ var Worksheet = class {
     if (!link.target && !link.location) {
       throw new Error("A hyperlink needs a target (external) or a location (in-workbook).");
     }
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     const normalized = normalizeRangeRef(ref);
     __privateGet(this, _hyperlinks).set(normalized, { ref: normalized, ...link });
   }
@@ -3395,6 +3970,7 @@ var Worksheet = class {
   }
   /** Removes the hyperlink on this ref. Returns true if one was there. */
   removeHyperlink(ref) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     return __privateGet(this, _hyperlinks).delete(normalizeRangeRef(ref));
   }
   /** Every hyperlink on the sheet, including ones read from a file. */
@@ -3415,6 +3991,7 @@ var Worksheet = class {
    * ws.setComment('B4', 'Check this figure', { author: 'Bill' });
    */
   setComment(ref, text, options) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     const normalized = normalizeRef(ref);
     __privateGet(this, _comments).set(normalized, {
       ref: normalized,
@@ -3429,6 +4006,7 @@ var Worksheet = class {
   }
   /** Removes the comment on a cell. Returns true if one was there. */
   removeComment(ref) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     const removed = __privateGet(this, _comments).delete(normalizeRef(ref));
     if (removed) __privateSet(this, _commentsDirty, true);
     return removed;
@@ -3456,6 +4034,7 @@ var Worksheet = class {
    * save pipeline turns registered providers into valid OOXML drawing/chart parts.
    */
   addDrawingProvider(provider) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     __privateGet(this, _drawings).push(provider);
   }
   /**
@@ -3467,6 +4046,7 @@ var Worksheet = class {
    * deliberately drop a chart that came from the source file.
    */
   clearDrawings() {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     __privateSet(this, _drawings, []);
     __privateSet(this, _preservedTail, __privateGet(this, _preservedTail).filter((t) => t.tag !== "drawing"));
   }
@@ -3533,6 +4113,7 @@ var Worksheet = class {
   }
   /** @internal Captures round-trip state from the source package. */
   loadPreservedState(worksheetXml, relationships) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     __privateSet(this, _preservedRels, relationships.filter((r) => r.type !== REL_TYPES.hyperlink));
     const known = new Set(__privateGet(this, _preservedRels).map((r) => r.id));
     __privateSet(this, _preservedTail, parseTailElements(worksheetXml).filter((t) => known.has(t.relId)));
@@ -3573,6 +4154,8 @@ var Worksheet = class {
   // ── XML serialisation ──────────────────────────────────────────────────────
   /** Builds the xl/worksheets/sheetN.xml string. */
   buildXml() {
+    const memo = __privateGet(this, _xmlMemo);
+    if (memo && memo.at === __privateGet(this, _version2).v) return memo.xml;
     const rels = this.generatedRels();
     const sheetViewXml = __privateMethod(this, _Worksheet_instances, buildSheetViewXml_fn).call(this);
     const colsXml = __privateMethod(this, _Worksheet_instances, buildColsXml_fn).call(this);
@@ -3583,15 +4166,18 @@ var Worksheet = class {
     const validXml = __privateMethod(this, _Worksheet_instances, buildDataValidationsXml_fn).call(this);
     const linksXml = __privateMethod(this, _Worksheet_instances, buildHyperlinksXml_fn).call(this, rels.hyperlinks);
     const tailXml = __privateMethod(this, _Worksheet_instances, buildTailXml_fn).call(this, rels);
-    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+    const xml2 = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
            xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
   <sheetViews>${sheetViewXml}</sheetViews>
 ${colsXml}${sheetDataXml}${protectionXml}${filterXml}${mergeXml}${validXml}${linksXml}${tailXml}
 </worksheet>`;
+    __privateSet(this, _xmlMemo, { at: __privateGet(this, _version2).v, xml: xml2 });
+    return xml2;
   }
   /** Parses xl/worksheets/sheetN.xml and loads cells into memory. */
   loadFromXml(xml2) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     __privateGet(this, _rows).clear();
     __privateSet(this, _cols, []);
     __privateSet(this, _mergeCells, []);
@@ -3613,6 +4199,8 @@ ${colsXml}${sheetDataXml}${protectionXml}${filterXml}${mergeXml}${validXml}${lin
         hidden: getAttr(colEl, "hidden") === "1"
       });
     }
+    const sharedMasters = /* @__PURE__ */ new Map();
+    const sharedInstances = [];
     for (const rowEl of getElementsByTagName(root, "row")) {
       const rowIndex = parseInt(getAttr(rowEl, "r") ?? "0", 10);
       if (rowIndex < 1) continue;
@@ -3633,9 +4221,17 @@ ${colsXml}${sheetDataXml}${protectionXml}${filterXml}${mergeXml}${validXml}${lin
           ref.toUpperCase()
         );
         rowData.cells.set(ref.toUpperCase(), cellData);
+        if (cellData.sharedIndex !== void 0) {
+          if (cellData.formula !== void 0) {
+            sharedMasters.set(cellData.sharedIndex, { formula: cellData.formula, ref: cellData.reference });
+          } else {
+            sharedInstances.push(cellData);
+          }
+        }
       }
       __privateGet(this, _rows).set(rowIndex, rowData);
     }
+    __privateMethod(this, _Worksheet_instances, resolveSharedFormulas_fn).call(this, sharedMasters, sharedInstances);
     for (const mcEl of getElementsByTagName(root, "mergeCell")) {
       const ref = getAttr(mcEl, "ref");
       if (ref) __privateGet(this, _mergeCells).push({ ref });
@@ -3691,6 +4287,7 @@ ${colsXml}${sheetDataXml}${protectionXml}${filterXml}${mergeXml}${validXml}${lin
   }
   /** @internal Parses an `xl/comments*.xml` part into this sheet's comments. */
   loadCommentsXml(xml2) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     const root = parseXml(xml2);
     const authors = getElementsByTagName(root, "author").map((a) => a.textContent);
     for (const cEl of getElementsByTagName(root, "comment")) {
@@ -3750,7 +4347,47 @@ _commentsDirty = new WeakMap();
 _pendingHyperlinkRels = new WeakMap();
 _preservedTail = new WeakMap();
 _preservedRels = new WeakMap();
+_version2 = new WeakMap();
+_usedBoundsMemo = new WeakMap();
+_xmlMemo = new WeakMap();
 _Worksheet_instances = new WeakSet();
+/** Records a change to this sheet's contents or layout. */
+touch_fn2 = function() {
+  __privateGet(this, _version2).v++;
+};
+/**
+ * The stored record for a cell, without creating it — the read paths below
+ * work on this directly instead of wrapping it in a {@link Cell}. Formula
+ * evaluation reads far more cells than it writes, and one wrapper per read is
+ * pure garbage.
+ */
+findCellData_fn = function(reference) {
+  const ref = normalizeRefFast(reference);
+  return __privateGet(this, _rows).get(parseCellRef(ref).row)?.cells.get(ref);
+};
+/**
+ * The extent, computed without touching the memo.
+ *
+ * Internal callers must use this. A mutator bumps the version once, at its
+ * start, and then does its work; if it read the memoised getter part-way
+ * through, the half-finished extent would be cached against the *new* version
+ * and served as current for the rest of that version's life. That is precisely
+ * how `insertColumns` came to report the extent it had before the insert —
+ * caught by the round-trip fuzz test, not by any of the hand-written ones.
+ */
+computeUsedBounds_fn = function() {
+  let rowCount = 0;
+  let columnCount = 0;
+  for (const row of __privateGet(this, _rows).values()) {
+    if (row.cells.size === 0) continue;
+    if (row.rowIndex > rowCount) rowCount = row.rowIndex;
+    for (const ref of row.cells.keys()) {
+      const col = columnFromRef(ref, refSplit(ref));
+      if (col > columnCount) columnCount = col;
+    }
+  }
+  return { rowCount, columnCount };
+};
 /** Removes and returns a cell's data record, pruning an emptied bare row. */
 takeCellData_fn = function(ref) {
   return __privateMethod(this, _Worksheet_instances, takeCellDataAt_fn).call(this, parseCellRef(ref).row, ref);
@@ -3776,7 +4413,7 @@ applyStructural_fn = function(dim, kind, at, count) {
   const shift = { dim, kind, at, count, sheetName: __privateGet(this, _name) };
   if (kind === "insert") {
     const limit = dim === "row" ? EXCEL_MAX_ROWS : EXCEL_MAX_COLUMNS;
-    const used = dim === "row" ? __privateMethod(this, _Worksheet_instances, maxPopulatedRow_fn).call(this) : this.usedBounds.columnCount;
+    const used = dim === "row" ? __privateMethod(this, _Worksheet_instances, maxPopulatedRow_fn).call(this) : __privateMethod(this, _Worksheet_instances, computeUsedBounds_fn).call(this).columnCount;
     if (used >= at && used + count > limit) {
       throw new RangeError(`Insert would push populated cells past the sheet limit of ${limit}.`);
     }
@@ -3992,6 +4629,34 @@ buildHyperlinksXml_fn = function(relIds) {
   }).join("");
   return `<hyperlinks>${inner}</hyperlinks>`;
 };
+/**
+ * Materialises the formula of every shared-formula instance cell.
+ *
+ * Excel writes a fill-down once: the group's master carries the text, the rest
+ * carry `<f t="shared" si="n"/>` and are understood to hold the master's
+ * formula with its relative references moved by the offset between the cells.
+ * Read literally — the way this used to be read — an instance cell has no
+ * formula at all, and the next save turns it into the constant that happened to
+ * be cached in `<v>`. On a real workbook that is tens of thousands of formulas
+ * quietly replaced by numbers.
+ *
+ * Each cell ends up owning its own text, so nothing downstream (evaluation,
+ * structural edits, serialisation) needs to know the group ever existed.
+ */
+resolveSharedFormulas_fn = function(masters, instances) {
+  if (instances.length === 0) return;
+  for (const cd of instances) {
+    const master = masters.get(cd.sharedIndex);
+    if (!master) continue;
+    const from = parseCellRef(master.ref);
+    const to = parseCellRef(cd.reference);
+    cd.formula = translateFormulaRefs(
+      master.formula,
+      to.row - from.row,
+      to.column - from.column
+    ).text;
+  }
+};
 // ── Private XML builders ───────────────────────────────────────────────────
 buildColsXml_fn = function() {
   if (__privateGet(this, _cols).length === 0) return "";
@@ -4009,7 +4674,7 @@ buildSheetDataXml_fn = function() {
     const ht = row.height !== void 0 && row.customHeight ? ` ht="${row.height}" customHeight="1"` : "";
     const hidden = row.hidden ? ' hidden="1"' : "";
     const sortedCells = [...row.cells.values()].map((cd) => ({ cd, col: columnFromRef(cd.reference, refSplit(cd.reference)) })).sort((a, b) => a.col - b.col);
-    const cellsXml = sortedCells.map(({ cd }) => new Cell(cd, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2)).toXml()).filter(Boolean).join("");
+    const cellsXml = sortedCells.map(({ cd }) => buildCellXml(cd)).filter(Boolean).join("");
     if (!cellsXml && !ht && !hidden) return "";
     return `<row r="${row.rowIndex}"${ht}${hidden}>${cellsXml}</row>`;
   }).filter(Boolean).join("");
@@ -4223,7 +4888,7 @@ indexOf_fn = function(name, scope) {
 };
 
 // src/model/workbook.ts
-var _sharedStrings3, _styles3, _sheets, _definedNames, _closed, _preservedParts, _preservedContentTypes, _orphanedTargets, _Workbook_instances, structuralEdit_fn, assertOpen_fn, seedPreservedParts_fn, preservedContentTypeDeclarations_fn, buildZipEntries_fn;
+var _sharedStrings3, _styles3, _sheets, _definedNames, _closed, _calcChain, _calcChainFingerprint, _deflateCache, _preservedParts, _preservedContentTypes, _orphanedTargets, _Workbook_instances, structuralEdit_fn, sheetFingerprint_fn, calcChainStillValid_fn, assertOpen_fn, seedPreservedParts_fn, preservedContentTypeDeclarations_fn, buildZipEntries_fn;
 var _Workbook = class _Workbook {
   constructor(sharedStrings, styles) {
     __privateAdd(this, _Workbook_instances);
@@ -4232,6 +4897,24 @@ var _Workbook = class _Workbook {
     __privateAdd(this, _sheets, []);
     __privateAdd(this, _definedNames, new DefinedNameManager());
     __privateAdd(this, _closed, false);
+    /**
+     * The calculation order Excel stored in `xl/calcChain.xml`, in file order, or
+     * undefined when the source had no such part. Read-only to consumers: it is a
+     * record of what the source file said, not a live view of the model.
+     */
+    __privateAdd(this, _calcChain);
+    /**
+     * Fingerprint of the sheet set taken right after the calc chain was parsed.
+     * The chain is only written back out when this still matches — see
+     * {@link #calcChainStillValid}.
+     */
+    __privateAdd(this, _calcChainFingerprint);
+    /**
+     * Compressed form of each package part from the last save. Compression is where
+     * a save spends its time, and an autosave changes one part, so the rest are
+     * reused verbatim. Keyed on content, so a part rebuilt identically still hits.
+     */
+    __privateAdd(this, _deflateCache, createDeflateCache());
     /** Parts carried over verbatim from the file this workbook was opened from. */
     __privateAdd(this, _preservedParts, /* @__PURE__ */ new Map());
     __privateAdd(this, _preservedContentTypes);
@@ -4256,6 +4939,7 @@ var _Workbook = class _Workbook {
    * Mirrors Workbook.Open(stream) in C#.
    */
   static fromBuffer(buffer) {
+    var _a;
     const entries = unzipXlsx(buffer);
     const ss = new SharedStringManager();
     const sm = new StyleManager();
@@ -4292,6 +4976,11 @@ var _Workbook = class _Workbook {
       }
       __privateGet(wb, _sheets).push({ worksheet: ws, sheetId, relId });
     }
+    const calcChainXml = readXmlEntry(entries, CALC_CHAIN_PATH);
+    if (calcChainXml) {
+      __privateSet(wb, _calcChain, parseCalcChain(calcChainXml, __privateGet(wb, _sheets)));
+      __privateSet(wb, _calcChainFingerprint, __privateMethod(_a = wb, _Workbook_instances, sheetFingerprint_fn).call(_a));
+    }
     __privateSet(wb, _preservedParts, collectPreservedParts(entries));
     const ctXml = readXmlEntry(entries, "[Content_Types].xml");
     if (ctXml) __privateSet(wb, _preservedContentTypes, parseContentTypes(ctXml));
@@ -4338,8 +5027,8 @@ var _Workbook = class _Workbook {
     if (__privateGet(this, _sheets).some((e) => e.worksheet.name === name)) {
       throw new Error(`Worksheet "${name}" already exists.`);
     }
-    const sheetId = __privateGet(this, _sheets).length + 1;
-    const relId = `rId${sheetId}`;
+    const sheetId = __privateGet(this, _sheets).reduce((max, e) => Math.max(max, e.sheetId), 0) + 1;
+    const relId = `rId${__privateGet(this, _sheets).length + 1}`;
     const ws = new Worksheet(name, __privateGet(this, _sharedStrings3), __privateGet(this, _styles3));
     __privateGet(this, _sheets).push({ worksheet: ws, sheetId, relId });
     return ws;
@@ -4448,7 +5137,21 @@ var _Workbook = class _Workbook {
   saveAsBuffer() {
     __privateMethod(this, _Workbook_instances, assertOpen_fn).call(this);
     const entries = __privateMethod(this, _Workbook_instances, buildZipEntries_fn).call(this);
-    return zipXlsx(entries);
+    return zipXlsxCached(entries, __privateGet(this, _deflateCache));
+  }
+  /**
+   * Same output as {@link saveAsBuffer}, without blocking the calling thread on
+   * compression — for an editor that autosaves, this is the difference between a
+   * visible stall on every save and none.
+   *
+   * The XML for sheets that have not changed since the last save is reused, so a
+   * save after a one-cell edit re-serialises one sheet rather than all of them.
+   * That reuse applies to the synchronous path too; only the compression differs.
+   */
+  async saveAsBufferAsync() {
+    __privateMethod(this, _Workbook_instances, assertOpen_fn).call(this);
+    const entries = __privateMethod(this, _Workbook_instances, buildZipEntries_fn).call(this);
+    return zipXlsxCachedAsync(entries, __privateGet(this, _deflateCache));
   }
   /**
    * Saves the workbook to a file (Node.js only).
@@ -4456,7 +5159,7 @@ var _Workbook = class _Workbook {
    */
   async saveToFile(filePath) {
     __privateMethod(this, _Workbook_instances, assertOpen_fn).call(this);
-    const buffer = this.saveAsBuffer();
+    const buffer = await this.saveAsBufferAsync();
     const fs = await import('fs/promises');
     const path = await import('path');
     const dir = path.dirname(filePath);
@@ -4472,12 +5175,29 @@ var _Workbook = class _Workbook {
   [Symbol.dispose]() {
     this.close();
   }
+  // ── Calculation order ──────────────────────────────────────────────────────
+  /**
+   * The calculation order Excel recorded for this workbook, oldest-first as
+   * stored in `xl/calcChain.xml`, or an empty array when the source file had
+   * none (a freshly created workbook, or one saved by a tool that omits it).
+   *
+   * Excel has already done the topological sort that produced this order, so
+   * evaluating in it avoids repeating that work. Treat it as a hint, not a
+   * guarantee: it reflects the file as opened, and edits made since are not
+   * reflected here.
+   */
+  get calcChain() {
+    return __privateGet(this, _calcChain) ?? EMPTY_CALC_CHAIN;
+  }
 };
 _sharedStrings3 = new WeakMap();
 _styles3 = new WeakMap();
 _sheets = new WeakMap();
 _definedNames = new WeakMap();
 _closed = new WeakMap();
+_calcChain = new WeakMap();
+_calcChainFingerprint = new WeakMap();
+_deflateCache = new WeakMap();
 _preservedParts = new WeakMap();
 _preservedContentTypes = new WeakMap();
 _orphanedTargets = new WeakMap();
@@ -4499,6 +5219,28 @@ structuralEdit_fn = function(sheetName, dim, kind, at, count) {
   }
   return { refErrors };
 };
+/**
+ * Identity of the sheet set: names, durable ids and per-sheet mutation counts.
+ * The calc chain is a statement about exactly this set — which cells hold
+ * formulas, on which sheet, under which id — so any change to it invalidates
+ * the chain wholesale.
+ */
+sheetFingerprint_fn = function() {
+  return __privateGet(this, _sheets).map((e) => `${e.sheetId}:${e.worksheet.name}:${e.worksheet.version}`).join("|");
+};
+/**
+ * Whether the parsed calc chain may be written back out.
+ *
+ * Deliberately conservative: any edit at all (a value, a formula, a sheet
+ * added or removed) and the chain is dropped instead of patched. An absent
+ * calcChain is a documented no-op — Excel rebuilds it on open — whereas a
+ * chain that disagrees with the sheets is the failure mode this whole change
+ * exists to remove. Rebuilding a correct chain would mean redoing Excel's
+ * dependency analysis, which belongs in the formula package, not here.
+ */
+calcChainStillValid_fn = function() {
+  return __privateGet(this, _calcChain) !== void 0 && __privateGet(this, _calcChain).length > 0 && __privateGet(this, _calcChainFingerprint) === __privateMethod(this, _Workbook_instances, sheetFingerprint_fn).call(this);
+};
 // ── Private helpers ────────────────────────────────────────────────────────
 assertOpen_fn = function() {
   if (__privateGet(this, _closed)) throw new Error("Workbook has been closed.");
@@ -4559,7 +5301,7 @@ buildZipEntries_fn = function() {
   entries.set("_rels/.rels", ROOT_RELS);
   const sheetMetas = __privateGet(this, _sheets).map((e, i) => ({
     name: e.worksheet.name,
-    sheetId: i + 1,
+    sheetId: e.sheetId,
     relationshipId: `rId${i + 1}`,
     state: e.worksheet.visibility !== "visible" ? e.worksheet.visibility : void 0
   }));
@@ -4572,7 +5314,15 @@ buildZipEntries_fn = function() {
     return { name: dn.name, refersTo: dn.refersTo, localSheetId };
   });
   entries.set("xl/workbook.xml", buildWorkbookXml(sheetMetas, definedNameMetas));
-  entries.set("xl/_rels/workbook.xml.rels", buildWorkbookRels(sheetCount));
+  const keepCalcChain = __privateMethod(this, _Workbook_instances, calcChainStillValid_fn).call(this);
+  if (keepCalcChain) {
+    const idBySheet = new Map(__privateGet(this, _sheets).map((e) => [e.worksheet.name, e.sheetId]));
+    entries.set(CALC_CHAIN_PATH, buildCalcChainXml(__privateGet(this, _calcChain), idBySheet));
+  } else {
+    entries.delete(CALC_CHAIN_PATH);
+    preservedPaths.delete(CALC_CHAIN_PATH);
+  }
+  entries.set("xl/_rels/workbook.xml.rels", buildWorkbookRels(sheetCount, keepCalcChain));
   entries.set("xl/styles.xml", __privateGet(this, _styles3).buildStylesXml());
   entries.set("xl/sharedStrings.xml", __privateGet(this, _sharedStrings3).buildXml());
   for (let i = 0; i < __privateGet(this, _sheets).length; i++) {
@@ -4580,6 +5330,9 @@ buildZipEntries_fn = function() {
   }
   const extraOverrides = [];
   const extraDefaults = [];
+  if (keepCalcChain) {
+    extraOverrides.push({ partName: `/${CALC_CHAIN_PATH}`, contentType: CONTENT_TYPES.calcChain });
+  }
   let drawingCounter = 0;
   let partCounter = 0;
   let commentsCounter = 0;
@@ -4655,6 +5408,42 @@ buildZipEntries_fn = function() {
   return entries;
 };
 var Workbook = _Workbook;
+var CALC_CHAIN_PATH = "xl/calcChain.xml";
+var EMPTY_CALC_CHAIN = [];
+function parseCalcChain(xml2, sheets) {
+  const nameById = new Map(sheets.map((e) => [e.sheetId, e.worksheet.name]));
+  const out = [];
+  let currentId;
+  try {
+    const root = parseXml(xml2);
+    for (const el of getElementsByTagName(root, "c")) {
+      const ref = getAttr(el, "r");
+      if (!ref) continue;
+      const iAttr = getAttr(el, "i");
+      if (iAttr !== void 0) {
+        const parsed = parseInt(iAttr, 10);
+        if (!Number.isNaN(parsed)) currentId = parsed;
+      }
+      if (currentId === void 0) continue;
+      const sheet = nameById.get(currentId);
+      if (sheet === void 0) continue;
+      out.push({ sheet, ref: ref.toUpperCase() });
+    }
+  } catch {
+    return [];
+  }
+  return out;
+}
+function buildCalcChainXml(chain, idBySheet) {
+  const cells = [];
+  for (const { sheet, ref } of chain) {
+    const id = idBySheet.get(sheet);
+    if (id === void 0) continue;
+    cells.push(`<c r="${ref}" i="${id}"/>`);
+  }
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<calcChain xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">${cells.join("")}</calcChain>`;
+}
 function resolveWorksheetPath(relsXml, relId) {
   if (!relsXml) return void 0;
   try {