@pixerate/editor 0.21.0 → 0.23.0

package/dist/{chunk-U6NDQFOK.cjs → chunk-XDMXXC4Z.cjs}

@@ -10,7 +10,15 @@
 
 
 
-var _chunkJYRIOFENcjs = require('./chunk-JYRIOFEN.cjs');
+
+
+
+
+
+
+
+
+var _chunkRIKBJLS2cjs = require('./chunk-RIKBJLS2.cjs');
 
 // src/spreadsheet/formula/dependency-graph.ts
 var columnDependencyKey = (col) => `${col.toUpperCase()}:`;
@@ -19,22 +27,24 @@ function extractCellDependencies(node) {
   const visit = (curr) => {
     if (curr.type === "CellRef") {
       deps.push({ col: curr.col, row: curr.row });
-    } else if (curr.type === "Range" && curr.endRow >= _chunkJYRIOFENcjs.WHOLE_COLUMN_END_ROW) {
-      const startC = _chunkJYRIOFENcjs.colNameToIndex.call(void 0, curr.startCol);
-      const endC = _chunkJYRIOFENcjs.colNameToIndex.call(void 0, curr.endCol);
+    } else if (curr.type === "SpillRef") {
+      deps.push({ col: curr.col, row: curr.row });
+    } else if (curr.type === "Range" && curr.endRow >= _chunkRIKBJLS2cjs.WHOLE_COLUMN_END_ROW) {
+      const startC = _chunkRIKBJLS2cjs.colNameToIndex.call(void 0, curr.startCol);
+      const endC = _chunkRIKBJLS2cjs.colNameToIndex.call(void 0, curr.endCol);
       for (let c = Math.min(startC, endC); c <= Math.max(startC, endC); c++) {
-        deps.push({ col: _chunkJYRIOFENcjs.indexToColName.call(void 0, c), row: 0 });
+        deps.push({ col: _chunkRIKBJLS2cjs.indexToColName.call(void 0, c), row: 0 });
       }
     } else if (curr.type === "Range") {
-      const startC = _chunkJYRIOFENcjs.colNameToIndex.call(void 0, curr.startCol);
-      const endC = _chunkJYRIOFENcjs.colNameToIndex.call(void 0, curr.endCol);
+      const startC = _chunkRIKBJLS2cjs.colNameToIndex.call(void 0, curr.startCol);
+      const endC = _chunkRIKBJLS2cjs.colNameToIndex.call(void 0, curr.endCol);
       const minC = Math.min(startC, endC);
       const maxC = Math.max(startC, endC);
       const minR = Math.min(curr.startRow, curr.endRow);
       const maxR = Math.max(curr.startRow, curr.endRow);
       for (let c = minC; c <= maxC; c++) {
         for (let r = minR; r <= maxR; r++) {
-          deps.push({ col: _chunkJYRIOFENcjs.indexToColName.call(void 0, c), row: r });
+          deps.push({ col: _chunkRIKBJLS2cjs.indexToColName.call(void 0, c), row: r });
         }
       }
     } else if (curr.type === "BinaryOp") {
@@ -49,11 +59,19 @@ function extractCellDependencies(node) {
   visit(node);
   return deps;
 }
-var DependencyGraph = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
+var DependencyGraph = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this); }
   // Map of cellKey (e.g. "B2") -> Set of cellKeys that this cell depends ON
   __init() {this.dependencies = /* @__PURE__ */ new Map()}
   // Map of cellKey (e.g. "A1") -> Set of cellKeys that depend ON this cell (dependents)
   __init2() {this.dependents = /* @__PURE__ */ new Map()}
+  // Dynamic-array edges, set by the controller after evaluating an anchor:
+  // spilled cells depend on their anchor, and a blocked (#SPILL!) anchor
+  // depends on the cells blocking it. Kept apart from formula dependencies,
+  // so re-entering a formula doesn't drop them.
+  __init3() {this.spillDependencies = /* @__PURE__ */ new Map()}
+  __init4() {this.spillDependents = /* @__PURE__ */ new Map()}
+  // anchor -> the edges it registered (so they can be replaced).
+  __init5() {this.spillEdges = /* @__PURE__ */ new Map()}
   setCellFormula(cellKey, formulaStr) {
     const key = cellKey.toUpperCase();
     const oldDeps = this.dependencies.get(key) || /* @__PURE__ */ new Set();
@@ -65,7 +83,7 @@ var DependencyGraph = (_class = class {constructor() { _class.prototype.__init.c
       return;
     }
     try {
-      const ast = _chunkJYRIOFENcjs.parseFormula.call(void 0, formulaStr);
+      const ast = _chunkRIKBJLS2cjs.parseFormula.call(void 0, formulaStr);
       const deps = extractCellDependencies(ast);
       const newDeps = /* @__PURE__ */ new Set();
       for (const d of deps) {
@@ -84,12 +102,49 @@ var DependencyGraph = (_class = class {constructor() { _class.prototype.__init.c
   clear() {
     this.dependencies.clear();
     this.dependents.clear();
+    this.spillDependencies.clear();
+    this.spillDependents.clear();
+    this.spillEdges.clear();
   }
+  /**
+   * Records the dynamic-array edges of the anchor `anchorKey`, replacing its
+   * previous ones: every key in `spilledKeys` (cells holding its spilled
+   * values) depends on the anchor, and the anchor depends on every key in
+   * `blockingKeys` (cells that stop it spilling). Pass empty lists to remove
+   * the anchor's edges.
+   */
+  setSpillEdges(anchorKey, spilledKeys, blockingKeys = []) {
+    const anchor = anchorKey.toUpperCase();
+    for (const [from, to] of _nullishCoalesce(this.spillEdges.get(anchor), () => ( []))) {
+      _optionalChain([this, 'access', _7 => _7.spillDependencies, 'access', _8 => _8.get, 'call', _9 => _9(from), 'optionalAccess', _10 => _10.delete, 'call', _11 => _11(to)]);
+      _optionalChain([this, 'access', _12 => _12.spillDependents, 'access', _13 => _13.get, 'call', _14 => _14(to), 'optionalAccess', _15 => _15.delete, 'call', _16 => _16(from)]);
+    }
+    const edges = [];
+    for (const key of spilledKeys) edges.push([key.toUpperCase(), anchor]);
+    for (const key of blockingKeys) edges.push([anchor, key.toUpperCase()]);
+    for (const [from, to] of edges) {
+      if (!this.spillDependencies.has(from)) this.spillDependencies.set(from, /* @__PURE__ */ new Set());
+      this.spillDependencies.get(from).add(to);
+      if (!this.spillDependents.has(to)) this.spillDependents.set(to, /* @__PURE__ */ new Set());
+      this.spillDependents.get(to).add(from);
+    }
+    if (edges.length > 0) this.spillEdges.set(anchor, edges);
+    else this.spillEdges.delete(anchor);
+  }
+  /** The spilled cells registered for `anchorKey` by `setSpillEdges`. */
+  getSpilledKeys(anchorKey) {
+    const anchor = anchorKey.toUpperCase();
+    return (_nullishCoalesce(this.spillEdges.get(anchor), () => ( []))).filter(([, to]) => to === anchor).map(([from]) => from);
+  }
+  /** Formula dependencies plus dynamic-array (spill) dependencies of a cell. */
   getDependencies(cellKey) {
-    return Array.from(this.dependencies.get(cellKey.toUpperCase()) || []);
+    const key = cellKey.toUpperCase();
+    return unionOf(this.dependencies.get(key), this.spillDependencies.get(key));
   }
+  /** Cells depending on `cellKey`, through formulas or spills. */
   getDependents(cellKey) {
-    return Array.from(this.dependents.get(cellKey.toUpperCase()) || []);
+    const key = cellKey.toUpperCase();
+    return unionOf(this.dependents.get(key), this.spillDependents.get(key));
   }
   /**
    * Detects if there is a cycle containing cellKey.
@@ -101,7 +156,7 @@ var DependencyGraph = (_class = class {constructor() { _class.prototype.__init.c
     const dfs = (node) => {
       visited.add(node);
       recStack.add(node);
-      const deps = this.dependencies.get(node) || /* @__PURE__ */ new Set();
+      const deps = this.getDependencies(node);
       for (const neighbor of deps) {
         if (!visited.has(neighbor)) {
           if (dfs(neighbor)) return true;
@@ -180,6 +235,7 @@ var DependencyGraph = (_class = class {constructor() { _class.prototype.__init.c
         const node = queue.pop();
         const direct = [
           ..._nullishCoalesce(this.dependents.get(node), () => ( [])),
+          ..._nullishCoalesce(this.spillDependents.get(node), () => ( [])),
           ..._nullishCoalesce(this.dependents.get(columnDependencyKey(node.replace(/\d+$/, ""))), () => ( []))
         ];
         for (const dep of direct) {
@@ -192,7 +248,7 @@ var DependencyGraph = (_class = class {constructor() { _class.prototype.__init.c
     }
     const neighbors = (node) => {
       const result = [];
-      for (const dep of _nullishCoalesce(this.dependencies.get(node), () => ( []))) {
+      for (const dep of this.getDependencies(node)) {
         if (dep.endsWith(":")) {
           const col = dep.slice(0, -1);
           for (const candidate of nodes) {
@@ -258,6 +314,11 @@ var DependencyGraph = (_class = class {constructor() { _class.prototype.__init.c
     return { order, cyclic };
   }
 }, _class);
+function unionOf(a, b) {
+  if (!b || b.size === 0) return Array.from(_nullishCoalesce(a, () => ( [])));
+  if (!a || a.size === 0) return Array.from(b);
+  return Array.from(/* @__PURE__ */ new Set([...a, ...b]));
+}
 
 // src/spreadsheet/formula/references.ts
 var CELL_PART = /^(\$?)([A-Za-z]+)(\$?)(\d+)$/;
@@ -268,19 +329,19 @@ function parsePart(text) {
   if (cell) {
     return {
       colAbs: cell[1],
-      col: _chunkJYRIOFENcjs.colNameToIndex.call(void 0, cell[2]),
+      col: _chunkRIKBJLS2cjs.colNameToIndex.call(void 0, cell[2]),
       rowAbs: cell[3],
       row: parseInt(cell[4], 10) - 1
     };
   }
   const column = COLUMN_PART.exec(text);
   if (column) {
-    return { colAbs: column[1], col: _chunkJYRIOFENcjs.colNameToIndex.call(void 0, column[2]), rowAbs: "", row: null };
+    return { colAbs: column[1], col: _chunkRIKBJLS2cjs.colNameToIndex.call(void 0, column[2]), rowAbs: "", row: null };
   }
   return null;
 }
 function formatPart(part) {
-  const col = `${part.colAbs}${_chunkJYRIOFENcjs.indexToColName.call(void 0, part.col)}`;
+  const col = `${part.colAbs}${_chunkRIKBJLS2cjs.indexToColName.call(void 0, part.col)}`;
   return part.row === null ? col : `${col}${part.rowAbs}${part.row + 1}`;
 }
 function shiftCoordinate(value, change) {
@@ -327,7 +388,7 @@ function mapFormulaReferences(formula, rewrite) {
   if (!formula.startsWith("=")) return formula;
   let tokens;
   try {
-    tokens = _chunkJYRIOFENcjs.tokenizeFormula.call(void 0, formula);
+    tokens = _chunkRIKBJLS2cjs.tokenizeFormula.call(void 0, formula);
   } catch (e2) {
     return formula;
   }
@@ -335,11 +396,17 @@ function mapFormulaReferences(formula, rewrite) {
   let cursor = 0;
   for (let i = 0; i < tokens.length; i++) {
     const token = tokens[i];
-    if (token.type !== "CELL_REF" && token.type !== "RANGE") continue;
-    if (_optionalChain([tokens, 'access', _7 => _7[i + 1], 'optionalAccess', _8 => _8.type]) === "LPAREN") continue;
+    if (token.type !== "CELL_REF" && token.type !== "RANGE" && token.type !== "SPILL_REF") continue;
+    if (_optionalChain([tokens, 'access', _17 => _17[i + 1], 'optionalAccess', _18 => _18.type]) === "LPAREN") continue;
     let end = token.position;
     while (end < formula.length && REF_CHAR.test(formula[end])) end++;
     const original = formula.slice(token.position, end);
+    if (token.type === "SPILL_REF") {
+      const rewritten = rewrite(original);
+      result += formula.slice(cursor, token.position) + (rewritten === "#REF!" ? rewritten : `${rewritten}#`);
+      cursor = end + 1;
+      continue;
+    }
     result += formula.slice(cursor, token.position) + rewrite(original);
     cursor = end;
   }
@@ -459,7 +526,7 @@ function innermostCall(stack) {
 }
 var toSuggestion = (def) => ({
   name: def.name,
-  signature: _chunkJYRIOFENcjs.getFormulaSignature.call(void 0, def),
+  signature: _chunkRIKBJLS2cjs.getFormulaSignature.call(void 0, def),
   description: def.description,
   category: def.category
 });
@@ -468,20 +535,20 @@ function getFormulaHints(input, caret = input.length, options = {}) {
   let suggestions = [];
   if (context.prefix) {
     const query = context.prefix.text.toUpperCase();
-    suggestions = _chunkJYRIOFENcjs.searchFormulaFunctions.call(void 0, query, { limit: void 0 }).filter((def) => def.name.startsWith(query)).slice(0, _nullishCoalesce(options.limit, () => ( 8))).map(toSuggestion);
+    suggestions = _chunkRIKBJLS2cjs.searchFormulaFunctions.call(void 0, query, { limit: void 0 }).filter((def) => def.name.startsWith(query)).slice(0, _nullishCoalesce(options.limit, () => ( 8))).map(toSuggestion);
     const followedByParen = input.slice(context.prefix.end).trimStart().startsWith("(");
     if (followedByParen || suggestions.length === 1 && suggestions[0].name === query) suggestions = [];
   }
   let activeCall = null;
   if (context.call) {
-    const def = _chunkJYRIOFENcjs.getFormulaFunction.call(void 0, context.call.name);
+    const def = _chunkRIKBJLS2cjs.getFormulaFunction.call(void 0, context.call.name);
     if (def) {
-      const specIndex = _chunkJYRIOFENcjs.getFormulaArgumentSpecIndex.call(void 0, def, context.call.argIndex);
+      const specIndex = _chunkRIKBJLS2cjs.getFormulaArgumentSpecIndex.call(void 0, def, context.call.argIndex);
       activeCall = {
         name: def.name,
-        signature: _chunkJYRIOFENcjs.getFormulaSignature.call(void 0, def),
+        signature: _chunkRIKBJLS2cjs.getFormulaSignature.call(void 0, def),
         description: def.description,
-        parts: _chunkJYRIOFENcjs.getFormulaSignatureParts.call(void 0, def, context.call.argIndex),
+        parts: _chunkRIKBJLS2cjs.getFormulaSignatureParts.call(void 0, def, context.call.argIndex),
         argIndex: context.call.argIndex,
         argument: specIndex >= 0 ? def.args[specIndex] : null
       };
@@ -491,8 +558,8 @@ function getFormulaHints(input, caret = input.length, options = {}) {
 }
 function applyFormulaSuggestion(input, caret, name) {
   const context = getFormulaCaretContext(input, caret);
-  const start = _nullishCoalesce(_optionalChain([context, 'access', _9 => _9.prefix, 'optionalAccess', _10 => _10.start]), () => ( caret));
-  const end = _nullishCoalesce(_optionalChain([context, 'access', _11 => _11.prefix, 'optionalAccess', _12 => _12.end]), () => ( caret));
+  const start = _nullishCoalesce(_optionalChain([context, 'access', _19 => _19.prefix, 'optionalAccess', _20 => _20.start]), () => ( caret));
+  const end = _nullishCoalesce(_optionalChain([context, 'access', _21 => _21.prefix, 'optionalAccess', _22 => _22.end]), () => ( caret));
   const hasParen = input[end] === "(";
   const insert = hasParen ? name.toUpperCase() : `${name.toUpperCase()}(`;
   const value = input.slice(0, start) + insert + input.slice(end);
@@ -500,8 +567,8 @@ function applyFormulaSuggestion(input, caret, name) {
 }
 
 // src/spreadsheet/datasource/index.ts
-var DataSourceBinder = (_class2 = class {constructor() { _class2.prototype.__init3.call(this); }
-  __init3() {this.dataSources = /* @__PURE__ */ new Map()}
+var DataSourceBinder = (_class2 = class {constructor() { _class2.prototype.__init6.call(this); }
+  __init6() {this.dataSources = /* @__PURE__ */ new Map()}
   register(dataSource) {
     this.dataSources.set(dataSource.id, dataSource);
   }
@@ -532,10 +599,10 @@ var DataSourceBinder = (_class2 = class {constructor() { _class2.prototype.__ini
     for (const record of records) {
       const existing = existingRecordRowMap.get(record.id);
       nextRows.push({
-        ..._optionalChain([existing, 'optionalAccess', _13 => _13.hidden]) ? { hidden: true } : {},
-        id: _optionalChain([existing, 'optionalAccess', _14 => _14.id]) || `row_${record.id}`,
+        ..._optionalChain([existing, 'optionalAccess', _23 => _23.hidden]) ? { hidden: true } : {},
+        id: _optionalChain([existing, 'optionalAccess', _24 => _24.id]) || `row_${record.id}`,
         index: rowIndex++,
-        height: _optionalChain([existing, 'optionalAccess', _15 => _15.height]) || 32,
+        height: _optionalChain([existing, 'optionalAccess', _25 => _25.height]) || 32,
         recordId: record.id,
         type: "record"
       });
@@ -617,28 +684,41 @@ function compareCellValues(a, b, direction = "asc") {
   const aBlank = isBlankValue(a);
   const bBlank = isBlankValue(b);
   if (aBlank || bBlank) return aBlank === bBlank ? 0 : aBlank ? 1 : -1;
-  const aNum = toNumber(a);
-  const bNum = toNumber(b);
   let result;
-  if (aNum !== null && bNum !== null) result = aNum - bNum;
-  else if (aNum !== null) result = -1;
-  else if (bNum !== null) result = 1;
-  else result = compareText(String(a), String(b));
+  if (isPlainText(a) && isPlainText(b) && !(_chunkRIKBJLS2cjs.parseIsoDate.call(void 0, a) && _chunkRIKBJLS2cjs.parseIsoDate.call(void 0, b))) {
+    result = compareText(a, b);
+  } else {
+    result = _chunkRIKBJLS2cjs.sortCompareValues.call(void 0, a, b);
+  }
   if (result === 0) return 0;
   return direction === "desc" ? -Math.sign(result) : Math.sign(result);
 }
+var isPlainText = (value) => typeof value === "string" && !_chunkRIKBJLS2cjs.isFormulaError.call(void 0, value);
+function filterValue(value) {
+  if (isBlankValue(value) || _chunkRIKBJLS2cjs.isFormulaError.call(void 0, value)) return null;
+  if (typeof value === "number") return Number.isFinite(value) ? { value, kind: "number" } : null;
+  if (typeof value === "boolean") return { value, kind: "boolean" };
+  const num = _chunkRIKBJLS2cjs.numericValue.call(void 0, value);
+  if (num !== null) return { value: num, kind: "number" };
+  const text = String(value);
+  return { value: text, kind: _chunkRIKBJLS2cjs.parseIsoDate.call(void 0, text) ? "number" : "text" };
+}
+function filterOperand(operand) {
+  if (typeof operand !== "string") return filterValue(operand);
+  if (operand.trim() === "") return null;
+  const parsed = _chunkRIKBJLS2cjs.parseCellInput.call(void 0, operand.trim());
+  if (parsed.type === "number" || parsed.type === "date" || parsed.type === "boolean") return filterValue(parsed.value);
+  return { value: operand, kind: "text" };
+}
 function compareForFilter(value, operand) {
-  if (isBlankValue(value) || isBlankValue(operand)) return null;
-  const a = toNumber(value);
-  const b = toNumber(operand);
-  if (a !== null && b !== null) return a - b;
-  if (a !== null || b !== null) return null;
-  return compareText(String(value), String(operand));
+  const a = filterValue(value);
+  const b = filterOperand(operand);
+  if (!a || !b || a.kind !== b.kind) return null;
+  return _chunkRIKBJLS2cjs.compareValues.call(void 0, a.value, b.value);
 }
 function looselyEquals(value, operand) {
-  const a = toNumber(value);
-  const b = toNumber(operand);
-  if (a !== null && b !== null) return a === b;
+  const c = compareForFilter(value, operand);
+  if (c !== null) return c === 0;
   return String(_nullishCoalesce(value, () => ( ""))).trim().toLowerCase() === String(_nullishCoalesce(operand, () => ( ""))).trim().toLowerCase();
 }
 function matchesFilterRule(value, rule) {
@@ -713,7 +793,8 @@ function classifyFillValue(raw) {
   if (raw.trim() === "") return { kind: "blank" };
   const num = toNumber(raw);
   if (num !== null) return { kind: "number", value: num };
-  const date = ISO_DATE_PATTERN.exec(raw.trim());
+  const typed = _chunkRIKBJLS2cjs.parseCellInput.call(void 0, raw);
+  const date = ISO_DATE_PATTERN.exec(typed.type === "date" ? String(typed.value) : raw.trim());
   if (date) {
     const [year, month, day] = [Number(date[1]), Number(date[2]), Number(date[3])];
     const time = Date.UTC(year, month - 1, day);
@@ -991,8 +1072,8 @@ function parseHtmlTable(html) {
     while (cellMatch = cellPattern.exec(rowMatch[1])) {
       while (taken.has(col)) row[col++] = "";
       const attrs = _nullishCoalesce(cellMatch[2], () => ( ""));
-      const colspan = Math.max(1, parseInt(_nullishCoalesce(_optionalChain([/colspan\s*=\s*["']?(\d+)/i, 'access', _16 => _16.exec, 'call', _17 => _17(attrs), 'optionalAccess', _18 => _18[1]]), () => ( "1")), 10));
-      const rowspan = Math.max(1, parseInt(_nullishCoalesce(_optionalChain([/rowspan\s*=\s*["']?(\d+)/i, 'access', _19 => _19.exec, 'call', _20 => _20(attrs), 'optionalAccess', _21 => _21[1]]), () => ( "1")), 10));
+      const colspan = Math.max(1, parseInt(_nullishCoalesce(_optionalChain([/colspan\s*=\s*["']?(\d+)/i, 'access', _26 => _26.exec, 'call', _27 => _27(attrs), 'optionalAccess', _28 => _28[1]]), () => ( "1")), 10));
+      const rowspan = Math.max(1, parseInt(_nullishCoalesce(_optionalChain([/rowspan\s*=\s*["']?(\d+)/i, 'access', _29 => _29.exec, 'call', _30 => _30(attrs), 'optionalAccess', _31 => _31[1]]), () => ( "1")), 10));
       row[col] = cellHtmlToText(cellMatch[3]);
       for (let c = col; c < col + colspan; c++) {
         if (c > col) row[c] = "";
@@ -1010,11 +1091,16 @@ function parseHtmlTable(html) {
   return rows.length > 0 ? rows : null;
 }
 function createSpreadsheetClipboardData(cells, origin) {
-  const values = cells.map((row) => row.map((cell) => cell.value));
-  const payload = { type: "pixerate-spreadsheet", version: 1, origin, cells };
+  const texts = cells.map((row) => row.map((cell) => _nullishCoalesce(cell.text, () => ( displayText(cell.value)))));
+  const payload = {
+    type: "pixerate-spreadsheet",
+    version: 1,
+    origin,
+    cells: cells.map((row) => row.map(({ raw, value }) => ({ raw, value })))
+  };
   return {
-    "text/plain": serializeTsv(values.map((row) => row.map(displayText))),
-    "text/html": serializeHtmlTable(values),
+    "text/plain": serializeTsv(texts),
+    "text/html": serializeHtmlTable(texts),
     [SPREADSHEET_CLIPBOARD_MIME]: JSON.stringify(payload)
   };
 }
@@ -1031,7 +1117,7 @@ function readFormat(source, format) {
 function parsePayload(json) {
   try {
     const payload = JSON.parse(json);
-    if (_optionalChain([payload, 'optionalAccess', _22 => _22.type]) !== "pixerate-spreadsheet" || !Array.isArray(payload.cells) || !payload.cells.every((row) => Array.isArray(row)) || typeof _optionalChain([payload, 'access', _23 => _23.origin, 'optionalAccess', _24 => _24.row]) !== "number" || typeof _optionalChain([payload, 'access', _25 => _25.origin, 'optionalAccess', _26 => _26.col]) !== "number") {
+    if (_optionalChain([payload, 'optionalAccess', _32 => _32.type]) !== "pixerate-spreadsheet" || !Array.isArray(payload.cells) || !payload.cells.every((row) => Array.isArray(row)) || typeof _optionalChain([payload, 'access', _33 => _33.origin, 'optionalAccess', _34 => _34.row]) !== "number" || typeof _optionalChain([payload, 'access', _35 => _35.origin, 'optionalAccess', _36 => _36.col]) !== "number") {
       return null;
     }
     return payload;
@@ -1045,7 +1131,7 @@ function readSpreadsheetClipboard(source) {
     return {
       format: "internal",
       origin: payload.origin,
-      rows: payload.cells.map((row) => row.map((cell) => typeof _optionalChain([cell, 'optionalAccess', _27 => _27.raw]) === "string" ? cell.raw : displayText(_optionalChain([cell, 'optionalAccess', _28 => _28.value]))))
+      rows: payload.cells.map((row) => row.map((cell) => typeof _optionalChain([cell, 'optionalAccess', _37 => _37.raw]) === "string" ? cell.raw : displayText(_optionalChain([cell, 'optionalAccess', _38 => _38.value]))))
     };
   }
   const html = readFormat(source, "text/html");
@@ -1074,8 +1160,8 @@ var DEFAULT_COLUMN_WIDTH = 130;
 var clampCount = (value, max) => Math.max(0, Math.min(Math.floor(_nullishCoalesce(value, () => ( 0))), max));
 function getTableSections(doc) {
   const total = doc.rows.length;
-  const headerRows = clampCount(_optionalChain([doc, 'access', _29 => _29.table, 'optionalAccess', _30 => _30.headerRowCount]), total);
-  const footerRows = clampCount(_optionalChain([doc, 'access', _31 => _31.table, 'optionalAccess', _32 => _32.footerRowCount]), total - headerRows);
+  const headerRows = clampCount(_optionalChain([doc, 'access', _39 => _39.table, 'optionalAccess', _40 => _40.headerRowCount]), total);
+  const footerRows = clampCount(_optionalChain([doc, 'access', _41 => _41.table, 'optionalAccess', _42 => _42.footerRowCount]), total - headerRows);
   return { headerRows, footerRows };
 }
 function getRowSection(doc, rowIndex) {
@@ -1085,8 +1171,8 @@ function getRowSection(doc, rowIndex) {
   return "body";
 }
 function rowPassesFilters(doc, rowIndex, getValue) {
-  const filter = _optionalChain([doc, 'access', _33 => _33.table, 'optionalAccess', _34 => _34.filter]);
-  if (!_optionalChain([filter, 'optionalAccess', _35 => _35.enabled]) || filter.rules.length === 0) return true;
+  const filter = _optionalChain([doc, 'access', _43 => _43.table, 'optionalAccess', _44 => _44.filter]);
+  if (!_optionalChain([filter, 'optionalAccess', _45 => _45.enabled]) || filter.rules.length === 0) return true;
   if (getRowSection(doc, rowIndex) !== "body") return true;
   return filter.rules.every((rule) => {
     const colIndex = doc.columns.findIndex((c) => c.id === rule.colId);
@@ -1095,7 +1181,7 @@ function rowPassesFilters(doc, rowIndex, getValue) {
   });
 }
 function computeRowGroups(doc, getValue) {
-  const grouping = _optionalChain([doc, 'access', _36 => _36.table, 'optionalAccess', _37 => _37.grouping]);
+  const grouping = _optionalChain([doc, 'access', _46 => _46.table, 'optionalAccess', _47 => _47.grouping]);
   if (!grouping) return [];
   const groupCol = doc.columns.findIndex((c) => c.id === grouping.colId);
   if (groupCol === -1) return [];
@@ -1125,9 +1211,9 @@ function computeRowGroups(doc, getValue) {
 }
 function buildSpreadsheetView(doc, getValue) {
   const { headerRows, footerRows } = getTableSections(doc);
-  const frozenRows = clampCount(_optionalChain([doc, 'access', _38 => _38.table, 'optionalAccess', _39 => _39.frozenRowCount]), doc.rows.length);
-  const frozenCols = clampCount(_optionalChain([doc, 'access', _40 => _40.table, 'optionalAccess', _41 => _41.frozenColumnCount]), doc.columns.length);
-  const headerCols = clampCount(_optionalChain([doc, 'access', _42 => _42.table, 'optionalAccess', _43 => _43.headerColumnCount]), doc.columns.length);
+  const frozenRows = clampCount(_optionalChain([doc, 'access', _48 => _48.table, 'optionalAccess', _49 => _49.frozenRowCount]), doc.rows.length);
+  const frozenCols = clampCount(_optionalChain([doc, 'access', _50 => _50.table, 'optionalAccess', _51 => _51.frozenColumnCount]), doc.columns.length);
+  const headerCols = clampCount(_optionalChain([doc, 'access', _52 => _52.table, 'optionalAccess', _53 => _53.headerColumnCount]), doc.columns.length);
   const columns = [];
   let left = 0;
   let hiddenColumnCount = 0;
@@ -1157,7 +1243,7 @@ function buildSpreadsheetView(doc, getValue) {
     if (doc.rows[r].hidden) hiddenRowCount++;
     else if (!rowPassesFilters(doc, r, getValue)) filteredOutCount++;
   }
-  const grouping = _optionalChain([doc, 'access', _44 => _44.table, 'optionalAccess', _45 => _45.grouping]);
+  const grouping = _optionalChain([doc, 'access', _54 => _54.table, 'optionalAccess', _55 => _55.grouping]);
   if (grouping && doc.columns.some((c) => c.id === grouping.colId)) {
     for (const group of groups) {
       rows.push({ kind: "group", group });
@@ -1191,7 +1277,7 @@ function buildSpreadsheetView(doc, getValue) {
     while (run < visible.length && positions.get(visible[run]) === positions.get(visible[0]) + run) run++;
     return { first: visible[0], run };
   };
-  for (const raw of _nullishCoalesce(_optionalChain([doc, 'access', _46 => _46.table, 'optionalAccess', _47 => _47.merges]), () => ( []))) {
+  for (const raw of _nullishCoalesce(_optionalChain([doc, 'access', _56 => _56.table, 'optionalAccess', _57 => _57.merges]), () => ( []))) {
     const merge = normalizeRange(raw);
     const rowIdx = [];
     const colIdx = [];
@@ -1228,29 +1314,45 @@ function buildSpreadsheetView(doc, getValue) {
 
 // src/spreadsheet/controller.ts
 var nextIdSequence = 0;
+var DEFAULT_MAX_HISTORY_BYTES = 64 * 1024 * 1024;
+var MAX_SPILL_PASSES = 25;
+var spillCellId = (rowId, colId) => `${rowId}\0${colId}`;
 var SpreadsheetController = (_class3 = class {
   
-  __init4() {this.activeCell = null}
-  __init5() {this.selectedRange = null}
-  __init6() {this.editingCell = null}
-  __init7() {this.draftValue = ""}
-  __init8() {this.binder = new DataSourceBinder()}
-  __init9() {this.depGraph = new DependencyGraph()}
+  __init7() {this.activeCell = null}
+  __init8() {this.selectedRange = null}
+  __init9() {this.editingCell = null}
+  __init10() {this.draftValue = ""}
+  __init11() {this.binder = new DataSourceBinder()}
+  __init12() {this.depGraph = new DependencyGraph()}
   
   
   
   
   
   // History stack for undo/redo
-  __init10() {this.undoStack = []}
-  __init11() {this.redoStack = []}
-  __init12() {this.isApplyingHistory = false}
+  __init13() {this.undoStack = []}
+  __init14() {this.redoStack = []}
+  __init15() {this.isApplyingHistory = false}
+  
   // Set while importing TSV: history and recalculation are done once at the end.
-  __init13() {this.batching = false}
-  __init14() {this.pendingCommits = []}
+  __init16() {this.batching = false}
+  __init17() {this.pendingCommits = []}
   // Row being evaluated, so [property] references resolve per row.
-  __init15() {this.evaluatingRowIndex = null}
-  constructor(options = {}) {;_class3.prototype.__init4.call(this);_class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this);_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);_class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this);_class3.prototype.__init16.call(this);
+  __init18() {this.evaluatingRowIndex = null}
+  // Cell being evaluated, for implicit intersection (`=@A:A`).
+  __init19() {this.evaluatingCell = null}
+  // Dynamic arrays. Spilled values are derived state: they live here, not in
+  // the document, and every recalculation rebuilds them.
+  __init20() {this.spills = /* @__PURE__ */ new Map()}
+  // anchor key -> spill
+  __init21() {this.spilledBy = /* @__PURE__ */ new Map()}
+  // spilled cell key -> anchor key
+  __init22() {this.spillCells = /* @__PURE__ */ new Map()}
+  // spillCellId -> displayed cell
+  // Cells whose spill ownership changed during the current pass.
+  __init23() {this.spillChanges = null}
+  constructor(options = {}) {;_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);_class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this);_class3.prototype.__init16.call(this);_class3.prototype.__init17.call(this);_class3.prototype.__init18.call(this);_class3.prototype.__init19.call(this);_class3.prototype.__init20.call(this);_class3.prototype.__init21.call(this);_class3.prototype.__init22.call(this);_class3.prototype.__init23.call(this);_class3.prototype.__init24.call(this);
     const defaultCols = [
       { id: "col_a", key: "A", title: "A", width: 120, type: "freeform" },
       { id: "col_b", key: "B", title: "B", width: 120, type: "freeform" },
@@ -1264,28 +1366,32 @@ var SpreadsheetController = (_class3 = class {
       type: "freeform"
     }));
     this.document = {
-      id: _optionalChain([options, 'access', _48 => _48.document, 'optionalAccess', _49 => _49.id]) || `sheet_${Date.now()}`,
-      name: _optionalChain([options, 'access', _50 => _50.document, 'optionalAccess', _51 => _51.name]) || "Sheet 1",
-      columns: _optionalChain([options, 'access', _52 => _52.document, 'optionalAccess', _53 => _53.columns]) || defaultCols,
-      rows: _optionalChain([options, 'access', _54 => _54.document, 'optionalAccess', _55 => _55.rows]) || defaultRows,
-      cells: _optionalChain([options, 'access', _56 => _56.document, 'optionalAccess', _57 => _57.cells]) || {},
-      createdAt: _optionalChain([options, 'access', _58 => _58.document, 'optionalAccess', _59 => _59.createdAt]) || Date.now(),
-      updatedAt: _optionalChain([options, 'access', _60 => _60.document, 'optionalAccess', _61 => _61.updatedAt]) || Date.now(),
-      ..._optionalChain([options, 'access', _62 => _62.document, 'optionalAccess', _63 => _63.table]) ? { table: options.document.table } : {}
+      id: _optionalChain([options, 'access', _58 => _58.document, 'optionalAccess', _59 => _59.id]) || `sheet_${Date.now()}`,
+      name: _optionalChain([options, 'access', _60 => _60.document, 'optionalAccess', _61 => _61.name]) || "Sheet 1",
+      columns: _optionalChain([options, 'access', _62 => _62.document, 'optionalAccess', _63 => _63.columns]) || defaultCols,
+      rows: _optionalChain([options, 'access', _64 => _64.document, 'optionalAccess', _65 => _65.rows]) || defaultRows,
+      cells: _optionalChain([options, 'access', _66 => _66.document, 'optionalAccess', _67 => _67.cells]) || {},
+      createdAt: _optionalChain([options, 'access', _68 => _68.document, 'optionalAccess', _69 => _69.createdAt]) || Date.now(),
+      updatedAt: _optionalChain([options, 'access', _70 => _70.document, 'optionalAccess', _71 => _71.updatedAt]) || Date.now(),
+      ..._optionalChain([options, 'access', _72 => _72.document, 'optionalAccess', _73 => _73.table]) ? { table: options.document.table } : {}
     };
     this.primaryDataSourceId = options.primaryDataSourceId;
+    this.maxHistoryBytes = Math.max(0, _nullishCoalesce(options.maxHistoryBytes, () => ( DEFAULT_MAX_HISTORY_BYTES)));
     this.onDocumentChange = options.onDocumentChange;
     this.onSelectionChange = options.onSelectionChange;
     this.onCellCommit = options.onCellCommit;
     if (options.dataSources) {
       options.dataSources.forEach((ds) => this.binder.register(ds));
     }
-    this.evaluator = new (0, _chunkJYRIOFENcjs.FormulaEvaluator)({
+    this.evaluator = new (0, _chunkRIKBJLS2cjs.FormulaEvaluator)({
       resolveCell: (colStr, rowNum) => this.resolveCellByCoord(colStr, rowNum),
       resolveRange: (sCol, sRow, eCol, eRow) => this.resolveRangeByCoords(sCol, sRow, eCol, eRow),
-      resolveProperty: (prop) => this.resolveCurrentRowProperty(prop)
+      resolveProperty: (prop) => this.resolveCurrentRowProperty(prop),
+      resolveSpill: (colStr, rowNum) => this.resolveSpillByCoord(colStr, rowNum),
+      getFormulaCell: () => this.evaluatingCell
     });
     this.syncWithDataSource();
+    this.rederiveTypedValues();
     this.recalculateAll();
   }
   loadDocument(document) {
@@ -1297,9 +1403,63 @@ var SpreadsheetController = (_class3 = class {
     this.undoStack = [];
     this.redoStack = [];
     this.syncWithDataSource();
+    this.rederiveTypedValues();
     this.recalculateAll();
     this.notifyChange();
   }
+  /**
+   * Re-parses the value of every stored typed (non-formula) cell from its
+   * `raw` input, so documents saved before typed input was parsed (whose
+   * values are text such as `"120"`) compare and sort as numbers. Cells of
+   * bound columns in record rows keep their value: it belongs to the data
+   * source.
+   */
+  rederiveTypedValues() {
+    for (const row of this.document.rows) {
+      const cells = this.document.cells[row.id];
+      if (!cells) continue;
+      for (const col of this.document.columns) {
+        const cell = cells[col.id];
+        if (!cell || typeof cell.raw !== "string" || cell.raw.startsWith("=")) continue;
+        if (col.type === "bound" && col.binding && row.recordId) continue;
+        const typed = this.typedCell(cell.raw, cell.format);
+        cell.value = typed.value;
+        if (typed.numberFormat) cell.numberFormat = typed.numberFormat;
+        else delete cell.numberFormat;
+        if (typed.format) cell.format = typed.format;
+      }
+    }
+  }
+  /**
+   * Value of typed (non-formula) input: a number, boolean, ISO date, error
+   * or text (see `parseCellInput`), its automatic number format, and the
+   * `CellFormat` to use: the automatic one (currency, percentage, date,
+   * number) when `format` is unset or `text` (the default of new columns).
+   */
+  typedCell(raw, format) {
+    const parsed = _chunkRIKBJLS2cjs.parseCellInput.call(void 0, raw);
+    return {
+      value: parsed.value,
+      ...parsed.numberFormat ? { numberFormat: parsed.numberFormat } : {},
+      format: parsed.cellFormat && (!format || format === "text") ? parsed.cellFormat : format
+    };
+  }
+  /**
+   * Typed input for a bound field, coerced by the field's declared type:
+   * number, boolean and date fields get a number, boolean or ISO date when
+   * the input parses as one; string and enum fields (and unknown fields)
+   * keep the text exactly as typed.
+   */
+  boundInputValue(dataSourceId, field, raw) {
+    if (raw.startsWith("=")) return raw;
+    const type = _optionalChain([this, 'access', _74 => _74.binder, 'access', _75 => _75.getDataSource, 'call', _76 => _76(dataSourceId), 'optionalAccess', _77 => _77.getFields, 'call', _78 => _78(), 'access', _79 => _79.find, 'call', _80 => _80((f) => f.key === field), 'optionalAccess', _81 => _81.type]);
+    if (type !== "number" && type !== "boolean" && type !== "date") return raw;
+    const parsed = _chunkRIKBJLS2cjs.parseCellInput.call(void 0, raw);
+    if (type === "number" && parsed.type === "number") return parsed.value;
+    if (type === "boolean" && parsed.type === "boolean") return parsed.value;
+    if (type === "date" && parsed.type === "date") return parsed.value;
+    return raw;
+  }
   registerDataSource(ds) {
     this.binder.register(ds);
     this.syncWithDataSource();
@@ -1320,7 +1480,7 @@ var SpreadsheetController = (_class3 = class {
       r.index = idx;
     });
     this.document.columns.forEach((c, idx) => {
-      c.key = _chunkJYRIOFENcjs.indexToColName.call(void 0, idx);
+      c.key = _chunkRIKBJLS2cjs.indexToColName.call(void 0, idx);
     });
   }
   getColumn(colIdOrKey) {
@@ -1335,7 +1495,12 @@ var SpreadsheetController = (_class3 = class {
     return this.document.rows.find((r) => r.id === rowIdOrIndex);
   }
   getCell(rowId, colId) {
-    const existing = _optionalChain([this, 'access', _64 => _64.document, 'access', _65 => _65.cells, 'access', _66 => _66[rowId], 'optionalAccess', _67 => _67[colId]]);
+    const existing = _optionalChain([this, 'access', _82 => _82.document, 'access', _83 => _83.cells, 'access', _84 => _84[rowId], 'optionalAccess', _85 => _85[colId]]);
+    if (existing && existing.raw !== "") return existing;
+    if (this.spillCells.size > 0) {
+      const spilled = this.spillCells.get(spillCellId(rowId, colId));
+      if (spilled) return spilled;
+    }
     if (existing) return existing;
     const col = this.document.columns.find((c) => c.id === colId);
     const row = this.document.rows.find((r) => r.id === rowId);
@@ -1362,7 +1527,7 @@ var SpreadsheetController = (_class3 = class {
         format: col.format
       };
     }
-    return { raw: "", value: "", format: _optionalChain([col, 'optionalAccess', _68 => _68.format]) };
+    return { raw: "", value: "", format: _optionalChain([col, 'optionalAccess', _86 => _86.format]) };
   }
   setCellValue(rowId, colId, raw) {
     this.recordSnapshot();
@@ -1371,21 +1536,20 @@ var SpreadsheetController = (_class3 = class {
     }
     const col = this.document.columns.find((c) => c.id === colId);
     const row = this.document.rows.find((r) => r.id === rowId);
-    if (_optionalChain([col, 'optionalAccess', _69 => _69.type]) === "bound" && col.binding && _optionalChain([row, 'optionalAccess', _70 => _70.recordId])) {
-      this.binder.commitBoundValue(
-        col.binding.dataSource,
-        row.recordId,
-        col.binding.field,
-        raw
-      );
+    const isFormula = raw.startsWith("=");
+    let cell;
+    if (_optionalChain([col, 'optionalAccess', _87 => _87.type]) === "bound" && col.binding && _optionalChain([row, 'optionalAccess', _88 => _88.recordId])) {
+      const value = this.boundInputValue(col.binding.dataSource, col.binding.field, raw);
+      this.binder.commitBoundValue(col.binding.dataSource, row.recordId, col.binding.field, value);
+      cell = { raw, value, format: col.format };
+    } else if (isFormula) {
+      cell = { raw, value: raw, format: _optionalChain([col, 'optionalAccess', _89 => _89.format]) };
+    } else {
+      cell = { raw, ...this.typedCell(raw, _optionalChain([col, 'optionalAccess', _90 => _90.format])) };
     }
     const cellKey = this.getCellKey(rowId, colId);
-    this.depGraph.setCellFormula(cellKey, raw.startsWith("=") ? raw : null);
-    this.document.cells[rowId][colId] = {
-      raw,
-      value: raw,
-      format: _optionalChain([col, 'optionalAccess', _71 => _71.format])
-    };
+    this.depGraph.setCellFormula(cellKey, isFormula ? raw : null);
+    this.document.cells[rowId][colId] = cell;
     this.document.updatedAt = Date.now();
     if (this.batching) {
       this.pendingCommits.push([rowId, colId, raw]);
@@ -1393,8 +1557,8 @@ var SpreadsheetController = (_class3 = class {
     }
     this.recalculateCell(rowId, colId);
     this.notifyChange();
-    const evaluatedVal = _optionalChain([this, 'access', _72 => _72.document, 'access', _73 => _73.cells, 'access', _74 => _74[rowId], 'access', _75 => _75[colId], 'optionalAccess', _76 => _76.value]);
-    _optionalChain([this, 'access', _77 => _77.onCellCommit, 'optionalCall', _78 => _78(rowId, colId, raw, evaluatedVal)]);
+    const evaluatedVal = _optionalChain([this, 'access', _91 => _91.document, 'access', _92 => _92.cells, 'access', _93 => _93[rowId], 'access', _94 => _94[colId], 'optionalAccess', _95 => _95.value]);
+    _optionalChain([this, 'access', _96 => _96.onCellCommit, 'optionalCall', _97 => _97(rowId, colId, raw, evaluatedVal)]);
   }
   getCellKey(rowId, colId) {
     const row = this.document.rows.find((r) => r.id === rowId);
@@ -1408,7 +1572,30 @@ var SpreadsheetController = (_class3 = class {
    */
   recalculateCell(rowId, colId) {
     const cellKey = this.getCellKey(rowId, colId);
-    this.runEvaluationPlan(this.depGraph.getEvaluationPlan([cellKey], { includeDependents: true }));
+    const anchor = this.spilledBy.get(cellKey);
+    this.recalculateKeys(anchor ? [cellKey, anchor] : [cellKey], true);
+  }
+  /**
+   * Recalculates `keys` (and, with `includeDependents`, their dependents) in
+   * dependency order. Spill ranges are only known after evaluating their
+   * anchors, so when a pass changes which cells hold spilled values (and so
+   * the dependency graph), the dependents of those cells are recalculated in
+   * another pass, until nothing changes.
+   */
+  recalculateKeys(keys, includeDependents) {
+    let pending = Array.from(keys);
+    let withDependents = includeDependents;
+    for (let pass = 0; pass < MAX_SPILL_PASSES && pending.length > 0; pass++) {
+      const changed = /* @__PURE__ */ new Set();
+      this.spillChanges = changed;
+      try {
+        this.runEvaluationPlan(this.depGraph.getEvaluationPlan(pending, { includeDependents: withDependents }));
+      } finally {
+        this.spillChanges = null;
+      }
+      pending = Array.from(changed);
+      withDependents = true;
+    }
   }
   /**
    * Rebuilds the dependency graph from scratch and recalculates every formula
@@ -1416,10 +1603,13 @@ var SpreadsheetController = (_class3 = class {
    */
   recalculateAll() {
     this.depGraph.clear();
+    this.spills.clear();
+    this.spilledBy.clear();
+    this.spillCells.clear();
     const formulaKeys = [];
     for (const row of this.document.rows) {
       for (const col of this.document.columns) {
-        const cell = _nullishCoalesce(_optionalChain([this, 'access', _79 => _79.document, 'access', _80 => _80.cells, 'access', _81 => _81[row.id], 'optionalAccess', _82 => _82[col.id]]), () => ( this.getDerivedCell(row, col)));
+        const cell = _nullishCoalesce(_optionalChain([this, 'access', _98 => _98.document, 'access', _99 => _99.cells, 'access', _100 => _100[row.id], 'optionalAccess', _101 => _101[col.id]]), () => ( this.getDerivedCell(row, col)));
         if (cell.raw.startsWith("=")) {
           const cellKey = `${col.key}${row.index + 1}`.toUpperCase();
           this.depGraph.setCellFormula(cellKey, cell.raw);
@@ -1427,7 +1617,7 @@ var SpreadsheetController = (_class3 = class {
         }
       }
     }
-    this.runEvaluationPlan(this.depGraph.getEvaluationPlan(formulaKeys));
+    this.recalculateKeys(formulaKeys, false);
   }
   runEvaluationPlan(plan) {
     for (const key of plan.order) {
@@ -1454,7 +1644,10 @@ var SpreadsheetController = (_class3 = class {
     if (!this.document.cells[row.id]) this.document.cells[row.id] = {};
     const deps = this.depGraph.getDependencies(cellKey);
     const selfReference = deps.includes(cellKey) || deps.includes(`${col.key.toUpperCase()}:`);
-    const errorMessage = selfReference ? "This formula can't reference its own cell." : "This formula is part of a circular reference: it depends on its own result through other cells.";
+    const spilledKeys = this.depGraph.getSpilledKeys(cellKey);
+    const ownSpill = deps.find((dep) => spilledKeys.includes(dep));
+    const errorMessage = selfReference ? "This formula can't reference its own cell." : ownSpill ? `This formula refers to ${ownSpill}, which holds its own spilled results (a circular reference).` : "This formula is part of a circular reference: it depends on its own result through other cells.";
+    this.clearSpill(cellKey.toUpperCase(), true);
     this.document.cells[row.id][col.id] = { ...cell, value: "#CYCLE!", error: "#CYCLE!", errorMessage };
   }
   evalSingleCellByKey(cellKey) {
@@ -1471,26 +1664,177 @@ var SpreadsheetController = (_class3 = class {
         cell.error = void 0;
         cell.errorMessage = void 0;
       }
+      this.clearSpill(`${colName}${rowNum}`);
       return;
     }
     try {
       this.evaluatingRowIndex = rowNum - 1;
+      this.evaluatingCell = { col: colName, row: rowNum };
       const result = this.evaluator.evaluateWithDiagnostics(cell.raw);
       if (!this.document.cells[row.id]) {
         this.document.cells[row.id] = {};
       }
+      let { value, error, message } = result;
+      if (result.array) {
+        const blocked = this.placeSpill(`${colName}${rowNum}`, rowNum - 1, this.document.columns.indexOf(col), result.array);
+        if (blocked) {
+          value = "#SPILL!";
+          error = "#SPILL!";
+          message = blocked;
+        }
+      } else {
+        this.clearSpill(`${colName}${rowNum}`);
+      }
       this.document.cells[row.id][col.id] = {
         ...cell,
-        value: result.value,
+        value,
         // `#ERROR!` (malformed formula, wrong argument count) keeps its
         // message in `error`, as before; other errors store their code.
-        error: result.error === "#ERROR!" ? result.message : result.error,
-        errorMessage: result.message
+        error: error === "#ERROR!" ? message : error,
+        errorMessage: message
       };
     } finally {
       this.evaluatingRowIndex = null;
+      this.evaluatingCell = null;
     }
   }
+  // --- Dynamic arrays (spilling) ---
+  /**
+   * Spills `array` from the anchor at (row, col) into the cells below and to
+   * the right. Returns why it can't (the anchor then shows `#SPILL!`), or
+   * null once placed. The grid never grows to fit an array, as in Excel.
+   */
+  placeSpill(anchor, row, col, array) {
+    const { rows, cols } = array;
+    const area = { startRow: row, startCol: col, endRow: row + rows - 1, endCol: col + cols - 1 };
+    const label = `${_chunkRIKBJLS2cjs.indexToColName.call(void 0, area.startCol)}${area.startRow + 1}:${_chunkRIKBJLS2cjs.indexToColName.call(void 0, area.endCol)}${area.endRow + 1}`;
+    let reason = null;
+    const blockers = [];
+    if (area.endRow >= this.document.rows.length || area.endCol >= this.document.columns.length) {
+      reason = `The ${rows}\xD7${cols} result needs ${label}, which extends past the edge of the sheet.`;
+    } else if (this.getMerges().some((m) => rangesIntersect(m, area))) {
+      reason = `The result can't spill into merged cells (it needs ${label}).`;
+    } else {
+      for (let c = area.startCol; c <= area.endCol; c++) {
+        const column = this.document.columns[c];
+        for (let r = area.startRow; r <= area.endRow; r++) {
+          if (r === row && c === col) continue;
+          const rowObj = this.document.rows[r];
+          const key = `${column.key}${r + 1}`.toUpperCase();
+          const stored = _optionalChain([this, 'access', _102 => _102.document, 'access', _103 => _103.cells, 'access', _104 => _104[rowObj.id], 'optionalAccess', _105 => _105[column.id]]);
+          const raw = stored ? stored.raw : this.getDerivedCell(rowObj, column).raw;
+          const owner = this.spilledBy.get(key);
+          if (raw !== "") {
+            blockers.push(key);
+            reason ??= `The result needs ${label}, but ${key} isn't empty.`;
+          } else if (owner && owner !== anchor) {
+            blockers.push(key);
+            reason ??= `The result needs ${label}, but ${key} already holds values spilled from ${owner}.`;
+          }
+        }
+      }
+    }
+    if (reason) {
+      this.clearSpill(anchor);
+      this.depGraph.setSpillEdges(anchor, [], blockers);
+      return reason;
+    }
+    const previous = this.spills.get(anchor);
+    const cells = [];
+    for (let c = 0; c < cols; c++) {
+      const column = this.document.columns[col + c];
+      for (let r = 0; r < rows; r++) {
+        if (r === 0 && c === 0) continue;
+        const rowObj = this.document.rows[row + r];
+        const key = `${column.key}${row + r + 1}`.toUpperCase();
+        const value = _nullishCoalesce(array.values[c * rows + r], () => ( ""));
+        const display = { raw: "", value, format: column.format, spillAnchor: anchor };
+        if (_chunkRIKBJLS2cjs.isFormulaError.call(void 0, value)) {
+          display.error = value;
+          display.errorMessage = _chunkRIKBJLS2cjs.describeFormulaError.call(void 0, value);
+        }
+        this.spillCells.set(spillCellId(rowObj.id, column.id), display);
+        if (this.spilledBy.get(key) !== anchor) {
+          this.spilledBy.set(key, anchor);
+          _optionalChain([this, 'access', _106 => _106.spillChanges, 'optionalAccess', _107 => _107.add, 'call', _108 => _108(key)]);
+        }
+        cells.push({ key, rowId: rowObj.id, colId: column.id });
+      }
+    }
+    if (previous) {
+      const kept = new Set(cells.map((cell) => cell.key));
+      for (const old of previous.cells) {
+        if (kept.has(old.key)) continue;
+        this.forgetSpilledCell(anchor, old);
+      }
+    }
+    this.spills.set(anchor, { anchor, row, col, rows, cols, values: array.values, cells });
+    this.depGraph.setSpillEdges(anchor, cells.map((cell) => cell.key));
+    return null;
+  }
+  /** Removes the array spilled from `anchor`. With `keepEdges`, its dependency edges stay. */
+  clearSpill(anchor, keepEdges = false) {
+    const record = this.spills.get(anchor);
+    if (record) {
+      for (const cell of record.cells) this.forgetSpilledCell(anchor, cell);
+      this.spills.delete(anchor);
+    }
+    if (!keepEdges) this.depGraph.setSpillEdges(anchor, []);
+  }
+  forgetSpilledCell(anchor, cell) {
+    if (this.spilledBy.get(cell.key) !== anchor) return;
+    this.spilledBy.delete(cell.key);
+    this.spillCells.delete(spillCellId(cell.rowId, cell.colId));
+    _optionalChain([this, 'access', _109 => _109.spillChanges, 'optionalAccess', _110 => _110.add, 'call', _111 => _111(cell.key)]);
+  }
+  resolveSpillByCoord(colStr, rowNum) {
+    const record = this.spills.get(`${colStr}${rowNum}`.toUpperCase());
+    if (record) return { rows: record.rows, cols: record.cols, values: record.values };
+    const value = this.resolveCellByCoord(colStr, rowNum);
+    return _chunkRIKBJLS2cjs.isFormulaError.call(void 0, value) ? value : "#REF!";
+  }
+  toSpill(record) {
+    const row = this.document.rows[record.row];
+    const col = this.document.columns[record.col];
+    return {
+      key: record.anchor,
+      anchor: { row: record.row, col: record.col },
+      range: {
+        startRow: record.row,
+        startCol: record.col,
+        endRow: record.row + record.rows - 1,
+        endCol: record.col + record.cols - 1
+      },
+      formula: row && col ? this.getCell(row.id, col.id).raw : ""
+    };
+  }
+  /**
+   * The dynamic array covering (row, col), whether it is the anchor (the cell
+   * holding the formula) or a spilled cell; null when there is none.
+   */
+  getSpillAt(row, col) {
+    if (this.spills.size === 0) return null;
+    const key = `${_chunkRIKBJLS2cjs.indexToColName.call(void 0, col)}${row + 1}`;
+    const record = _nullishCoalesce(this.spills.get(key), () => ( this.spills.get(_nullishCoalesce(this.spilledBy.get(key), () => ( "")))));
+    return record ? this.toSpill(record) : null;
+  }
+  /** Every dynamic array currently spilled. */
+  getSpills() {
+    return Array.from(this.spills.values(), (record) => this.toSpill(record));
+  }
+  /** Whether `range` overlaps a spilled array (its anchor or spilled cells). */
+  intersectsSpill(range) {
+    for (const record of this.spills.values()) {
+      const area = {
+        startRow: record.row,
+        startCol: record.col,
+        endRow: record.row + record.rows - 1,
+        endCol: record.col + record.cols - 1
+      };
+      if (rangesIntersect(area, range)) return true;
+    }
+    return false;
+  }
   resolveCellByCoord(colStr, rowNum) {
     const col = this.document.columns.find((c) => c.key.toUpperCase() === colStr.toUpperCase());
     const row = this.document.rows[rowNum - 1];
@@ -1498,15 +1842,15 @@ var SpreadsheetController = (_class3 = class {
     return _nullishCoalesce(this.getCell(row.id, col.id).value, () => ( ""));
   }
   resolveRangeByCoords(sCol, sRow, eCol, eRow) {
-    const startC = _chunkJYRIOFENcjs.colNameToIndex.call(void 0, sCol);
-    const endC = _chunkJYRIOFENcjs.colNameToIndex.call(void 0, eCol);
+    const startC = _chunkRIKBJLS2cjs.colNameToIndex.call(void 0, sCol);
+    const endC = _chunkRIKBJLS2cjs.colNameToIndex.call(void 0, eCol);
     const minC = Math.min(startC, endC);
     const maxC = Math.max(startC, endC);
     const minR = Math.min(sRow, eRow);
-    const maxR = Math.min(Math.max(sRow, eRow), _chunkJYRIOFENcjs.WHOLE_COLUMN_END_ROW, this.document.rows.length);
+    const maxR = Math.min(Math.max(sRow, eRow), _chunkRIKBJLS2cjs.WHOLE_COLUMN_END_ROW, this.document.rows.length);
     const results = [];
     for (let c = minC; c <= maxC; c++) {
-      const colName = _chunkJYRIOFENcjs.indexToColName.call(void 0, c);
+      const colName = _chunkRIKBJLS2cjs.indexToColName.call(void 0, c);
       const col = this.document.columns.find((colDef) => colDef.key.toUpperCase() === colName);
       if (!col) continue;
       for (let r = minR; r <= maxR; r++) {
@@ -1518,7 +1862,7 @@ var SpreadsheetController = (_class3 = class {
     return results;
   }
   resolveCurrentRowProperty(prop) {
-    const rowIndex = _nullishCoalesce(this.evaluatingRowIndex, () => ( _optionalChain([this, 'access', _83 => _83.activeCell, 'optionalAccess', _84 => _84.row])));
+    const rowIndex = _nullishCoalesce(this.evaluatingRowIndex, () => ( _optionalChain([this, 'access', _112 => _112.activeCell, 'optionalAccess', _113 => _113.row])));
     if (rowIndex === void 0 || rowIndex === null) return 0;
     const row = this.document.rows[rowIndex];
     if (!row || !row.recordId || !this.primaryDataSourceId) return 0;
@@ -1536,8 +1880,8 @@ var SpreadsheetController = (_class3 = class {
     this.activeCell = {
       row: activeRow,
       col: activeCol,
-      rowId: _optionalChain([rowObj, 'optionalAccess', _85 => _85.id]),
-      colId: _optionalChain([colObj, 'optionalAccess', _86 => _86.id])
+      rowId: _optionalChain([rowObj, 'optionalAccess', _114 => _114.id]),
+      colId: _optionalChain([colObj, 'optionalAccess', _115 => _115.id])
     };
     if (extendSelection && this.selectedRange) {
       this.selectedRange = this.expandRangeToMerges({
@@ -1556,16 +1900,16 @@ var SpreadsheetController = (_class3 = class {
         endCol: clampedCol
       };
     }
-    _optionalChain([this, 'access', _87 => _87.onSelectionChange, 'optionalCall', _88 => _88(this.activeCell, this.selectedRange)]);
+    _optionalChain([this, 'access', _116 => _116.onSelectionChange, 'optionalCall', _117 => _117(this.activeCell, this.selectedRange)]);
   }
   selectRange(range) {
     this.selectedRange = range;
-    _optionalChain([this, 'access', _89 => _89.onSelectionChange, 'optionalCall', _90 => _90(this.activeCell, this.selectedRange)]);
+    _optionalChain([this, 'access', _118 => _118.onSelectionChange, 'optionalCall', _119 => _119(this.activeCell, this.selectedRange)]);
   }
   startEditing(row, col, initialValue) {
-    this.selectCell(_nullishCoalesce(_nullishCoalesce(row, () => ( _optionalChain([this, 'access', _91 => _91.activeCell, 'optionalAccess', _92 => _92.row]))), () => ( 0)), _nullishCoalesce(_nullishCoalesce(col, () => ( _optionalChain([this, 'access', _93 => _93.activeCell, 'optionalAccess', _94 => _94.col]))), () => ( 0)));
-    const targetRow = _nullishCoalesce(_optionalChain([this, 'access', _95 => _95.activeCell, 'optionalAccess', _96 => _96.row]), () => ( 0));
-    const targetCol = _nullishCoalesce(_optionalChain([this, 'access', _97 => _97.activeCell, 'optionalAccess', _98 => _98.col]), () => ( 0));
+    this.selectCell(_nullishCoalesce(_nullishCoalesce(row, () => ( _optionalChain([this, 'access', _120 => _120.activeCell, 'optionalAccess', _121 => _121.row]))), () => ( 0)), _nullishCoalesce(_nullishCoalesce(col, () => ( _optionalChain([this, 'access', _122 => _122.activeCell, 'optionalAccess', _123 => _123.col]))), () => ( 0)));
+    const targetRow = _nullishCoalesce(_optionalChain([this, 'access', _124 => _124.activeCell, 'optionalAccess', _125 => _125.row]), () => ( 0));
+    const targetCol = _nullishCoalesce(_optionalChain([this, 'access', _126 => _126.activeCell, 'optionalAccess', _127 => _127.col]), () => ( 0));
     const rowObj = this.document.rows[targetRow];
     const colObj = this.document.columns[targetCol];
     if (!rowObj || !colObj) return;
@@ -1619,17 +1963,17 @@ var SpreadsheetController = (_class3 = class {
   // --- Grid Structure Mutations ---
   insertColumn(index, config) {
     this.recordSnapshot();
-    const newId = _optionalChain([config, 'optionalAccess', _99 => _99.id]) || this.generateId("col");
+    const newId = _optionalChain([config, 'optionalAccess', _128 => _128.id]) || this.generateId("col");
     const newCol = {
       id: newId,
-      key: _chunkJYRIOFENcjs.indexToColName.call(void 0, index),
-      title: _optionalChain([config, 'optionalAccess', _100 => _100.title]) || _chunkJYRIOFENcjs.indexToColName.call(void 0, index),
-      width: _optionalChain([config, 'optionalAccess', _101 => _101.width]) || 130,
-      type: _optionalChain([config, 'optionalAccess', _102 => _102.type]) || "freeform",
-      binding: _optionalChain([config, 'optionalAccess', _103 => _103.binding]),
-      formula: _optionalChain([config, 'optionalAccess', _104 => _104.formula]),
-      format: _optionalChain([config, 'optionalAccess', _105 => _105.format]) || "text",
-      readOnly: _optionalChain([config, 'optionalAccess', _106 => _106.readOnly])
+      key: _chunkRIKBJLS2cjs.indexToColName.call(void 0, index),
+      title: _optionalChain([config, 'optionalAccess', _129 => _129.title]) || _chunkRIKBJLS2cjs.indexToColName.call(void 0, index),
+      width: _optionalChain([config, 'optionalAccess', _130 => _130.width]) || 130,
+      type: _optionalChain([config, 'optionalAccess', _131 => _131.type]) || "freeform",
+      binding: _optionalChain([config, 'optionalAccess', _132 => _132.binding]),
+      formula: _optionalChain([config, 'optionalAccess', _133 => _133.formula]),
+      format: _optionalChain([config, 'optionalAccess', _134 => _134.format]) || "text",
+      readOnly: _optionalChain([config, 'optionalAccess', _135 => _135.readOnly])
     };
     this.shiftReferences({ axis: "col", index, type: "insert" });
     this.adjustTableForStructuralChange({ axis: "col", index, type: "insert" });
@@ -1654,13 +1998,13 @@ var SpreadsheetController = (_class3 = class {
   }
   insertRow(index, config) {
     this.recordSnapshot();
-    const newId = _optionalChain([config, 'optionalAccess', _107 => _107.id]) || this.generateId("row");
+    const newId = _optionalChain([config, 'optionalAccess', _136 => _136.id]) || this.generateId("row");
     const newRow = {
       id: newId,
       index,
-      height: _optionalChain([config, 'optionalAccess', _108 => _108.height]) || 32,
-      recordId: _optionalChain([config, 'optionalAccess', _109 => _109.recordId]),
-      type: _optionalChain([config, 'optionalAccess', _110 => _110.type]) || "freeform"
+      height: _optionalChain([config, 'optionalAccess', _137 => _137.height]) || 32,
+      recordId: _optionalChain([config, 'optionalAccess', _138 => _138.recordId]),
+      type: _optionalChain([config, 'optionalAccess', _139 => _139.type]) || "freeform"
     };
     this.shiftReferences({ axis: "row", index, type: "insert" });
     this.adjustTableForStructuralChange({ axis: "row", index, type: "insert" });
@@ -1691,14 +2035,14 @@ var SpreadsheetController = (_class3 = class {
   shiftReferences(change) {
     for (const rowCells of Object.values(this.document.cells)) {
       for (const cell of Object.values(rowCells)) {
-        if (_optionalChain([cell, 'access', _111 => _111.raw, 'optionalAccess', _112 => _112.startsWith, 'call', _113 => _113("=")])) {
+        if (_optionalChain([cell, 'access', _140 => _140.raw, 'optionalAccess', _141 => _141.startsWith, 'call', _142 => _142("=")])) {
           cell.raw = shiftFormulaReferences(cell.raw, change);
         }
       }
     }
     if (change.axis === "col") {
       for (const col of this.document.columns) {
-        if (_optionalChain([col, 'access', _114 => _114.formula, 'optionalAccess', _115 => _115.startsWith, 'call', _116 => _116("=")])) {
+        if (_optionalChain([col, 'access', _143 => _143.formula, 'optionalAccess', _144 => _144.startsWith, 'call', _145 => _145("=")])) {
           col.formula = shiftFormulaReferences(col.formula, change);
         }
       }
@@ -1721,7 +2065,7 @@ var SpreadsheetController = (_class3 = class {
     let maxLen = (col.title || "").length + (col.key ? col.key.length + 3 : 0);
     for (const row of this.document.rows) {
       const cell = this.getCell(row.id, col.id);
-      const valStr = cell.value != null ? String(cell.value) : "";
+      const valStr = _chunkRIKBJLS2cjs.formatCellDisplay.call(void 0, cell);
       if (valStr.length > maxLen) {
         maxLen = valStr.length;
       }
@@ -1745,8 +2089,7 @@ var SpreadsheetController = (_class3 = class {
     ) : this.document.columns;
     return rows.map(
       (row) => columns.map((col) => {
-        const cell = this.getCell(row.id, col.id);
-        return String(_nullishCoalesce(cell.value, () => ( ""))).replace(/\t/g, " ");
+        return _chunkRIKBJLS2cjs.formatCellDisplay.call(void 0, this.getCell(row.id, col.id)).replace(/\t/g, " ");
       }).join("	")
     ).join("\n");
   }
@@ -1766,7 +2109,7 @@ var SpreadsheetController = (_class3 = class {
       this.document.rows.push({ id: this.generateId("row"), index, height: 32, type: "freeform" });
     }
     while (colIndex >= this.document.columns.length) {
-      const key = _chunkJYRIOFENcjs.indexToColName.call(void 0, this.document.columns.length);
+      const key = _chunkRIKBJLS2cjs.indexToColName.call(void 0, this.document.columns.length);
       this.document.columns.push({
         id: this.generateId("col"),
         key,
@@ -1813,7 +2156,7 @@ var SpreadsheetController = (_class3 = class {
     const commits = this.pendingCommits;
     this.pendingCommits = [];
     for (const [rowId, colId, raw] of commits) {
-      _optionalChain([this, 'access', _117 => _117.onCellCommit, 'optionalCall', _118 => _118(rowId, colId, raw, _optionalChain([this, 'access', _119 => _119.document, 'access', _120 => _120.cells, 'access', _121 => _121[rowId], 'optionalAccess', _122 => _122[colId], 'optionalAccess', _123 => _123.value]))]);
+      _optionalChain([this, 'access', _146 => _146.onCellCommit, 'optionalCall', _147 => _147(rowId, colId, raw, _optionalChain([this, 'access', _148 => _148.document, 'access', _149 => _149.cells, 'access', _150 => _150[rowId], 'optionalAccess', _151 => _151[colId], 'optionalAccess', _152 => _152.value]))]);
     }
   }
   // --- CSV ---
@@ -1823,7 +2166,7 @@ var SpreadsheetController = (_class3 = class {
    */
   exportToCsv(options = {}) {
     const matrix = this.readMatrix(_nullishCoalesce(options.range, () => ( null))).map(
-      (row) => row.map((cell) => options.formulas ? cell.raw : String(_nullishCoalesce(cell.value, () => ( ""))))
+      (row) => row.map((cell) => options.formulas ? cell.raw : _chunkRIKBJLS2cjs.formatCellDisplay.call(void 0, cell))
     );
     return serializeCsv(matrix, {
       delimiter: options.delimiter,
@@ -1861,7 +2204,16 @@ var SpreadsheetController = (_class3 = class {
    */
   copyToClipboardData(range = this.selectedRange) {
     const r = range ? normalizeRange(range) : { startRow: 0, startCol: 0, endRow: this.document.rows.length - 1, endCol: this.document.columns.length - 1 };
-    const cells = this.readMatrix(r).map((row) => row.map((cell) => ({ raw: cell.raw, value: cell.error || cell.value })));
+    const cells = this.readMatrix(r).map(
+      (row) => row.map((cell) => {
+        const value = cell.error || cell.value;
+        const text = _chunkRIKBJLS2cjs.formatCellDisplay.call(void 0, cell);
+        if (cell.spillAnchor && !this.spillAnchorInRange(cell.spillAnchor, r)) {
+          return { raw: text, value, text };
+        }
+        return { raw: cell.raw, value, text };
+      })
+    );
     return createSpreadsheetClipboardData(cells, { row: r.startRow, col: r.startCol });
   }
   /**
@@ -1884,12 +2236,16 @@ var SpreadsheetController = (_class3 = class {
     this.selectRange(r);
     return true;
   }
+  spillAnchorInRange(anchor, range) {
+    const record = this.spills.get(anchor);
+    return !!record && rangeContains(range, record.row, record.col);
+  }
   getSelectionTopLeft() {
     if (this.selectedRange) {
       const r = normalizeRange(this.selectedRange);
       return { row: r.startRow, col: r.startCol };
     }
-    return { row: _nullishCoalesce(_optionalChain([this, 'access', _124 => _124.activeCell, 'optionalAccess', _125 => _125.row]), () => ( 0)), col: _nullishCoalesce(_optionalChain([this, 'access', _126 => _126.activeCell, 'optionalAccess', _127 => _127.col]), () => ( 0)) };
+    return { row: _nullishCoalesce(_optionalChain([this, 'access', _153 => _153.activeCell, 'optionalAccess', _154 => _154.row]), () => ( 0)), col: _nullishCoalesce(_optionalChain([this, 'access', _155 => _155.activeCell, 'optionalAccess', _156 => _156.col]), () => ( 0)) };
   }
   // --- Table operations: shared helpers ---
   /** The table settings object, created on first use. */
@@ -1913,7 +2269,7 @@ var SpreadsheetController = (_class3 = class {
     const { headerRows, footerRows } = getTableSections(this.document);
     return { start: headerRows, end: this.document.rows.length - footerRows - 1 };
   }
-  __init16() {this.getCellValueAt = (rowIndex, colIndex) => {
+  __init24() {this.getCellValueAt = (rowIndex, colIndex) => {
     const row = this.document.rows[rowIndex];
     const col = this.document.columns[colIndex];
     if (!row || !col) return "";
@@ -1923,7 +2279,7 @@ var SpreadsheetController = (_class3 = class {
   remapAllFormulas(moveCell) {
     for (const rowCells of Object.values(this.document.cells)) {
       for (const cell of Object.values(rowCells)) {
-        if (_optionalChain([cell, 'access', _128 => _128.raw, 'optionalAccess', _129 => _129.startsWith, 'call', _130 => _130("=")])) {
+        if (_optionalChain([cell, 'access', _157 => _157.raw, 'optionalAccess', _158 => _158.startsWith, 'call', _159 => _159("=")])) {
           cell.raw = remapFormulaReferences(cell.raw, moveCell);
         }
       }
@@ -1935,8 +2291,8 @@ var SpreadsheetController = (_class3 = class {
    * merges reduced to a single cell are dropped.
    */
   adjustTableForStructuralChange(change) {
-    const merges = _optionalChain([this, 'access', _131 => _131.document, 'access', _132 => _132.table, 'optionalAccess', _133 => _133.merges]);
-    if (!_optionalChain([merges, 'optionalAccess', _134 => _134.length])) return;
+    const merges = _optionalChain([this, 'access', _160 => _160.document, 'access', _161 => _161.table, 'optionalAccess', _162 => _162.merges]);
+    if (!_optionalChain([merges, 'optionalAccess', _163 => _163.length])) return;
     const startKey = change.axis === "row" ? "startRow" : "startCol";
     const endKey = change.axis === "row" ? "endRow" : "endCol";
     const next = [];
@@ -1967,8 +2323,8 @@ var SpreadsheetController = (_class3 = class {
     const colCount = this.document.columns.length;
     const body = this.getBodyRowBounds();
     const range = options.range ? normalizeRange(options.range) : null;
-    const startRow = Math.max(_nullishCoalesce(_optionalChain([range, 'optionalAccess', _135 => _135.startRow]), () => ( body.start)), body.start);
-    const endRow = Math.min(_nullishCoalesce(_optionalChain([range, 'optionalAccess', _136 => _136.endRow]), () => ( body.end)), body.end);
+    const startRow = Math.max(_nullishCoalesce(_optionalChain([range, 'optionalAccess', _164 => _164.startRow]), () => ( body.start)), body.start);
+    const endRow = Math.min(_nullishCoalesce(_optionalChain([range, 'optionalAccess', _165 => _165.endRow]), () => ( body.end)), body.end);
     const startCol = range ? Math.max(0, range.startCol) : 0;
     const endCol = range ? Math.min(colCount - 1, range.endCol) : colCount - 1;
     if (endRow - startRow < 1 || startCol > endCol) return false;
@@ -1978,7 +2334,8 @@ var SpreadsheetController = (_class3 = class {
     }));
     if (keyCols.length === 0 || keyCols.some((k) => k.index < startCol || k.index > endCol)) return false;
     const area = { startRow, startCol, endRow, endCol };
-    if ((_nullishCoalesce(_optionalChain([this, 'access', _137 => _137.document, 'access', _138 => _138.table, 'optionalAccess', _139 => _139.merges]), () => ( []))).some((m) => rangesIntersect(m, area))) return false;
+    if ((_nullishCoalesce(_optionalChain([this, 'access', _166 => _166.document, 'access', _167 => _167.table, 'optionalAccess', _168 => _168.merges]), () => ( []))).some((m) => rangesIntersect(m, area))) return false;
+    if (this.intersectsSpill(area)) return false;
     const sourceRows = [];
     for (let r = startRow; r <= endRow; r++) sourceRows.push(r);
     const sorted = sourceRows.map((r) => ({ r, values: keyCols.map((k) => this.getCellValueAt(r, k.index)) })).sort((a, b) => {
@@ -2005,7 +2362,7 @@ var SpreadsheetController = (_class3 = class {
         const colIds = this.document.columns.slice(startCol, endCol + 1).map((c) => c.id);
         const snapshot = sorted.map((oldRow) => {
           const rowId = this.document.rows[oldRow].id;
-          return colIds.map((colId) => _optionalChain([this, 'access', _140 => _140.document, 'access', _141 => _141.cells, 'access', _142 => _142[rowId], 'optionalAccess', _143 => _143[colId]]));
+          return colIds.map((colId) => _optionalChain([this, 'access', _169 => _169.document, 'access', _170 => _170.cells, 'access', _171 => _171[rowId], 'optionalAccess', _172 => _172[colId]]));
         });
         snapshot.forEach((cells, i) => {
           const rowId = this.document.rows[startRow + i].id;
@@ -2021,7 +2378,7 @@ var SpreadsheetController = (_class3 = class {
   }
   // --- Filters ---
   getFilterState() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _144 => _144.document, 'access', _145 => _145.table, 'optionalAccess', _146 => _146.filter]), () => ( { enabled: false, rules: [] }));
+    return _nullishCoalesce(_optionalChain([this, 'access', _173 => _173.document, 'access', _174 => _174.table, 'optionalAccess', _175 => _175.filter]), () => ( { enabled: false, rules: [] }));
   }
   /** Replaces all filter rules (and turns filters on when there are any). */
   setFilterRules(rules) {
@@ -2098,7 +2455,7 @@ var SpreadsheetController = (_class3 = class {
   }
   setTableCount(key, count, max) {
     const value = Math.max(0, Math.min(Math.floor(count), max));
-    if ((_nullishCoalesce(_optionalChain([this, 'access', _147 => _147.document, 'access', _148 => _148.table, 'optionalAccess', _149 => _149[key]]), () => ( 0))) === value) return;
+    if ((_nullishCoalesce(_optionalChain([this, 'access', _176 => _176.document, 'access', _177 => _177.table, 'optionalAccess', _178 => _178[key]]), () => ( 0))) === value) return;
     this.applyTableChange(() => {
       this.table[key] = value;
     });
@@ -2139,7 +2496,7 @@ var SpreadsheetController = (_class3 = class {
   }
   // --- Merged cells ---
   getMerges() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _150 => _150.document, 'access', _151 => _151.table, 'optionalAccess', _152 => _152.merges]), () => ( []));
+    return _nullishCoalesce(_optionalChain([this, 'access', _179 => _179.document, 'access', _180 => _180.table, 'optionalAccess', _181 => _181.merges]), () => ( []));
   }
   /** The merge containing (row, col), or null. */
   getMergeAt(row, col) {
@@ -2186,12 +2543,13 @@ var SpreadsheetController = (_class3 = class {
     }
     const merges = this.getMerges();
     if (merges.some((m) => rangesIntersect(m, r) && !rangeContainsRange(r, m))) return false;
+    if (this.intersectsSpill(r)) return false;
     this.applyTableChange(() => {
       for (let row = r.startRow; row <= r.endRow; row++) {
         const rowId = this.document.rows[row].id;
         for (let col = r.startCol; col <= r.endCol; col++) {
           if (row === r.startRow && col === r.startCol) continue;
-           _optionalChainDelete([this, 'access', _153 => _153.document, 'access', _154 => _154.cells, 'access', _155 => _155[rowId], 'optionalAccess', _156 => _156[this.document.columns[col].id]]);
+           _optionalChainDelete([this, 'access', _182 => _182.document, 'access', _183 => _183.cells, 'access', _184 => _184[rowId], 'optionalAccess', _185 => _185[this.document.columns[col].id]]);
         }
       }
       this.table.merges = [...merges.filter((m) => !rangeContainsRange(r, m)), r];
@@ -2207,7 +2565,7 @@ var SpreadsheetController = (_class3 = class {
     if (remaining.length === merges.length) return false;
     this.applyTableChange(() => {
       this.table.merges = remaining;
-    });
+    }, { recalculate: true });
     return true;
   }
   // --- Autofill ---
@@ -2277,14 +2635,14 @@ var SpreadsheetController = (_class3 = class {
     });
   }
   ungroupRows() {
-    if (!_optionalChain([this, 'access', _157 => _157.document, 'access', _158 => _158.table, 'optionalAccess', _159 => _159.grouping])) return;
+    if (!_optionalChain([this, 'access', _186 => _186.document, 'access', _187 => _187.table, 'optionalAccess', _188 => _188.grouping])) return;
     this.applyTableChange(() => {
       delete this.table.grouping;
     });
   }
   /** Sets (or with `null`, removes) the group summary for a column. */
   setGroupSummary(colId, aggregate) {
-    const grouping = _optionalChain([this, 'access', _160 => _160.document, 'access', _161 => _161.table, 'optionalAccess', _162 => _162.grouping]);
+    const grouping = _optionalChain([this, 'access', _189 => _189.document, 'access', _190 => _190.table, 'optionalAccess', _191 => _191.grouping]);
     if (!grouping) return;
     this.applyTableChange(() => {
       const others = grouping.summaries.filter((s) => s.colId !== colId);
@@ -2295,7 +2653,7 @@ var SpreadsheetController = (_class3 = class {
     });
   }
   setGroupCollapsed(key, collapsed) {
-    const grouping = _optionalChain([this, 'access', _163 => _163.document, 'access', _164 => _164.table, 'optionalAccess', _165 => _165.grouping]);
+    const grouping = _optionalChain([this, 'access', _192 => _192.document, 'access', _193 => _193.table, 'optionalAccess', _194 => _194.grouping]);
     if (!grouping || grouping.collapsed.includes(key) === collapsed) return;
     this.applyTableChange(() => {
       this.table.grouping = {
@@ -2305,7 +2663,7 @@ var SpreadsheetController = (_class3 = class {
     });
   }
   toggleGroupCollapsed(key) {
-    const grouping = _optionalChain([this, 'access', _166 => _166.document, 'access', _167 => _167.table, 'optionalAccess', _168 => _168.grouping]);
+    const grouping = _optionalChain([this, 'access', _195 => _195.document, 'access', _196 => _196.table, 'optionalAccess', _197 => _197.grouping]);
     if (!grouping) return;
     this.setGroupCollapsed(key, !grouping.collapsed.includes(key));
   }
@@ -2328,6 +2686,7 @@ var SpreadsheetController = (_class3 = class {
     const width = s.endCol - s.startCol + 1;
     const t = { startRow: s.startRow, startCol: s.startCol, endRow: s.startRow + width - 1, endCol: s.startCol + height - 1 };
     if (this.getMerges().some((m) => rangesIntersect(m, s) || rangesIntersect(m, t))) return false;
+    if (this.intersectsSpill(s) || this.intersectsSpill(t)) return false;
     this.applyTableChange(() => {
       this.growGrid(t.endRow, t.endCol);
       this.remapAllFormulas(({ row, col }) => {
@@ -2342,9 +2701,9 @@ var SpreadsheetController = (_class3 = class {
           moved.push({
             row: s.startRow + (c - s.startCol),
             col: s.startCol + (r - s.startRow),
-            cell: _optionalChain([this, 'access', _169 => _169.document, 'access', _170 => _170.cells, 'access', _171 => _171[rowId(r)], 'optionalAccess', _172 => _172[colId(c)]])
+            cell: _optionalChain([this, 'access', _198 => _198.document, 'access', _199 => _199.cells, 'access', _200 => _200[rowId(r)], 'optionalAccess', _201 => _201[colId(c)]])
           });
-           _optionalChainDelete([this, 'access', _173 => _173.document, 'access', _174 => _174.cells, 'access', _175 => _175[rowId(r)], 'optionalAccess', _176 => _176[colId(c)]]);
+           _optionalChainDelete([this, 'access', _202 => _202.document, 'access', _203 => _203.cells, 'access', _204 => _204[rowId(r)], 'optionalAccess', _205 => _205[colId(c)]]);
         }
       }
       for (const { row, col, cell } of moved) {
@@ -2371,6 +2730,28 @@ var SpreadsheetController = (_class3 = class {
     this.undoStack.push(JSON.stringify(this.document));
     if (this.undoStack.length > 50) this.undoStack.shift();
     this.redoStack = [];
+    this.trimHistory();
+  }
+  /** Drops the oldest snapshots beyond `maxHistoryBytes`, always keeping the newest. */
+  trimHistory() {
+    if (this.maxHistoryBytes <= 0 || this.undoStack.length <= 1) return;
+    let total = 0;
+    for (const s of this.undoStack) total += s.length * 2;
+    for (const s of this.redoStack) total += s.length * 2;
+    while (total > this.maxHistoryBytes && this.undoStack.length > 1) {
+      total -= this.undoStack.shift().length * 2;
+    }
+  }
+  /** Approximate bytes held by the undo/redo snapshots (UTF-16 size). */
+  getHistoryByteSize() {
+    let total = 0;
+    for (const s of this.undoStack) total += s.length * 2;
+    for (const s of this.redoStack) total += s.length * 2;
+    return total;
+  }
+  /** Number of undo / redo snapshots currently held. */
+  getHistoryDepth() {
+    return { undo: this.undoStack.length, redo: this.redoStack.length };
   }
   undo() {
     if (this.undoStack.length === 0) return;
@@ -2397,7 +2778,7 @@ var SpreadsheetController = (_class3 = class {
     }
   }
   notifyChange() {
-    _optionalChain([this, 'access', _177 => _177.onDocumentChange, 'optionalCall', _178 => _178(this.document)]);
+    _optionalChain([this, 'access', _206 => _206.onDocumentChange, 'optionalCall', _207 => _207(this.document)]);
   }
 }, _class3);
 function stepInOrder(order, from, delta) {
@@ -2412,6 +2793,17 @@ function stepInOrder(order, from, delta) {
 }
 
 // src/spreadsheet/menu.ts
+function clampMenuPosition(point, size, viewport, margin = 4) {
+  const place = (start, length, limit) => {
+    if (start + length <= limit - margin) return Math.max(margin, start);
+    const flipped = start - length;
+    return Math.max(margin, flipped >= margin ? flipped : limit - margin - length);
+  };
+  return {
+    x: place(point.x, size.width, viewport.width),
+    y: place(point.y, size.height, viewport.height)
+  };
+}
 var quote = (value) => {
   const text = String(_nullishCoalesce(value, () => ( "")));
   return text.length > 24 ? `"${text.slice(0, 23)}\u2026"` : `"${text}"`;
@@ -2422,8 +2814,9 @@ function getSpreadsheetMenuItems(controller, cell) {
   const row = doc.rows[cell.row];
   if (!column || !row) return [];
   const selection = controller.selectedRange && rangeContains(controller.selectedRange, cell.row, cell.col) ? normalizeRange(controller.selectedRange) : { startRow: cell.row, startCol: cell.col, endRow: cell.row, endCol: cell.col };
-  const colName = _chunkJYRIOFENcjs.indexToColName.call(void 0, cell.col);
-  const value = controller.getCell(row.id, column.id).value;
+  const colName = _chunkRIKBJLS2cjs.indexToColName.call(void 0, cell.col);
+  const cellData = controller.getCell(row.id, column.id);
+  const value = cellData.value;
   const table = _nullishCoalesce(doc.table, () => ( {}));
   const filter = controller.getFilterState();
   const grouping = table.grouping;
@@ -2445,7 +2838,7 @@ function getSpreadsheetMenuItems(controller, cell) {
     },
     {
       id: "filter-equals",
-      label: `Show only rows where ${colName} = ${quote(value)}`,
+      label: `Show only rows where ${colName} = ${quote(_chunkRIKBJLS2cjs.formatCellDisplay.call(void 0, cellData))}`,
       separatorBefore: true,
       run: () => controller.addFilterRule({ colId: column.id, operator: "equals", value: String(_nullishCoalesce(value, () => ( ""))) })
     },
@@ -2702,5 +3095,6 @@ async function importFileIntoSpreadsheet(controller, input, options) {
 
 
 
-exports.columnDependencyKey = columnDependencyKey; exports.extractCellDependencies = extractCellDependencies; exports.DependencyGraph = DependencyGraph; exports.shiftFormulaReferences = shiftFormulaReferences; exports.mapFormulaReferences = mapFormulaReferences; exports.offsetFormulaReferences = offsetFormulaReferences; exports.remapFormulaReferences = remapFormulaReferences; exports.getFormulaCaretContext = getFormulaCaretContext; exports.getFormulaHints = getFormulaHints; exports.applyFormulaSuggestion = applyFormulaSuggestion; exports.DataSourceBinder = DataSourceBinder; exports.normalizeRange = normalizeRange; exports.rangeContains = rangeContains; exports.rangesIntersect = rangesIntersect; exports.rangeContainsRange = rangeContainsRange; exports.isSingleCellRange = isSingleCellRange; exports.isBlankValue = isBlankValue; exports.toNumber = toNumber; exports.compareCellValues = compareCellValues; exports.matchesFilterRule = matchesFilterRule; exports.aggregateValues = aggregateValues; exports.roundFloat = roundFloat; exports.fillSeries = fillSeries; exports.computeFillTarget = computeFillTarget; exports.getFillDirection = getFillDirection; exports.parseCsv = parseCsv; exports.escapeCsvField = escapeCsvField; exports.serializeCsv = serializeCsv; exports.parseTsv = parseTsv; exports.serializeTsv = serializeTsv; exports.SPREADSHEET_CLIPBOARD_MIME = SPREADSHEET_CLIPBOARD_MIME; exports.serializeHtmlTable = serializeHtmlTable; exports.parseHtmlTable = parseHtmlTable; exports.createSpreadsheetClipboardData = createSpreadsheetClipboardData; exports.readSpreadsheetClipboard = readSpreadsheetClipboard; exports.rebaseClipboardRows = rebaseClipboardRows; exports.DEFAULT_ROW_HEIGHT = DEFAULT_ROW_HEIGHT; exports.DEFAULT_COLUMN_WIDTH = DEFAULT_COLUMN_WIDTH; exports.getTableSections = getTableSections; exports.getRowSection = getRowSection; exports.rowPassesFilters = rowPassesFilters; exports.computeRowGroups = computeRowGroups; exports.buildSpreadsheetView = buildSpreadsheetView; exports.SpreadsheetController = SpreadsheetController; exports.getSpreadsheetMenuItems = getSpreadsheetMenuItems; exports.SPREADSHEET_TABLE_ACTIONS = SPREADSHEET_TABLE_ACTIONS; exports.bindSpreadsheetTableActions = bindSpreadsheetTableActions; exports.csvImportAdapter = csvImportAdapter; exports.tsvImportAdapter = tsvImportAdapter; exports.SPREADSHEET_IMPORT_ADAPTERS = SPREADSHEET_IMPORT_ADAPTERS; exports.registerSpreadsheetImportAdapters = registerSpreadsheetImportAdapters; exports.importFileIntoSpreadsheet = importFileIntoSpreadsheet;
-//# sourceMappingURL=chunk-U6NDQFOK.cjs.map
+
+exports.columnDependencyKey = columnDependencyKey; exports.extractCellDependencies = extractCellDependencies; exports.DependencyGraph = DependencyGraph; exports.shiftFormulaReferences = shiftFormulaReferences; exports.mapFormulaReferences = mapFormulaReferences; exports.offsetFormulaReferences = offsetFormulaReferences; exports.remapFormulaReferences = remapFormulaReferences; exports.getFormulaCaretContext = getFormulaCaretContext; exports.getFormulaHints = getFormulaHints; exports.applyFormulaSuggestion = applyFormulaSuggestion; exports.DataSourceBinder = DataSourceBinder; exports.normalizeRange = normalizeRange; exports.rangeContains = rangeContains; exports.rangesIntersect = rangesIntersect; exports.rangeContainsRange = rangeContainsRange; exports.isSingleCellRange = isSingleCellRange; exports.isBlankValue = isBlankValue; exports.toNumber = toNumber; exports.compareCellValues = compareCellValues; exports.matchesFilterRule = matchesFilterRule; exports.aggregateValues = aggregateValues; exports.roundFloat = roundFloat; exports.fillSeries = fillSeries; exports.computeFillTarget = computeFillTarget; exports.getFillDirection = getFillDirection; exports.parseCsv = parseCsv; exports.escapeCsvField = escapeCsvField; exports.serializeCsv = serializeCsv; exports.parseTsv = parseTsv; exports.serializeTsv = serializeTsv; exports.SPREADSHEET_CLIPBOARD_MIME = SPREADSHEET_CLIPBOARD_MIME; exports.serializeHtmlTable = serializeHtmlTable; exports.parseHtmlTable = parseHtmlTable; exports.createSpreadsheetClipboardData = createSpreadsheetClipboardData; exports.readSpreadsheetClipboard = readSpreadsheetClipboard; exports.rebaseClipboardRows = rebaseClipboardRows; exports.DEFAULT_ROW_HEIGHT = DEFAULT_ROW_HEIGHT; exports.DEFAULT_COLUMN_WIDTH = DEFAULT_COLUMN_WIDTH; exports.getTableSections = getTableSections; exports.getRowSection = getRowSection; exports.rowPassesFilters = rowPassesFilters; exports.computeRowGroups = computeRowGroups; exports.buildSpreadsheetView = buildSpreadsheetView; exports.SpreadsheetController = SpreadsheetController; exports.clampMenuPosition = clampMenuPosition; exports.getSpreadsheetMenuItems = getSpreadsheetMenuItems; exports.SPREADSHEET_TABLE_ACTIONS = SPREADSHEET_TABLE_ACTIONS; exports.bindSpreadsheetTableActions = bindSpreadsheetTableActions; exports.csvImportAdapter = csvImportAdapter; exports.tsvImportAdapter = tsvImportAdapter; exports.SPREADSHEET_IMPORT_ADAPTERS = SPREADSHEET_IMPORT_ADAPTERS; exports.registerSpreadsheetImportAdapters = registerSpreadsheetImportAdapters; exports.importFileIntoSpreadsheet = importFileIntoSpreadsheet;
+//# sourceMappingURL=chunk-XDMXXC4Z.cjs.map