@pixerate/editor 0.25.0 → 0.26.1

package/dist/{chunk-RR7F5GUM.js → chunk-X7HXL2SB.js}

@@ -31,7 +31,7 @@ import {
   toBoolean,
   toText,
   tokenizeFormula
-} from "./chunk-FH6F67DN.js";
+} from "./chunk-ZRNHGAQT.js";
 
 // src/spreadsheet/formula/dependency-graph.ts
 function extractNameDependencies(node) {
@@ -105,11 +105,178 @@ function extractCellDependencies(node) {
   visit(node);
   return deps;
 }
+function extractReferenceDependencies(node) {
+  const deps = [];
+  const stack = [node];
+  while (stack.length > 0) {
+    const curr = stack.pop();
+    const sheet = "sheet" in curr && curr.sheet !== void 0 ? "sheetEnd" in curr && curr.sheetEnd !== void 0 ? { sheet: curr.sheet, sheetEnd: curr.sheetEnd } : { sheet: curr.sheet } : {};
+    switch (curr.type) {
+      case "CellRef":
+      case "SpillRef":
+        deps.push({ kind: "cell", col: curr.col.toUpperCase(), row: curr.row, ...sheet });
+        break;
+      case "Range": {
+        const startC = colNameToIndex(curr.startCol);
+        const endC = colNameToIndex(curr.endCol);
+        const whole = curr.endRow >= WHOLE_COLUMN_END_ROW;
+        deps.push({
+          kind: "range",
+          startCol: indexToColName(Math.min(startC, endC)),
+          endCol: indexToColName(Math.max(startC, endC)),
+          startRow: whole ? 1 : Math.min(curr.startRow, curr.endRow),
+          endRow: whole ? WHOLE_COLUMN_END_ROW : Math.max(curr.startRow, curr.endRow),
+          ...sheet
+        });
+        break;
+      }
+      case "BinaryOp":
+        stack.push(curr.right, curr.left);
+        break;
+      case "UnaryOp":
+        stack.push(curr.argument);
+        break;
+      case "FunctionCall":
+        for (let i = curr.args.length - 1; i >= 0; i--) stack.push(curr.args[i]);
+        break;
+      case "Invoke":
+        for (let i = curr.args.length - 1; i >= 0; i--) stack.push(curr.args[i]);
+        stack.push(curr.callee);
+        break;
+      default:
+        break;
+    }
+  }
+  return deps;
+}
+function rangeDependencyKey(startCol, startRow, endCol, endRow, sheetPrefix = "") {
+  const prefix = sheetPrefix === "" ? "" : `${sheetPrefix}!`;
+  return `${prefix}${startCol}${startRow}:${endCol}${endRow}`.toUpperCase();
+}
+var WIDE_RANGE_COLUMNS = 64;
+var PENDING_INTERVALS = 32;
+var IntervalIndex = class {
+  items = [];
+  dead = new Uint8Array(0);
+  deadCount = 0;
+  maxEnd = new Float64Array(0);
+  leaves = 0;
+  position = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  /** Live entries. */
+  get size() {
+    return this.items.length - this.deadCount + this.pending.size;
+  }
+  /** Adds (or revives) the entry `id`. An id always names the same interval. */
+  insert(r0, r1, id, payload) {
+    const at = this.position.get(id);
+    if (at !== void 0) {
+      if (this.dead[at]) {
+        this.dead[at] = 0;
+        this.deadCount--;
+        this.items[at].payload = payload;
+      }
+      return;
+    }
+    this.pending.set(id, { r0, r1, id, payload });
+  }
+  remove(id) {
+    const at = this.position.get(id);
+    if (at !== void 0) {
+      if (!this.dead[at]) {
+        this.dead[at] = 1;
+        this.deadCount++;
+      }
+      return;
+    }
+    this.pending.delete(id);
+  }
+  /** Merges pending insertions and drops dead entries when there are enough of them. */
+  settle() {
+    if (this.pending.size <= PENDING_INTERVALS && this.deadCount <= Math.max(this.items.length / 2, PENDING_INTERVALS)) return;
+    const all = [];
+    this.items.forEach((item, i) => {
+      if (!this.dead[i]) all.push(item);
+    });
+    for (const item of this.pending.values()) all.push(item);
+    all.sort((a, b) => a.r0 - b.r0 || a.r1 - b.r1 || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    let leaves = 1;
+    while (leaves < all.length) leaves *= 2;
+    const maxEnd = new Float64Array(2 * leaves).fill(-1);
+    all.forEach((item, i) => {
+      maxEnd[leaves + i] = item.r1;
+    });
+    for (let i = leaves - 1; i >= 1; i--) maxEnd[i] = Math.max(maxEnd[2 * i], maxEnd[2 * i + 1]);
+    this.items = all;
+    this.dead = new Uint8Array(all.length);
+    this.deadCount = 0;
+    this.maxEnd = maxEnd;
+    this.leaves = leaves;
+    this.position = new Map(all.map((item, i) => [item.id, i]));
+    this.pending = /* @__PURE__ */ new Map();
+  }
+  /** Calls `fn` for every live interval overlapping rows `a..b` (`r0 <= b && r1 >= a`). */
+  query(a, b, fn) {
+    this.settle();
+    for (const item of this.pending.values()) {
+      if (item.r0 <= b && item.r1 >= a) fn(item.payload, item);
+    }
+    let lo = 0;
+    let hi = this.items.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (this.items[mid].r0 <= b) lo = mid + 1;
+      else hi = mid;
+    }
+    if (lo === 0) return;
+    this.walk(1, 0, this.leaves, lo, a, fn);
+  }
+  walk(node, lo, hi, p, a, fn) {
+    if (lo >= p || this.maxEnd[node] < a) return;
+    if (hi - lo <= 1) {
+      const item = this.items[lo];
+      if (item && !this.dead[lo] && item.r1 >= a) fn(item.payload, item);
+      return;
+    }
+    const mid = lo + (hi - lo >>> 1);
+    this.walk(2 * node, lo, mid, p, a, fn);
+    this.walk(2 * node + 1, mid, hi, p, a, fn);
+  }
+};
+var CELL_KEY = /^([A-Z]+)(\d+)$/;
+var RANGE_KEY = /^([A-Z]+)(\d+):([A-Z]+)(\d+)$/;
+var COLUMN_KEY = /^([A-Z]+):$/;
+function parseKey(key) {
+  const bang = key.lastIndexOf("!");
+  const sheet = bang < 0 ? "" : key.slice(0, bang);
+  const ref = bang < 0 ? key : key.slice(bang + 1);
+  let m = CELL_KEY.exec(ref);
+  if (m) return { kind: "cell", sheet, col: colNameToIndex(m[1]), row: Number(m[2]) };
+  m = RANGE_KEY.exec(ref);
+  if (m) {
+    const ca = colNameToIndex(m[1]);
+    const cb = colNameToIndex(m[3]);
+    const ra = Number(m[2]);
+    const rb = Number(m[4]);
+    return { kind: "range", sheet, c0: Math.min(ca, cb), c1: Math.max(ca, cb), r0: Math.min(ra, rb), r1: Math.max(ra, rb) };
+  }
+  m = COLUMN_KEY.exec(ref);
+  if (m) {
+    const c = colNameToIndex(m[1]);
+    return { kind: "range", sheet, c0: c, c1: c, r0: 1, r1: WHOLE_COLUMN_END_ROW };
+  }
+  return { kind: "opaque" };
+}
+var VIRTUAL_PREFIX = "\0";
 var DependencyGraph = class {
-  // Map of cellKey (e.g. "B2") -> Set of cellKeys that this cell depends ON
-  dependencies = /* @__PURE__ */ new Map();
-  // Map of cellKey (e.g. "A1") -> Set of cellKeys that depend ON this cell (dependents)
-  dependents = /* @__PURE__ */ new Map();
+  // Formula cell -> what it reads (single cells and whole ranges).
+  nodes = /* @__PURE__ */ new Map();
+  // Cell -> formulas reading it as a single cell.
+  cellDependents = /* @__PURE__ */ new Map();
+  // Sheet ('' for unqualified keys) -> interval index of the ranges formulas read.
+  rangeIndex = /* @__PURE__ */ new Map();
+  // Formulas recalculated on every recalculation (NOW, RAND, …).
+  volatile = /* @__PURE__ */ new Set();
   // 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,
@@ -118,60 +285,145 @@ var DependencyGraph = class {
   spillDependents = /* @__PURE__ */ new Map();
   // anchor -> the edges it registered (so they can be replaced).
   spillEdges = /* @__PURE__ */ new Map();
+  // Blocked anchor -> its blockers. These edges only propagate changes
+  // (clearing a blocker recalculates the anchor): whether a cell blocks
+  // depends on its input, not its value, so they don't order evaluation and
+  // can't close a cycle.
+  blockingEdges = /* @__PURE__ */ new Map();
+  parsed = /* @__PURE__ */ new Map();
+  parse(key) {
+    let parsed = this.parsed.get(key);
+    if (!parsed) {
+      parsed = parseKey(key);
+      if (this.parsed.size > 2e5) this.parsed.clear();
+      this.parsed.set(key, parsed);
+    }
+    return parsed;
+  }
+  sheetIndex(sheet) {
+    let index = this.rangeIndex.get(sheet);
+    if (!index) {
+      index = { cols: /* @__PURE__ */ new Map(), wide: new IntervalIndex() };
+      this.rangeIndex.set(sheet, index);
+    }
+    return index;
+  }
+  removeNode(key) {
+    const node = this.nodes.get(key);
+    if (!node) return;
+    for (const dep of node.cells) {
+      const set = this.cellDependents.get(dep);
+      if (!set) continue;
+      set.delete(key);
+      if (set.size === 0) this.cellDependents.delete(dep);
+    }
+    for (const range of node.ranges) {
+      const index = this.rangeIndex.get(range.sheet);
+      if (!index) continue;
+      if (range.c1 - range.c0 + 1 > WIDE_RANGE_COLUMNS) {
+        index.wide.remove(`${range.r0}:${range.r1}:${range.c0}:${range.c1}:${key}`);
+      } else {
+        for (let c = range.c0; c <= range.c1; c++) index.cols.get(c)?.remove(`${range.r0}:${range.r1}:${key}`);
+      }
+    }
+    this.nodes.delete(key);
+  }
   /**
-   * Sets the cells `cellKey` depends on directly (keys such as `B2`, or a
-   * column key from `columnDependencyKey`), replacing its previous
-   * dependencies. Used by spreadsheets whose keys carry more than A1 text
-   * (e.g. sheet-qualified keys); `setCellFormula` derives them from a formula.
+   * Sets what `cellKey` depends on directly, replacing its previous
+   * dependencies. Keys are single cells (`B2`), rectangles (`A1:B9`) or
+   * whole columns (`A:`, see `columnDependencyKey`), each optionally
+   * sheet-qualified (`SHEET!A1:A9`). Ranges are stored whole in an interval
+   * index, never expanded cell by cell. `setCellFormula` derives the keys
+   * from a formula.
    */
   setCellDependencies(cellKey2, dependencyKeys) {
     const key = cellKey2.toUpperCase();
-    for (const dep of this.dependencies.get(key) ?? []) {
-      this.dependents.get(dep)?.delete(key);
-    }
-    this.dependencies.delete(key);
-    const deps = /* @__PURE__ */ new Set();
+    this.removeNode(key);
+    const node = { cells: /* @__PURE__ */ new Set(), ranges: [] };
+    const seenRanges = /* @__PURE__ */ new Set();
     for (const raw of dependencyKeys) {
       const dep = raw.toUpperCase();
-      deps.add(dep);
-      if (!this.dependents.has(dep)) this.dependents.set(dep, /* @__PURE__ */ new Set());
-      this.dependents.get(dep).add(key);
+      const parsed = this.parse(dep);
+      if (parsed.kind === "range" && !(parsed.c0 === parsed.c1 && parsed.r0 === parsed.r1)) {
+        if (seenRanges.has(dep)) continue;
+        seenRanges.add(dep);
+        node.ranges.push({ key: dep, sheet: parsed.sheet, c0: parsed.c0, c1: parsed.c1, r0: parsed.r0, r1: parsed.r1 });
+        continue;
+      }
+      const cell = parsed.kind === "range" ? `${parsed.sheet === "" ? "" : `${parsed.sheet}!`}${indexToColName(parsed.c0)}${parsed.r0}` : dep;
+      node.cells.add(cell);
+    }
+    if (node.cells.size === 0 && node.ranges.length === 0) {
+      this.volatile.delete(key);
+      return;
     }
-    if (deps.size > 0) this.dependencies.set(key, deps);
+    for (const dep of node.cells) {
+      let set = this.cellDependents.get(dep);
+      if (!set) this.cellDependents.set(dep, set = /* @__PURE__ */ new Set());
+      set.add(key);
+    }
+    for (const range of node.ranges) {
+      const index = this.sheetIndex(range.sheet);
+      if (range.c1 - range.c0 + 1 > WIDE_RANGE_COLUMNS) {
+        index.wide.insert(range.r0, range.r1, `${range.r0}:${range.r1}:${range.c0}:${range.c1}:${key}`, {
+          c0: range.c0,
+          c1: range.c1,
+          key
+        });
+      } else {
+        for (let c = range.c0; c <= range.c1; c++) {
+          let col = index.cols.get(c);
+          if (!col) index.cols.set(c, col = new IntervalIndex());
+          col.insert(range.r0, range.r1, `${range.r0}:${range.r1}:${key}`, key);
+        }
+      }
+    }
+    this.nodes.set(key, node);
+  }
+  /**
+   * Marks `cellKey` as volatile (its formula uses NOW, RAND, …): it is
+   * recalculated by every plan made with `includeVolatile`, whatever changed.
+   */
+  setVolatile(cellKey2, volatile) {
+    const key = cellKey2.toUpperCase();
+    if (volatile) this.volatile.add(key);
+    else this.volatile.delete(key);
+  }
+  /** Cells whose formulas are volatile. */
+  getVolatileKeys() {
+    return Array.from(this.volatile);
   }
   setCellFormula(cellKey2, formulaStr) {
     const key = cellKey2.toUpperCase();
-    const oldDeps = this.dependencies.get(key) || /* @__PURE__ */ new Set();
-    for (const dep of oldDeps) {
-      this.dependents.get(dep)?.delete(key);
-    }
-    this.dependencies.delete(key);
     if (!formulaStr || !formulaStr.startsWith("=")) {
+      this.setCellDependencies(key, []);
       return;
     }
+    let ast;
     try {
-      const ast = parseFormula(formulaStr);
-      const deps = extractCellDependencies(ast);
-      const newDeps = /* @__PURE__ */ new Set();
-      for (const d of deps) {
-        const depKey = d.row === 0 ? columnDependencyKey(d.col) : `${d.col}${d.row}`.toUpperCase();
-        newDeps.add(depKey);
-        if (!this.dependents.has(depKey)) {
-          this.dependents.set(depKey, /* @__PURE__ */ new Set());
-        }
-        this.dependents.get(depKey).add(key);
-      }
-      this.dependencies.set(key, newDeps);
+      ast = parseFormula(formulaStr);
     } catch {
+      this.setCellDependencies(key, []);
+      return;
+    }
+    const keys = [];
+    for (const dep of extractReferenceDependencies(ast)) {
+      keys.push(
+        dep.kind === "cell" ? `${dep.col}${dep.row}` : dep.endRow >= WHOLE_COLUMN_END_ROW && dep.startCol === dep.endCol ? columnDependencyKey(dep.startCol) : rangeDependencyKey(dep.startCol, dep.startRow, dep.endCol, dep.endRow)
+      );
     }
+    this.setCellDependencies(key, keys);
   }
   /** Removes every registered formula and dependency. */
   clear() {
-    this.dependencies.clear();
-    this.dependents.clear();
+    this.nodes.clear();
+    this.cellDependents.clear();
+    this.rangeIndex.clear();
+    this.volatile.clear();
     this.spillDependencies.clear();
     this.spillDependents.clear();
     this.spillEdges.clear();
+    this.blockingEdges.clear();
   }
   /**
    * Records the dynamic-array edges of the anchor `anchorKey`, replacing its
@@ -186,9 +438,15 @@ var DependencyGraph = class {
       this.spillDependencies.get(from)?.delete(to);
       this.spillDependents.get(to)?.delete(from);
     }
+    this.blockingEdges.delete(anchor);
     const edges = [];
     for (const key of spilledKeys) edges.push([key.toUpperCase(), anchor]);
-    for (const key of blockingKeys) edges.push([anchor, key.toUpperCase()]);
+    const blockers = /* @__PURE__ */ new Set();
+    for (const key of blockingKeys) {
+      edges.push([anchor, key.toUpperCase()]);
+      blockers.add(key.toUpperCase());
+    }
+    if (blockers.size > 0) this.blockingEdges.set(anchor, blockers);
     for (const [from, to] of edges) {
       if (!this.spillDependencies.has(from)) this.spillDependencies.set(from, /* @__PURE__ */ new Set());
       this.spillDependencies.get(from).add(to);
@@ -198,133 +456,201 @@ var DependencyGraph = class {
     if (edges.length > 0) this.spillEdges.set(anchor, edges);
     else this.spillEdges.delete(anchor);
   }
+  /**
+   * Drops the edge from a spilled cell to the anchor whose values it holds,
+   * for a cell that just got input of its own: its value no longer comes
+   * from the anchor (which recalculates and becomes `#SPILL!`), and the
+   * stale edge could otherwise close a false cycle with the cell's new
+   * formula before the anchor is evaluated again.
+   */
+  detachSpilledCell(cellKey2) {
+    const key = cellKey2.toUpperCase();
+    const anchors = this.spillDependencies.get(key);
+    if (!anchors) return;
+    for (const anchor of Array.from(anchors)) {
+      if (this.blockingEdges.get(key)?.has(anchor)) continue;
+      const edges = this.spillEdges.get(anchor);
+      if (!edges?.some(([from, to]) => from === key && to === anchor)) continue;
+      anchors.delete(anchor);
+      this.spillDependents.get(anchor)?.delete(key);
+      const kept = edges.filter(([from, to]) => !(from === key && to === anchor));
+      if (kept.length > 0) this.spillEdges.set(anchor, kept);
+      else this.spillEdges.delete(anchor);
+    }
+  }
   /** The spilled cells registered for `anchorKey` by `setSpillEdges`. */
   getSpilledKeys(anchorKey) {
     const anchor = anchorKey.toUpperCase();
     return (this.spillEdges.get(anchor) ?? []).filter(([, to]) => to === anchor).map(([from]) => from);
   }
-  /** Formula dependencies plus dynamic-array (spill) dependencies of a cell. */
+  /**
+   * What a cell depends on directly: single cells, ranges (as registered,
+   * e.g. `A1:A9` or `A:`, not expanded) and dynamic-array (spill) edges.
+   */
   getDependencies(cellKey2) {
     const key = cellKey2.toUpperCase();
-    return unionOf(this.dependencies.get(key), this.spillDependencies.get(key));
+    const node = this.nodes.get(key);
+    const own = node ? [...node.cells, ...node.ranges.map((r) => r.key)] : [];
+    const spill = this.spillDependencies.get(key);
+    if (!spill || spill.size === 0) return own;
+    return Array.from(/* @__PURE__ */ new Set([...own, ...spill]));
+  }
+  /**
+   * Whether the formula in `formulaKey` reads `cellKey` directly: as a cell,
+   * inside one of its ranges, or through a spill edge.
+   */
+  dependsOn(formulaKey, cellKey2) {
+    const key = formulaKey.toUpperCase();
+    const target = cellKey2.toUpperCase();
+    if (this.spillDependencies.get(key)?.has(target)) return true;
+    const node = this.nodes.get(key);
+    if (!node) return false;
+    if (node.cells.has(target)) return true;
+    const parsed = this.parse(target);
+    if (parsed.kind !== "cell") return false;
+    return node.ranges.some(
+      (r) => r.sheet === parsed.sheet && parsed.col >= r.c0 && parsed.col <= r.c1 && parsed.row >= r.r0 && parsed.row <= r.r1
+    );
   }
-  /** Cells depending on `cellKey`, through formulas or spills. */
+  /**
+   * Formulas (and spilled cells) reading `cellKey` directly, through formulas
+   * or spills. Found in O(log n + k) through the range index.
+   */
   getDependents(cellKey2) {
-    const key = cellKey2.toUpperCase();
-    return unionOf(this.dependents.get(key), this.spillDependents.get(key));
+    const out = /* @__PURE__ */ new Set();
+    this.collectDependents(cellKey2.toUpperCase(), (key) => out.add(key));
+    return Array.from(out);
+  }
+  collectDependents(key, add) {
+    const cells = this.cellDependents.get(key);
+    if (cells) for (const dep of cells) add(dep);
+    const spill = this.spillDependents.get(key);
+    if (spill) for (const dep of spill) add(dep);
+    if (this.rangeIndex.size === 0) return;
+    const parsed = this.parse(key);
+    if (parsed.kind !== "cell") return;
+    const index = this.rangeIndex.get(parsed.sheet);
+    if (!index) return;
+    index.cols.get(parsed.col)?.query(parsed.row, parsed.row, add);
+    if (index.wide.size > 0) {
+      index.wide.query(parsed.row, parsed.row, (wide) => {
+        if (parsed.col >= wide.c0 && parsed.col <= wide.c1) add(wide.key);
+      });
+    }
+  }
+  /** Sizes of the index: ranges count once (per column), not once per cell. */
+  getIndexStats() {
+    let cellEdges = 0;
+    let rangeEntries = 0;
+    for (const node of this.nodes.values()) {
+      cellEdges += node.cells.size;
+      for (const r of node.ranges) rangeEntries += r.c1 - r.c0 + 1 > WIDE_RANGE_COLUMNS ? 1 : r.c1 - r.c0 + 1;
+    }
+    return { formulas: this.nodes.size, cellEdges, rangeEntries, volatile: this.volatile.size };
   }
   /**
    * Detects if there is a cycle containing cellKey.
    */
   hasCycle(cellKey2) {
     const key = cellKey2.toUpperCase();
-    const visited = /* @__PURE__ */ new Set();
-    const recStack = /* @__PURE__ */ new Set();
-    const dfs = (node) => {
-      visited.add(node);
-      recStack.add(node);
-      const deps = this.getDependencies(node);
-      for (const neighbor of deps) {
-        if (!visited.has(neighbor)) {
-          if (dfs(neighbor)) return true;
-        } else if (recStack.has(neighbor)) {
-          return true;
-        }
-      }
-      recStack.delete(node);
-      return false;
-    };
-    return dfs(key);
+    return this.getEvaluationPlan([key], { includeDependents: true }).cyclic.has(key);
   }
   /**
    * Returns cells affected by updating cellKey in topological order.
    */
   getEvaluationOrder(startCellKey) {
-    const start = startCellKey.toUpperCase();
-    const visited = /* @__PURE__ */ new Set();
-    const recStack = /* @__PURE__ */ new Set();
-    const order = [];
-    let cycleDetected = false;
-    const affected = /* @__PURE__ */ new Set();
-    const collectAffected = (node) => {
-      affected.add(node);
-      const directDependents = this.dependents.get(node) || /* @__PURE__ */ new Set();
-      for (const dep of directDependents) {
-        if (!affected.has(dep)) {
-          collectAffected(dep);
-        }
-      }
-    };
-    collectAffected(start);
-    const visit = (node) => {
-      if (recStack.has(node)) {
-        cycleDetected = true;
-        return;
-      }
-      if (visited.has(node)) return;
-      recStack.add(node);
-      visited.add(node);
-      const deps = this.dependencies.get(node) || /* @__PURE__ */ new Set();
-      for (const neighbor of deps) {
-        if (affected.has(neighbor)) {
-          visit(neighbor);
-        }
-      }
-      recStack.delete(node);
-      order.push(node);
-    };
-    for (const node of affected) {
-      if (!visited.has(node)) {
-        visit(node);
-      }
-    }
-    return { order, hasCycle: cycleDetected };
+    const plan = this.getEvaluationPlan([startCellKey], { includeDependents: true });
+    return { order: plan.order, hasCycle: plan.cyclic.size > 0 };
   }
   /**
    * Plans a recalculation over `cellKeys` (and, with `includeDependents`, every
-   * cell that transitively depends on them). Returns the keys in evaluation
+   * cell that transitively depends on them; with `includeVolatile`, every
+   * volatile formula and its dependents too). Returns the keys in evaluation
    * order (dependencies first) and the set of keys that are part of a cycle,
    * which must be marked `#CYCLE!` instead of evaluated. Every member of a
    * cycle is reported, not just the cell that closed it.
+   *
+   * Only the planned cells are ordered: a range a formula reads becomes one
+   * node whose edges are the planned cells inside it (found by binary
+   * search), so a range shared by many formulas is resolved once.
    */
   getEvaluationPlan(cellKeys, options = {}) {
     const nodes = /* @__PURE__ */ new Set();
     const queue = [];
-    for (const key of cellKeys) {
-      const upper = key.toUpperCase();
-      if (!nodes.has(upper)) {
-        nodes.add(upper);
-        queue.push(upper);
+    const visit = (key) => {
+      if (!nodes.has(key)) {
+        nodes.add(key);
+        queue.push(key);
       }
-    }
+    };
+    for (const key of cellKeys) visit(key.toUpperCase());
+    if (options.includeVolatile) for (const key of this.volatile) visit(key);
     if (options.includeDependents) {
-      while (queue.length > 0) {
-        const node = queue.pop();
-        const direct = [
-          ...this.dependents.get(node) ?? [],
-          ...this.spillDependents.get(node) ?? [],
-          ...this.dependents.get(columnDependencyKey(node.replace(/\d+$/, ""))) ?? []
-        ];
-        for (const dep of direct) {
-          if (!nodes.has(dep)) {
-            nodes.add(dep);
-            queue.push(dep);
+      while (queue.length > 0) this.collectDependents(queue.pop(), visit);
+    }
+    let positions = null;
+    const planPositions = () => {
+      if (positions) return positions;
+      positions = /* @__PURE__ */ new Map();
+      for (const key of nodes) {
+        const parsed = this.parse(key);
+        if (parsed.kind !== "cell") continue;
+        let sheet = positions.get(parsed.sheet);
+        if (!sheet) positions.set(parsed.sheet, sheet = /* @__PURE__ */ new Map());
+        let cells = sheet.get(parsed.col);
+        if (!cells) sheet.set(parsed.col, cells = []);
+        cells.push([parsed.row, key]);
+      }
+      for (const sheet of positions.values()) for (const cells of sheet.values()) cells.sort((a, b) => a[0] - b[0]);
+      return positions;
+    };
+    const rangeMembers = /* @__PURE__ */ new Map();
+    const rangeNode = (range) => {
+      const id = `${VIRTUAL_PREFIX}${range.sheet}!${range.c0}:${range.c1}:${range.r0}:${range.r1}`;
+      let members = rangeMembers.get(id);
+      if (!members) {
+        const found = [];
+        const sheet = planPositions().get(range.sheet);
+        const scan = (cells) => {
+          let lo = 0;
+          let hi = cells.length;
+          while (lo < hi) {
+            const mid = lo + hi >>> 1;
+            if (cells[mid][0] < range.r0) lo = mid + 1;
+            else hi = mid;
+          }
+          for (let i = lo; i < cells.length && cells[i][0] <= range.r1; i++) found.push(cells[i][1]);
+        };
+        if (sheet) {
+          if (range.c1 - range.c0 + 1 <= sheet.size) {
+            for (let c = range.c0; c <= range.c1; c++) {
+              const cells = sheet.get(c);
+              if (cells) scan(cells);
+            }
+          } else {
+            for (const [c, cells] of sheet) if (c >= range.c0 && c <= range.c1) scan(cells);
           }
         }
+        rangeMembers.set(id, members = found);
       }
-    }
+      return members.length > 0 ? id : null;
+    };
     const neighbors = (node) => {
+      if (node.startsWith(VIRTUAL_PREFIX)) return rangeMembers.get(node) ?? [];
       const result = [];
-      for (const dep of this.getDependencies(node)) {
-        if (dep.endsWith(":")) {
-          const col = dep.slice(0, -1);
-          for (const candidate of nodes) {
-            if (candidate.replace(/\d+$/, "") === col) result.push(candidate);
-          }
-        } else if (nodes.has(dep)) {
-          result.push(dep);
+      const formula = this.nodes.get(node);
+      if (formula) {
+        for (const dep of formula.cells) if (nodes.has(dep)) result.push(dep);
+        for (const range of formula.ranges) {
+          const id = rangeNode(range);
+          if (id) result.push(id);
         }
       }
+      const spill = this.spillDependencies.get(node);
+      if (spill) {
+        const blockers = this.blockingEdges.get(node);
+        for (const dep of spill) if (nodes.has(dep) && !blockers?.has(dep)) result.push(dep);
+      }
       return result;
     };
     const order = [];
@@ -372,6 +698,7 @@ var DependencyGraph = class {
           } while (member !== frame.node);
           const isCycle = component.length > 1 || frame.edges.includes(frame.node);
           for (const key of component) {
+            if (key.startsWith(VIRTUAL_PREFIX)) continue;
             order.push(key);
             if (isCycle) cyclic.add(key);
           }
@@ -381,11 +708,6 @@ var DependencyGraph = class {
     return { order, cyclic };
   }
 };
-function unionOf(a, b) {
-  if (!b || b.size === 0) return Array.from(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+)$/;
@@ -2505,8 +2827,35 @@ var createRuntime = (doc) => ({
 });
 var sameName3 = (a, b) => a.toUpperCase() === b.toUpperCase();
 var DEFAULT_MAX_HISTORY_BYTES = 64 * 1024 * 1024;
+var AST_CACHE_SIZE = 1e5;
+var RANGE_CACHE_MIN_CELLS = 256;
 var MAX_SPILL_PASSES = 25;
 var spillCellId = (rowId, colId) => `${rowId}\0${colId}`;
+var PositionCache = class {
+  map = /* @__PURE__ */ new Map();
+  scanned = 0;
+  find(list, id) {
+    const pos = this.map.get(id);
+    if (pos !== void 0 && list[pos]?.id === id) return pos;
+    if (pos === void 0 && this.scanned <= list.length) {
+      for (let i = this.scanned; i < list.length; i++) this.map.set(list[i].id, i);
+      this.scanned = list.length;
+      const found2 = this.map.get(id);
+      if (found2 !== void 0 && list[found2]?.id === id) return found2;
+    }
+    this.map.clear();
+    list.forEach((item, i) => this.map.set(item.id, i));
+    this.scanned = list.length;
+    const found = this.map.get(id);
+    return found !== void 0 ? found : -1;
+  }
+};
+var positionCaches = /* @__PURE__ */ new WeakMap();
+function positionOf(list, id) {
+  let cache = positionCaches.get(list);
+  if (!cache) positionCaches.set(list, cache = new PositionCache());
+  return cache.find(list, id);
+}
 var SpreadsheetController = class {
   activeCell = null;
   selectedRange = null;
@@ -2546,6 +2895,10 @@ var SpreadsheetController = class {
   // runtimes, not in the documents, and every recalculation rebuilds them.
   // Cells (sheet-qualified keys) whose spill ownership changed during the current pass.
   spillChanges = null;
+  recalcStats = { evaluated: 0, planned: 0, passes: 0 };
+  // Values of large ranges read while running an evaluation plan (see runEvaluationPlan).
+  astCache = /* @__PURE__ */ new Map();
+  rangeCache = null;
   /** The active sheet's document (the sheet the editor shows). */
   get document() {
     return this.ctx.doc;
@@ -2617,7 +2970,7 @@ var SpreadsheetController = class {
     }
     this.evaluator = new FormulaEvaluator({
       resolveCell: (colStr, rowNum, sheet) => this.onSheet(sheet, () => this.resolveCellByCoord(colStr, rowNum)),
-      resolveRange: (sCol, sRow, eCol, eRow, sheet) => this.onSheet(sheet, () => this.resolveRangeByCoords(sCol, sRow, eCol, eRow)),
+      resolveRange: (sCol, sRow, eCol, eRow, sheet, options2) => this.onSheet(sheet, () => this.resolveRangeByCoords(sCol, sRow, eCol, eRow, options2)),
       resolveProperty: (prop) => this.resolveCurrentRowProperty(prop),
       resolveSpill: (colStr, rowNum, sheet) => this.onSheet(sheet, () => this.resolveSpillByCoord(colStr, rowNum)),
       resolveSheetSpan: (first3, last) => this.resolveSheetSpan(first3, last),
@@ -2877,6 +3230,8 @@ var SpreadsheetController = class {
     });
   }
   getColumn(colIdOrKey) {
+    const byId = this.findColumn(colIdOrKey);
+    if (byId) return byId;
     return this.document.columns.find(
       (c) => c.id === colIdOrKey || c.key.toUpperCase() === colIdOrKey.toUpperCase()
     );
@@ -2885,7 +3240,24 @@ var SpreadsheetController = class {
     if (typeof rowIdOrIndex === "number") {
       return this.document.rows[rowIdOrIndex];
     }
-    return this.document.rows.find((r) => r.id === rowIdOrIndex);
+    return this.findRow(rowIdOrIndex);
+  }
+  /** The row with this id on the current sheet (constant time, see `PositionCache`). */
+  findRow(rowId) {
+    const pos = positionOf(this.document.rows, rowId);
+    return pos < 0 ? void 0 : this.document.rows[pos];
+  }
+  /** The column with this id on the current sheet. */
+  findColumn(colId) {
+    const pos = positionOf(this.document.columns, colId);
+    return pos < 0 ? void 0 : this.document.columns[pos];
+  }
+  /** The column whose key is `key` (`A`, `B`, …): keys follow column positions. */
+  columnByKey(key) {
+    const upper = key.toUpperCase();
+    const col = this.document.columns[colNameToIndex(upper)];
+    if (col && col.key.toUpperCase() === upper) return col;
+    return this.document.columns.find((c) => c.key.toUpperCase() === upper);
   }
   getCell(rowId, colId) {
     const existing = this.document.cells[rowId]?.[colId];
@@ -2895,8 +3267,21 @@ var SpreadsheetController = class {
       if (spilled) return spilled;
     }
     if (existing && !existing.explicitNumberFormat) return existing;
-    const col = this.document.columns.find((c) => c.id === colId);
-    const row = this.document.rows.find((r) => r.id === rowId);
+    return this.finishCell(existing, this.findRow(rowId), this.findColumn(colId));
+  }
+  /** `getCell` for a row and column already looked up. */
+  cellOf(row, col) {
+    const existing = this.document.cells[row.id]?.[col.id];
+    if (existing && existing.raw !== "") return existing;
+    if (this.spillCells.size > 0) {
+      const spilled = this.spillCells.get(spillCellId(row.id, col.id));
+      if (spilled) return spilled;
+    }
+    if (existing && !existing.explicitNumberFormat) return existing;
+    return this.finishCell(existing, row, col);
+  }
+  /** A cell with no value of its own: derived (bound, column formula, blank), keeping an explicit number format. */
+  finishCell(existing, row, col) {
     const derived = this.getDerivedCell(row, col);
     if (!existing) return derived;
     if (derived.raw === "") return existing;
@@ -2928,12 +3313,12 @@ var SpreadsheetController = class {
     return { raw: "", value: "", format: col?.format, ...this.fixedNumberFormatFields(col, void 0) };
   }
   setCellValue(rowId, colId, raw) {
-    this.recordSnapshot();
+    this.recordCellSnapshot(rowId, colId);
     if (!this.document.cells[rowId]) {
       this.document.cells[rowId] = {};
     }
-    const col = this.document.columns.find((c) => c.id === colId);
-    const row = this.document.rows.find((r) => r.id === rowId);
+    const col = this.findColumn(colId);
+    const row = this.findRow(rowId);
     const isFormula = raw.startsWith("=");
     const existing = this.document.cells[rowId][colId];
     let cell;
@@ -2948,6 +3333,7 @@ var SpreadsheetController = class {
     }
     const cellKey2 = this.getCellKey(rowId, colId);
     this.registerFormula(cellKey2, isFormula ? raw : null);
+    this.dropStaleSpillEdges(cellKey2, raw);
     this.document.cells[rowId][colId] = cell;
     this.document.updatedAt = Date.now();
     if (this.batching) {
@@ -2966,8 +3352,8 @@ var SpreadsheetController = class {
     this.onCellCommit?.(rowId, colId, raw, evaluatedVal);
   }
   getCellKey(rowId, colId) {
-    const row = this.document.rows.find((r) => r.id === rowId);
-    const col = this.document.columns.find((c) => c.id === colId);
+    const row = this.findRow(rowId);
+    const col = this.findColumn(colId);
     if (!row || !col) return `${colId}_${rowId}`;
     return `${col.key}${row.index + 1}`.toUpperCase();
   }
@@ -2990,22 +3376,57 @@ var SpreadsheetController = class {
     const key = this.qualify(cellKey2);
     if (!formula || !formula.startsWith("=")) {
       this.depGraph.setCellDependencies(key, []);
+      this.depGraph.setVolatile(key, false);
       return;
     }
     let ast;
     try {
-      ast = parseFormula(formula);
+      ast = this.parseCached(formula);
     } catch {
       this.depGraph.setCellDependencies(key, []);
+      this.depGraph.setVolatile(key, false);
       return;
     }
     const deps = /* @__PURE__ */ new Set();
-    this.collectDependencies(ast, this.ctx, deps, /* @__PURE__ */ new Set());
+    const volatile = { found: false };
+    this.collectDependencies(ast, this.ctx, deps, /* @__PURE__ */ new Set(), volatile);
     this.depGraph.setCellDependencies(key, deps);
+    this.depGraph.setVolatile(key, volatile.found);
+  }
+  /**
+   * Spill edges made stale by new input in `cellKey`: the edges of the array
+   * it anchored (its new formula re-spills when evaluated; spill changes
+   * are recalculated in a further pass) and, when it now holds input, its
+   * edge to the anchor whose values it held. Left in place they can close
+   * false cycles with the new formulas before the anchors are evaluated.
+   */
+  dropStaleSpillEdges(cellKey2, raw) {
+    const key = this.qualify(cellKey2);
+    this.depGraph.setSpillEdges(key, []);
+    if (raw !== "") this.depGraph.detachSpilledCell(key);
+  }
+  /**
+   * The parsed formula, shared by dependency registration and evaluation (so
+   * a load parses each formula once). ASTs are never mutated.
+   */
+  parseCached(formula) {
+    let ast = this.astCache.get(formula);
+    if (!ast) {
+      ast = parseFormula(formula);
+      if (this.astCache.size >= AST_CACHE_SIZE) this.astCache.clear();
+      this.astCache.set(formula, ast);
+    }
+    return ast;
   }
-  /** Adds the qualified keys `ast` depends on, with unqualified references on `home`. */
-  collectDependencies(ast, home, out, seenNames) {
-    for (const dep of extractCellDependencies(ast)) {
+  /**
+   * Adds the qualified keys `ast` depends on, with unqualified references on
+   * `home`: cells, and ranges kept whole (`SHEETID!A1:A50000`), which the
+   * graph indexes as intervals instead of one key per cell. Sets
+   * `volatile.found` when a volatile function (NOW, RAND, …) is used,
+   * directly or through a defined name.
+   */
+  collectDependencies(ast, home, out, seenNames, volatile = { found: false }) {
+    for (const dep of extractReferenceDependencies(ast)) {
       let sheets;
       if (dep.sheet === void 0) {
         sheets = [home];
@@ -3017,11 +3438,19 @@ var SpreadsheetController = class {
         sheets = Array.isArray(span) ? span.map((name) => this.findRuntimeByName(name)) : [];
       }
       for (const rt of sheets) {
-        out.add(dep.row === 0 ? columnDependencyKey(`${rt.doc.id}!${dep.col}`) : this.qualify(`${dep.col}${dep.row}`, rt));
+        out.add(
+          dep.kind === "cell" ? this.qualify(`${dep.col}${dep.row}`, rt) : rangeDependencyKey(dep.startCol, dep.startRow, dep.endCol, dep.endRow, rt.doc.id)
+        );
       }
     }
     for (const used of extractNameDependencies(ast)) {
-      if (used.call && getFormulaFunction(used.name)) continue;
+      if (used.call) {
+        const fn = getFormulaFunction(used.name);
+        if (fn) {
+          if (fn.volatile) volatile.found = true;
+          continue;
+        }
+      }
       const lookupSheet = used.sheet === void 0 ? home : this.findRuntimeByName(used.sheet);
       if (!lookupSheet) continue;
       const def = this.findName(used.name, lookupSheet);
@@ -3032,7 +3461,7 @@ var SpreadsheetController = class {
       if (seenNames.has(seenKey)) continue;
       seenNames.add(seenKey);
       try {
-        this.collectDependencies(parseFormula(def.refersTo), nameHome, out, seenNames);
+        this.collectDependencies(parseFormula(def.refersTo), nameHome, out, seenNames, volatile);
       } catch {
       }
     }
@@ -3047,18 +3476,49 @@ var SpreadsheetController = class {
   recalculateKeys(keys, includeDependents) {
     let pending = Array.from(keys);
     let withDependents = includeDependents;
-    for (let pass = 0; pass < MAX_SPILL_PASSES && pending.length > 0; pass++) {
+    let withVolatile = includeDependents;
+    const stats = { evaluated: 0, planned: 0, passes: 0 };
+    this.recalcStats = stats;
+    for (let pass = 0; pass < MAX_SPILL_PASSES && (pending.length > 0 || withVolatile); pass++) {
       const changed = /* @__PURE__ */ new Set();
       this.spillChanges = changed;
       try {
-        this.runEvaluationPlan(this.depGraph.getEvaluationPlan(pending, { includeDependents: withDependents }));
+        const plan = this.depGraph.getEvaluationPlan(pending, { includeDependents: withDependents, includeVolatile: withVolatile });
+        stats.planned += plan.order.length;
+        stats.passes++;
+        this.runEvaluationPlan(plan);
       } finally {
         this.spillChanges = null;
       }
       pending = Array.from(changed);
       withDependents = true;
+      withVolatile = false;
     }
   }
+  /**
+   * Recalculates cells of the current sheet whose stored input changed (their
+   * formulas already registered), with their dependents, in one plan.
+   */
+  recalculateWrittenCells(cells) {
+    const keys = /* @__PURE__ */ new Set();
+    for (const [rowId, colId] of cells) {
+      const cellKey2 = this.getCellKey(rowId, colId);
+      keys.add(this.qualify(cellKey2));
+      const anchor = this.spilledBy.get(cellKey2);
+      if (anchor) keys.add(this.qualify(anchor));
+    }
+    this.recalculateKeys(keys, true);
+  }
+  /**
+   * Work done by the last recalculation (an edit, paste, import, load or
+   * full recalculation): formulas evaluated, cells planned (formulas, their
+   * dependents and spilled cells) and passes (more than one when spill
+   * ranges changed). Deterministic, unlike timings: use it to check that an
+   * edit only recalculates what depends on it.
+   */
+  getRecalculationStats() {
+    return { ...this.recalcStats };
+  }
   /**
    * Rebuilds the dependency graph from scratch and recalculates every formula
    * in dependency order.
@@ -3072,10 +3532,14 @@ var SpreadsheetController = class {
         this.spills.clear();
         this.spilledBy.clear();
         this.spillCells.clear();
+        const columns = this.document.columns;
+        const deriving = columns.map((col) => col.type === "bound" || col.type === "formula");
         for (const row of this.document.rows) {
-          for (const col of this.document.columns) {
-            const cell = this.document.cells[row.id]?.[col.id] ?? this.getDerivedCell(row, col);
-            if (cell.raw.startsWith("=")) {
+          const stored = this.document.cells[row.id];
+          for (let c = 0; c < columns.length; c++) {
+            const col = columns[c];
+            const cell = stored?.[col.id] ?? (deriving[c] ? this.getDerivedCell(row, col) : null);
+            if (cell && typeof cell.raw === "string" && cell.raw.startsWith("=")) {
               const cellKey2 = `${col.key}${row.index + 1}`.toUpperCase();
               this.registerFormula(cellKey2, cell.raw);
               formulaKeys.push(this.qualify(cellKey2));
@@ -3087,25 +3551,45 @@ var SpreadsheetController = class {
     this.recalculateKeys(formulaKeys, false);
   }
   runEvaluationPlan(plan) {
-    for (const qualified of plan.order) {
-      const located = this.unqualify(qualified);
-      if (!located) continue;
-      const onActive = located.rt === this.active;
-      this.withSheet(located.rt, () => {
-        if (onActive) this.markValueChanged(located.key);
-        if (plan.cyclic.has(qualified)) {
-          this.markCycle(located.key);
-        } else {
-          this.evalSingleCellByKey(located.key);
-        }
-        if (onActive) this.markValueChanged(located.key);
-      });
+    this.rangeCache = /* @__PURE__ */ new Map();
+    try {
+      for (const qualified of plan.order) {
+        const located = this.unqualify(qualified);
+        if (!located) continue;
+        const onActive = located.rt === this.active;
+        this.withSheet(located.rt, () => {
+          const hadSpill = this.spills.has(located.key);
+          const spillChanges = this.spillChanges?.size ?? 0;
+          if (onActive) this.markValueChanged(located.key);
+          if (plan.cyclic.has(qualified)) {
+            this.markCycle(located.key);
+          } else {
+            this.evalSingleCellByKey(located.key);
+          }
+          if (onActive) this.markValueChanged(located.key);
+          const spilled = hadSpill || this.spills.has(located.key) || (this.spillChanges?.size ?? 0) !== spillChanges;
+          this.invalidateRangeCache(located.rt.doc.id, spilled ? null : colNameToIndex(located.key.replace(/\d+$/, "")));
+        });
+      }
+    } finally {
+      this.rangeCache = null;
+    }
+  }
+  /**
+   * Drops cached ranges of `sheetId` that cover column `col` (whose cell was
+   * just evaluated), or all of the sheet's when `col` is null (spilled
+   * values moved or changed).
+   */
+  invalidateRangeCache(sheetId, col) {
+    if (!this.rangeCache || this.rangeCache.size === 0) return;
+    for (const [key, entry] of this.rangeCache) {
+      if (entry.sheet === sheetId && (col === null || col >= entry.c0 && col <= entry.c1)) this.rangeCache.delete(key);
     }
   }
   locateCellKey(cellKey2) {
     const match = cellKey2.match(/^([A-Za-z]+)(\d+)$/);
     if (!match) return null;
-    const col = this.document.columns.find((c) => c.key.toUpperCase() === match[1].toUpperCase());
+    const col = this.columnByKey(match[1]);
     const row = this.document.rows[parseInt(match[2], 10) - 1];
     return col && row ? { row, col } : null;
   }
@@ -3117,10 +3601,8 @@ var SpreadsheetController = class {
     if (!cell.raw.startsWith("=")) return;
     if (!this.document.cells[row.id]) this.document.cells[row.id] = {};
     const qualified = this.qualify(cellKey2);
-    const deps = this.depGraph.getDependencies(qualified);
-    const selfReference = deps.includes(qualified) || deps.includes(columnDependencyKey(`${this.document.id}!${col.key}`));
-    const spilledKeys = this.depGraph.getSpilledKeys(qualified);
-    const ownSpill = deps.find((dep) => spilledKeys.includes(dep));
+    const selfReference = this.depGraph.dependsOn(qualified, qualified);
+    const ownSpill = selfReference ? void 0 : this.depGraph.getSpilledKeys(qualified).find((key) => this.depGraph.dependsOn(qualified, key));
     const errorMessage = selfReference ? "This formula can't reference its own cell." : ownSpill ? `This formula refers to ${ownSpill.slice(ownSpill.lastIndexOf("!") + 1)}, 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(cellKey2.toUpperCase(), true);
     this.document.cells[row.id][col.id] = { ...cell, value: "#CYCLE!", error: "#CYCLE!", errorMessage };
@@ -3130,7 +3612,7 @@ var SpreadsheetController = class {
     if (!match) return;
     const colName = match[1].toUpperCase();
     const rowNum = parseInt(match[2], 10);
-    const col = this.document.columns.find((c) => c.key.toUpperCase() === colName);
+    const col = this.columnByKey(colName);
     const row = this.document.rows[rowNum - 1];
     if (!col || !row) return;
     const cell = this.getCell(row.id, col.id);
@@ -3145,13 +3627,19 @@ var SpreadsheetController = class {
     try {
       this.evaluatingRowIndex = rowNum - 1;
       this.evaluatingCell = { col: colName, row: rowNum };
-      const result = this.evaluator.evaluateWithDiagnostics(cell.raw);
+      this.recalcStats.evaluated++;
+      let parsed = cell.raw;
+      try {
+        parsed = this.parseCached(cell.raw);
+      } catch {
+      }
+      const result = this.evaluator.evaluateWithDiagnostics(parsed);
       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);
+        const blocked = this.placeSpill(`${colName}${rowNum}`, rowNum - 1, positionOf(this.document.columns, col.id), result.array);
         if (blocked) {
           value = "#SPILL!";
           error = "#SPILL!";
@@ -3215,6 +3703,7 @@ var SpreadsheetController = class {
       return reason;
     }
     const previous = this.spills.get(anchor);
+    const linked = new Set(this.depGraph.getSpilledKeys(this.qualify(anchor)));
     const cells = [];
     for (let c = 0; c < cols; c++) {
       const column = this.document.columns[col + c];
@@ -3238,6 +3727,8 @@ var SpreadsheetController = class {
         if (this.spilledBy.get(key) !== anchor) {
           this.spilledBy.set(key, anchor);
           this.spillChanges?.add(this.qualify(key));
+        } else if (!linked.has(this.qualify(key))) {
+          this.spillChanges?.add(this.qualify(key));
         }
         cells.push({ key, rowId: rowObj.id, colId: column.id });
       }
@@ -3317,36 +3808,65 @@ var SpreadsheetController = class {
     return false;
   }
   resolveCellByCoord(colStr, rowNum) {
-    const col = this.document.columns.find((c) => c.key.toUpperCase() === colStr.toUpperCase());
+    const col = this.columnByKey(colStr);
     const row = this.document.rows[rowNum - 1];
     if (!col || !row) return 0;
     const override = this.valueOverride;
     if (override && override.row === rowNum - 1 && this.document.columns[override.col] === col) return override.value;
-    return this.getCell(row.id, col.id).value ?? "";
+    return this.cellOf(row, col).value ?? "";
   }
-  resolveRangeByCoords(sCol, sRow, eCol, eRow) {
+  /**
+   * Values of a range, column by column. With `skipBlanks` (functions that
+   * ignore blank cells: SUM, COUNT, AVERAGE, …) blank cells are left out, so
+   * a sparse column costs one lookup per row and no array slot.
+   */
+  resolveRangeByCoords(sCol, sRow, eCol, eRow, options) {
     const startC = colNameToIndex(sCol);
     const endC = colNameToIndex(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), WHOLE_COLUMN_END_ROW, this.document.rows.length);
+    const skipBlanks = options?.skipBlanks === true;
+    const cacheable = this.rangeCache !== null && !this.valueOverride && (maxC - minC + 1) * (maxR - minR + 1) >= RANGE_CACHE_MIN_CELLS;
+    const cacheKey = cacheable ? `${this.document.id}|${minC}|${maxC}|${minR}|${maxR}|${skipBlanks ? 1 : 0}` : "";
+    if (cacheable) {
+      const hit = this.rangeCache.get(cacheKey);
+      if (hit) return hit.values.slice();
+    }
+    const rows = this.document.rows;
+    const cells = this.document.cells;
+    const spills = this.spillCells.size > 0 ? this.spillCells : null;
     const results = [];
     for (let c = minC; c <= maxC; c++) {
-      const colName = indexToColName(c);
-      const col = this.document.columns.find((colDef) => colDef.key.toUpperCase() === colName);
+      const col = this.columnByKey(indexToColName(c));
       if (!col) continue;
+      const plain = col.type !== "bound" && col.type !== "formula";
+      const colId = col.id;
       const override = this.valueOverride && this.document.columns[this.valueOverride.col] === col ? this.valueOverride : null;
       for (let r = minR; r <= maxR; r++) {
-        const row = this.document.rows[r - 1];
+        const row = rows[r - 1];
         if (!row) continue;
+        let value;
         if (override && override.row === r - 1) {
-          results.push(override.value);
-          continue;
+          value = override.value;
+        } else {
+          const stored = cells[row.id]?.[colId];
+          if (stored && stored.raw !== "") value = stored.value;
+          else {
+            const spilled = spills?.get(spillCellId(row.id, colId));
+            if (spilled) value = spilled.value;
+            else if (stored && (plain || !stored.explicitNumberFormat)) value = stored.value;
+            else if (plain) value = "";
+            else value = this.cellOf(row, col).value;
+          }
         }
-        results.push(this.getCell(row.id, col.id).value ?? "");
+        if (value === void 0 || value === null) value = "";
+        if (skipBlanks && value === "") continue;
+        results.push(value);
       }
     }
+    if (cacheable) this.rangeCache.set(cacheKey, { sheet: this.document.id, c0: minC, c1: maxC, values: results.slice() });
     return results;
   }
   resolveCurrentRowProperty(prop) {
@@ -3438,8 +3958,8 @@ var SpreadsheetController = class {
    */
   commitCellInput(rowId, colId, raw) {
     if (this.validationPrompt) return { status: "pending", prompt: this.validationPrompt };
-    const row = this.document.rows.findIndex((r) => r.id === rowId);
-    const col = this.document.columns.findIndex((c) => c.id === colId);
+    const row = positionOf(this.document.rows, rowId);
+    const col = positionOf(this.document.columns, colId);
     if (row === -1 || col === -1) return { status: "none" };
     const failed = this.checkInput(rowId, colId, row, col, raw, false);
     if (failed) return failed;
@@ -3708,6 +4228,8 @@ var SpreadsheetController = class {
    */
   runBatch(fn) {
     this.recordSnapshot();
+    const rowCount = this.document.rows.length;
+    const colCount = this.document.columns.length;
     this.batching = true;
     this.pendingCommits = [];
     try {
@@ -3715,8 +4237,14 @@ var SpreadsheetController = class {
     } finally {
       this.batching = false;
     }
+    const grew = this.document.rows.length !== rowCount || this.document.columns.length !== colCount;
     this.recomputeRowIndices();
-    this.recalculateAll();
+    if (grew) {
+      this.recalculateAll();
+    } else {
+      this.cfDirty = "all";
+      this.recalculateWrittenCells(this.pendingCommits.map(([rowId, colId]) => [rowId, colId]));
+    }
     this.document.updatedAt = Date.now();
     this.notifyChange();
     const commits = this.pendingCommits;
@@ -4742,6 +5270,17 @@ var SpreadsheetController = class {
     if (this.isApplyingHistory || this.batching) return;
     this.pushUndo({ kind: "sheet", sheetId: this.ctx.doc.id, data: JSON.stringify(this.ctx.doc) });
   }
+  /** Records the stored state of one cell, for undoing a single-cell edit. */
+  recordCellSnapshot(rowId, colId) {
+    if (this.isApplyingHistory || this.batching) return;
+    this.pushUndo({ kind: "cells", sheetId: this.ctx.doc.id, data: JSON.stringify(this.cellHistory(this.ctx.doc, [[rowId, colId]])) });
+  }
+  cellHistory(doc, cells) {
+    return {
+      cells: cells.map(([rowId, colId]) => [rowId, colId, doc.cells[rowId]?.[colId] ?? null, doc.cells[rowId] !== void 0]),
+      updatedAt: doc.updatedAt
+    };
+  }
   recordWorkbookSnapshot() {
     if (this.isApplyingHistory || this.batching) return;
     this.pushUndo({ kind: "workbook", data: JSON.stringify(this.workbookSnapshot()) });
@@ -4783,6 +5322,37 @@ var SpreadsheetController = class {
     if (!entry) return;
     this.isApplyingHistory = true;
     try {
+      if (entry.kind === "cells") {
+        const rt = this.findRuntimeById(entry.sheetId);
+        if (!rt) return;
+        const saved = JSON.parse(entry.data);
+        const positions = saved.cells.map(([rowId, colId]) => [rowId, colId]);
+        to.push({ kind: "cells", sheetId: rt.doc.id, data: JSON.stringify(this.cellHistory(rt.doc, positions)) });
+        for (const [rowId, colId, cell, rowExisted] of saved.cells) {
+          if (cell) {
+            (rt.doc.cells[rowId] ??= {})[colId] = cell;
+          } else if (rt.doc.cells[rowId]) {
+            delete rt.doc.cells[rowId][colId];
+            if (!rowExisted && Object.keys(rt.doc.cells[rowId]).length === 0) delete rt.doc.cells[rowId];
+          }
+        }
+        if (saved.updatedAt !== void 0) rt.doc.updatedAt = saved.updatedAt;
+        if (rt !== this.active) {
+          this.ctx = this.active;
+          this.activateRuntime(rt);
+        }
+        this.withSheet(rt, () => {
+          for (const [rowId, colId] of positions) {
+            const raw = rt.doc.cells[rowId]?.[colId]?.raw;
+            const cellKey2 = this.getCellKey(rowId, colId);
+            this.registerFormula(cellKey2, raw?.startsWith("=") ? raw : null);
+            this.dropStaleSpillEdges(cellKey2, raw ?? "");
+          }
+          this.recalculateWrittenCells(positions);
+        });
+        this.notifyChange();
+        return;
+      }
       if (entry.kind === "sheet") {
         const rt = this.findRuntimeById(entry.sheetId);
         if (!rt) return;
@@ -4999,7 +5569,7 @@ var SpreadsheetController = class {
       const changed = [];
       for (const key of this.cfDirty) {
         const located = this.locateCellKey(key);
-        if (located) changed.push({ row: located.row.index, col: this.document.columns.indexOf(located.col) });
+        if (located) changed.push({ row: located.row.index, col: positionOf(this.document.columns, located.col.id) });
       }
       this.cfEngine.setSheet(sheet);
       this.cfEngine.update(rules, changed);
@@ -5606,10 +6176,180 @@ function getNameManagerRows(controller) {
   }).sort((a, b) => a.name.localeCompare(b.name) || a.scopeLabel.localeCompare(b.scopeLabel));
 }
 
+// src/spreadsheet/viewport.ts
+var SPREADSHEET_COLUMN_HEADER_HEIGHT = 28;
+var SPREADSHEET_ROW_HEADER_WIDTH = 48;
+var SPREADSHEET_GROUP_ROW_HEIGHT = 28;
+var SPREADSHEET_VIRTUAL_ROW_THRESHOLD = 200;
+var SPREADSHEET_VIRTUAL_COLUMN_THRESHOLD = 60;
+var SPREADSHEET_DEFAULT_VIEWPORT = { width: 1200, height: 600 };
+function measureSpreadsheetView(view) {
+  const rowTops = new Float64Array(view.rows.length + 1);
+  const rowPosition = /* @__PURE__ */ new Map();
+  let frozenRows = 0;
+  let top = 0;
+  view.rows.forEach((viewRow, i) => {
+    rowTops[i] = top;
+    if (viewRow.kind === "row") {
+      rowPosition.set(viewRow.index, i);
+      if (viewRow.frozen && frozenRows === i) frozenRows = i + 1;
+      top += viewRow.row.height || DEFAULT_ROW_HEIGHT;
+    } else {
+      top += SPREADSHEET_GROUP_ROW_HEIGHT;
+    }
+  });
+  rowTops[view.rows.length] = top;
+  const columnLefts = new Float64Array(view.columns.length + 1);
+  const columnPosition = /* @__PURE__ */ new Map();
+  let frozenColumns = 0;
+  let left = 0;
+  view.columns.forEach((viewCol, i) => {
+    columnLefts[i] = left;
+    columnPosition.set(viewCol.index, i);
+    if (viewCol.frozen && frozenColumns === i) frozenColumns = i + 1;
+    left += viewCol.column.width || DEFAULT_COLUMN_WIDTH;
+  });
+  columnLefts[view.columns.length] = left;
+  return { rowTops, columnLefts, frozenRows, frozenColumns, rowPosition, columnPosition };
+}
+function shouldVirtualizeSpreadsheet(view, mode = "auto") {
+  if (mode !== "auto") return mode;
+  return view.rows.length > SPREADSHEET_VIRTUAL_ROW_THRESHOLD || view.columns.length > SPREADSHEET_VIRTUAL_COLUMN_THRESHOLD;
+}
+function fullSpreadsheetViewWindow(metrics) {
+  return {
+    virtual: false,
+    frozenRows: metrics.frozenRows,
+    rowStart: metrics.frozenRows,
+    rowEnd: metrics.rowTops.length - 1,
+    topSpace: 0,
+    bottomSpace: 0,
+    frozenColumns: metrics.frozenColumns,
+    colStart: metrics.frozenColumns,
+    colEnd: metrics.columnLefts.length - 1,
+    leftSpace: 0,
+    rightSpace: 0
+  };
+}
+function entryAt(edges, value, lo, hi) {
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (edges[mid + 1] <= value) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function visibleSlice(edges, frozen, from, to, overscan) {
+  const count = edges.length - 1;
+  if (count <= frozen) return [frozen, frozen];
+  const first2 = entryAt(edges, from, frozen, count);
+  const last = entryAt(edges, Math.max(from, to - 1), first2, count);
+  return [Math.max(frozen, first2 - overscan), Math.min(count, last + 1 + overscan)];
+}
+function getSpreadsheetViewWindow(metrics, viewport, options = {}) {
+  const overscanRows = options.overscanRows ?? 8;
+  const overscanColumns = options.overscanColumns ?? 2;
+  const height = viewport.height > 0 ? viewport.height : SPREADSHEET_DEFAULT_VIEWPORT.height;
+  const width = viewport.width > 0 ? viewport.width : SPREADSHEET_DEFAULT_VIEWPORT.width;
+  const { rowTops, columnLefts, frozenRows, frozenColumns } = metrics;
+  const rowCount = rowTops.length - 1;
+  const colCount = columnLefts.length - 1;
+  const top = Math.max(0, viewport.scrollTop);
+  let [rowStart, rowEnd] = visibleSlice(rowTops, frozenRows, top, top + Math.max(0, height - SPREADSHEET_COLUMN_HEADER_HEIGHT), overscanRows);
+  const left = Math.max(0, viewport.scrollLeft);
+  let [colStart, colEnd] = visibleSlice(columnLefts, frozenColumns, left, left + Math.max(0, width - SPREADSHEET_ROW_HEADER_WIDTH), overscanColumns);
+  const merges = options.merges ?? [];
+  for (let changed = merges.length > 0, guard = 0; changed && guard < 8; guard++) {
+    changed = false;
+    for (const raw of merges) {
+      const merge = normalizeRange(raw);
+      const rows = displayedSpan(metrics.rowPosition, merge.startRow, merge.endRow);
+      const cols = displayedSpan(metrics.columnPosition, merge.startCol, merge.endCol);
+      if (!rows || !cols) continue;
+      const rowsMeet = rows[1] >= rowStart && rows[0] < rowEnd;
+      const colsMeet = cols[1] >= colStart && cols[0] < colEnd;
+      if (!rowsMeet && !(rows[1] < frozenRows)) continue;
+      if (!colsMeet && !(cols[1] < frozenColumns)) continue;
+      if (rowsMeet) {
+        const s = Math.max(frozenRows, rows[0]);
+        const e = rows[1] + 1;
+        if (s < rowStart || e > rowEnd) {
+          rowStart = Math.min(rowStart, s);
+          rowEnd = Math.max(rowEnd, e);
+          changed = true;
+        }
+      }
+      if (colsMeet) {
+        const s = Math.max(frozenColumns, cols[0]);
+        const e = cols[1] + 1;
+        if (s < colStart || e > colEnd) {
+          colStart = Math.min(colStart, s);
+          colEnd = Math.max(colEnd, e);
+          changed = true;
+        }
+      }
+    }
+  }
+  return {
+    virtual: true,
+    frozenRows,
+    rowStart,
+    rowEnd,
+    topSpace: rowTops[rowStart] - rowTops[frozenRows],
+    bottomSpace: rowTops[rowCount] - rowTops[rowEnd],
+    frozenColumns,
+    colStart,
+    colEnd,
+    leftSpace: columnLefts[colStart] - columnLefts[frozenColumns],
+    rightSpace: columnLefts[colCount] - columnLefts[colEnd]
+  };
+}
+function displayedSpan(positions, from, to) {
+  let lo = Infinity;
+  let hi = -Infinity;
+  for (let i = from; i <= to; i++) {
+    const pos = positions.get(i);
+    if (pos === void 0) continue;
+    if (pos < lo) lo = pos;
+    if (pos > hi) hi = pos;
+  }
+  return lo === Infinity ? null : [lo, hi];
+}
+function getSpreadsheetScrollToCell(metrics, viewport, cell) {
+  const height = viewport.height > 0 ? viewport.height : SPREADSHEET_DEFAULT_VIEWPORT.height;
+  const width = viewport.width > 0 ? viewport.width : SPREADSHEET_DEFAULT_VIEWPORT.width;
+  const result = {};
+  const rowPos = metrics.rowPosition.get(cell.row);
+  if (rowPos !== void 0 && rowPos >= metrics.frozenRows) {
+    const frozenHeight = metrics.rowTops[metrics.frozenRows];
+    const top = metrics.rowTops[rowPos];
+    const bottom = metrics.rowTops[rowPos + 1];
+    const visibleHeight = height - SPREADSHEET_COLUMN_HEADER_HEIGHT;
+    if (top < viewport.scrollTop + frozenHeight) result.scrollTop = Math.max(0, top - frozenHeight);
+    else if (bottom > viewport.scrollTop + visibleHeight) result.scrollTop = Math.max(0, bottom - visibleHeight);
+  }
+  const colPos = metrics.columnPosition.get(cell.col);
+  if (colPos !== void 0 && colPos >= metrics.frozenColumns) {
+    const frozenWidth = metrics.columnLefts[metrics.frozenColumns];
+    const left = metrics.columnLefts[colPos];
+    const right = metrics.columnLefts[colPos + 1];
+    const visibleWidth = width - SPREADSHEET_ROW_HEADER_WIDTH;
+    if (left < viewport.scrollLeft + frozenWidth) result.scrollLeft = Math.max(0, left - frozenWidth);
+    else if (right > viewport.scrollLeft + visibleWidth) result.scrollLeft = Math.max(0, right - visibleWidth);
+  }
+  return result.scrollTop === void 0 && result.scrollLeft === void 0 ? null : result;
+}
+function sameSpreadsheetViewWindow(a, b) {
+  return a.virtual === b.virtual && a.rowStart === b.rowStart && a.rowEnd === b.rowEnd && a.colStart === b.colStart && a.colEnd === b.colEnd && a.topSpace === b.topSpace && a.bottomSpace === b.bottomSpace && a.leftSpace === b.leftSpace && a.rightSpace === b.rightSpace;
+}
+
 export {
   extractNameDependencies,
   columnDependencyKey,
   extractCellDependencies,
+  extractReferenceDependencies,
+  rangeDependencyKey,
+  IntervalIndex,
   DependencyGraph,
   shiftFormulaReferences,
   mapFormulaReferences,
@@ -5721,6 +6461,18 @@ export {
   importFileIntoSpreadsheet,
   getSheetTabMenuItems,
   sheetDropIndex,
-  getNameManagerRows
+  getNameManagerRows,
+  SPREADSHEET_COLUMN_HEADER_HEIGHT,
+  SPREADSHEET_ROW_HEADER_WIDTH,
+  SPREADSHEET_GROUP_ROW_HEIGHT,
+  SPREADSHEET_VIRTUAL_ROW_THRESHOLD,
+  SPREADSHEET_VIRTUAL_COLUMN_THRESHOLD,
+  SPREADSHEET_DEFAULT_VIEWPORT,
+  measureSpreadsheetView,
+  shouldVirtualizeSpreadsheet,
+  fullSpreadsheetViewWindow,
+  getSpreadsheetViewWindow,
+  getSpreadsheetScrollToCell,
+  sameSpreadsheetViewWindow
 };
-//# sourceMappingURL=chunk-RR7F5GUM.js.map
+//# sourceMappingURL=chunk-X7HXL2SB.js.map