@pixerate/editor 0.24.0 → 0.25.0

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

@@ -19,30 +19,64 @@ import {
   indexToColName,
   isBlank,
   isFormulaError,
+  numberToText,
   numericValue,
   parseCellInput,
   parseFormula,
   parseIsoDate,
   searchFormulaFunctions,
+  serialFromYmd,
+  serialToDate,
   sortCompareValues,
+  toBoolean,
   toText,
   tokenizeFormula
-} from "./chunk-3CN2WD3X.js";
+} from "./chunk-FH6F67DN.js";
 
 // src/spreadsheet/formula/dependency-graph.ts
+function extractNameDependencies(node) {
+  const names = [];
+  const stack = [node];
+  while (stack.length > 0) {
+    const curr = stack.pop();
+    switch (curr.type) {
+      case "Name":
+        names.push(curr.sheet === void 0 ? { name: curr.name, call: false } : { name: curr.name, sheet: curr.sheet, call: false });
+        break;
+      case "FunctionCall":
+        names.push({ name: curr.name, call: true });
+        for (const arg of curr.args) stack.push(arg);
+        break;
+      case "Invoke":
+        stack.push(curr.callee);
+        for (const arg of curr.args) stack.push(arg);
+        break;
+      case "BinaryOp":
+        stack.push(curr.left, curr.right);
+        break;
+      case "UnaryOp":
+        stack.push(curr.argument);
+        break;
+      default:
+        break;
+    }
+  }
+  return names;
+}
 var columnDependencyKey = (col) => `${col.toUpperCase()}:`;
 function extractCellDependencies(node) {
   const deps = [];
   const visit = (curr) => {
+    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 } : {};
     if (curr.type === "CellRef") {
-      deps.push({ col: curr.col, row: curr.row });
+      deps.push({ col: curr.col, row: curr.row, ...sheet });
     } else if (curr.type === "SpillRef") {
-      deps.push({ col: curr.col, row: curr.row });
+      deps.push({ col: curr.col, row: curr.row, ...sheet });
     } else if (curr.type === "Range" && curr.endRow >= WHOLE_COLUMN_END_ROW) {
       const startC = colNameToIndex(curr.startCol);
       const endC = colNameToIndex(curr.endCol);
       for (let c = Math.min(startC, endC); c <= Math.max(startC, endC); c++) {
-        deps.push({ col: indexToColName(c), row: 0 });
+        deps.push({ col: indexToColName(c), row: 0, ...sheet });
       }
     } else if (curr.type === "Range") {
       const startC = colNameToIndex(curr.startCol);
@@ -53,7 +87,7 @@ function extractCellDependencies(node) {
       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: indexToColName(c), row: r });
+          deps.push({ col: indexToColName(c), row: r, ...sheet });
         }
       }
     } else if (curr.type === "BinaryOp") {
@@ -63,6 +97,9 @@ function extractCellDependencies(node) {
       visit(curr.argument);
     } else if (curr.type === "FunctionCall") {
       curr.args.forEach(visit);
+    } else if (curr.type === "Invoke") {
+      visit(curr.callee);
+      curr.args.forEach(visit);
     }
   };
   visit(node);
@@ -81,8 +118,29 @@ var DependencyGraph = class {
   spillDependents = /* @__PURE__ */ new Map();
   // anchor -> the edges it registered (so they can be replaced).
   spillEdges = /* @__PURE__ */ new Map();
-  setCellFormula(cellKey, formulaStr) {
-    const key = cellKey.toUpperCase();
+  /**
+   * 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.
+   */
+  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();
+    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);
+    }
+    if (deps.size > 0) this.dependencies.set(key, deps);
+  }
+  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);
@@ -146,20 +204,20 @@ var DependencyGraph = class {
     return (this.spillEdges.get(anchor) ?? []).filter(([, to]) => to === anchor).map(([from]) => from);
   }
   /** Formula dependencies plus dynamic-array (spill) dependencies of a cell. */
-  getDependencies(cellKey) {
-    const key = cellKey.toUpperCase();
+  getDependencies(cellKey2) {
+    const key = cellKey2.toUpperCase();
     return unionOf(this.dependencies.get(key), this.spillDependencies.get(key));
   }
   /** Cells depending on `cellKey`, through formulas or spills. */
-  getDependents(cellKey) {
-    const key = cellKey.toUpperCase();
+  getDependents(cellKey2) {
+    const key = cellKey2.toUpperCase();
     return unionOf(this.dependents.get(key), this.spillDependents.get(key));
   }
   /**
    * Detects if there is a cycle containing cellKey.
    */
-  hasCycle(cellKey) {
-    const key = cellKey.toUpperCase();
+  hasCycle(cellKey2) {
+    const key = cellKey2.toUpperCase();
     const visited = /* @__PURE__ */ new Set();
     const recStack = /* @__PURE__ */ new Set();
     const dfs = (node) => {
@@ -390,8 +448,11 @@ function rewriteReference(text, change) {
   const newEnd = { ...end, [key]: startValue <= endValue ? hi : lo };
   return `${formatPart(newStart)}:${formatPart(newEnd)}`;
 }
-function shiftFormulaReferences(formula, change) {
-  return mapFormulaReferences(formula, (text) => rewriteReference(text, change));
+function shiftFormulaReferences(formula, change, options = {}) {
+  return mapFormulaReferences(
+    formula,
+    (text, info) => !options.appliesTo || options.appliesTo(info.sheet, info.sheetEnd) ? rewriteReference(text, change) : text
+  );
 }
 function mapFormulaReferences(formula, rewrite) {
   if (!formula.startsWith("=")) return formula;
@@ -407,16 +468,20 @@ function mapFormulaReferences(formula, rewrite) {
     const token = tokens[i];
     if (token.type !== "CELL_REF" && token.type !== "RANGE" && token.type !== "SPILL_REF") continue;
     if (tokens[i + 1]?.type === "LPAREN") continue;
-    let end = token.position;
+    const refStart = token.refStart ?? token.position;
+    let end = refStart;
     while (end < formula.length && REF_CHAR.test(formula[end])) end++;
-    const original = formula.slice(token.position, end);
+    const original = formula.slice(refStart, end);
+    const info = token.sheet === void 0 ? {} : token.sheetEnd === void 0 ? { sheet: token.sheet } : { sheet: token.sheet, sheetEnd: token.sheetEnd };
+    const prefix = formula.slice(token.position, refStart);
     if (token.type === "SPILL_REF") {
-      const rewritten = rewrite(original);
-      result += formula.slice(cursor, token.position) + (rewritten === "#REF!" ? rewritten : `${rewritten}#`);
+      const rewritten2 = rewrite(original, info);
+      result += formula.slice(cursor, token.position) + (rewritten2 === "#REF!" ? rewritten2 : `${prefix}${rewritten2}#`);
       cursor = end + 1;
       continue;
     }
-    result += formula.slice(cursor, token.position) + rewrite(original);
+    const rewritten = rewrite(original, info);
+    result += formula.slice(cursor, token.position) + (rewritten === "#REF!" ? rewritten : prefix + rewritten);
     cursor = end;
   }
   return result + formula.slice(cursor);
@@ -437,8 +502,9 @@ function offsetFormulaReferences(formula, rowOffset, colOffset) {
   });
 }
 var MAX_REMAP_RANGE_CELLS = 1e5;
-function remapFormulaReferences(formula, moveCell) {
-  return mapFormulaReferences(formula, (text) => {
+function remapFormulaReferences(formula, moveCell, options = {}) {
+  return mapFormulaReferences(formula, (text, info) => {
+    if (options.appliesTo && !options.appliesTo(info.sheet, info.sheetEnd)) return text;
     const parts = text.split(":").map(parsePart);
     if (parts.some((p) => p === null)) return text;
     const [start, end] = parts;
@@ -475,6 +541,101 @@ function remapFormulaReferences(formula, moveCell) {
     return `${formatPart({ ...start, row: minR, col: minC })}:${formatPart({ ...end, row: maxR, col: maxC })}`;
   });
 }
+var CELL_LIKE = /^[A-Za-z]{1,3}\d{1,7}$/;
+var isCellLike = (name) => {
+  if (!CELL_LIKE.test(name)) return false;
+  const letters = name.match(/^[A-Za-z]+/)[0].toUpperCase();
+  const col = Array.from(letters).reduce((n, ch) => n * 26 + ch.charCodeAt(0) - 64, 0);
+  const row = Number(name.slice(letters.length));
+  return col <= 16384 && row >= 1 && row <= 1048576;
+};
+var R1C1_LIKE = /^[Rr]\d*(?:[Cc]\d*)?$|^[Cc]\d*$/;
+function sheetNameNeedsQuotes(name) {
+  if (!/^[A-Za-z_\p{L}][\p{L}\p{N}_.]*$/u.test(name)) return true;
+  const upper = name.toUpperCase();
+  return isCellLike(name) || R1C1_LIKE.test(name) || upper === "TRUE" || upper === "FALSE";
+}
+function quoteSheetName(name) {
+  return sheetNameNeedsQuotes(name) ? `'${name.replace(/'/g, "''")}'` : name;
+}
+function formatSheetPrefix(sheet, sheetEnd) {
+  if (sheetEnd === void 0) return `${quoteSheetName(sheet)}!`;
+  const quoted = sheetNameNeedsQuotes(sheet) || sheetNameNeedsQuotes(sheetEnd);
+  return quoted ? `'${`${sheet}:${sheetEnd}`.replace(/'/g, "''")}'!` : `${sheet}:${sheetEnd}!`;
+}
+function tokensOf(formula) {
+  if (!formula.startsWith("=")) return null;
+  try {
+    return tokenizeFormula(formula);
+  } catch {
+    return null;
+  }
+}
+function rewriteTokens(formula, edit) {
+  const tokens = tokensOf(formula);
+  if (!tokens) return formula;
+  let result = "";
+  let cursor = 0;
+  for (const token of tokens) {
+    const change = edit(token);
+    if (!change) continue;
+    result += formula.slice(cursor, change.from) + change.text;
+    cursor = change.to;
+  }
+  return cursor === 0 ? formula : result + formula.slice(cursor);
+}
+var sameName = (a, b) => a.toUpperCase() === b.toUpperCase();
+function renameSheetInFormula(formula, oldName, newName) {
+  return rewriteTokens(formula, (token) => {
+    if (token.sheet === void 0 || token.refStart === void 0) return null;
+    const first2 = sameName(token.sheet, oldName);
+    const last = token.sheetEnd !== void 0 && sameName(token.sheetEnd, oldName);
+    if (!first2 && !last) return null;
+    const sheet = first2 ? newName : token.sheet;
+    const sheetEnd = token.sheetEnd === void 0 ? void 0 : last ? newName : token.sheetEnd;
+    return { from: token.position, to: token.refStart, text: formatSheetPrefix(sheet, sheetEnd) };
+  });
+}
+function deleteSheetInFormula(formula, name, order = []) {
+  const position = (sheet) => order.findIndex((s) => sameName(s, sheet));
+  return rewriteTokens(formula, (token) => {
+    if (token.sheet === void 0 || token.refStart === void 0) return null;
+    const end = token.end ?? token.refStart;
+    if (token.sheetEnd === void 0) {
+      return sameName(token.sheet, name) ? { from: token.position, to: end, text: "#REF!" } : null;
+    }
+    const first2 = sameName(token.sheet, name);
+    const last = sameName(token.sheetEnd, name);
+    if (!first2 && !last) return null;
+    const a = position(token.sheet);
+    const b = position(token.sheetEnd);
+    if (a < 0 || b < 0 || a === b) return { from: token.position, to: end, text: "#REF!" };
+    const inward = (from, to) => order[from < to ? from + 1 : from - 1];
+    const newFirst = first2 ? inward(a, b) : token.sheet;
+    const newLast = last ? inward(b, a) : token.sheetEnd;
+    const prefix = sameName(newFirst, newLast) ? formatSheetPrefix(newFirst) : formatSheetPrefix(newFirst, newLast);
+    return { from: token.position, to: token.refStart, text: prefix };
+  });
+}
+function renameNameInFormula(formula, oldName, newName, options = {}) {
+  return rewriteTokens(formula, (token) => {
+    if (token.type !== "IDENTIFIER" || !sameName(token.value, oldName)) return null;
+    if (token.sheet !== void 0 ? options.appliesTo && !options.appliesTo(token.sheet) : options.qualifiedOnly) return null;
+    const from = token.refStart ?? token.position;
+    return { from, to: token.end ?? from + oldName.length, text: newName };
+  });
+}
+function formulaIdentifiers(formula) {
+  const tokens = tokensOf(formula);
+  if (!tokens) return [];
+  const out = [];
+  tokens.forEach((token, i) => {
+    if (token.type !== "IDENTIFIER") return;
+    const call = tokens[i + 1]?.type === "LPAREN";
+    out.push(token.sheet === void 0 ? { name: token.value, call } : { name: token.value, sheet: token.sheet, call });
+  });
+  return out;
+}
 
 // src/spreadsheet/formula/caret.ts
 var EMPTY = { prefix: null, call: null };
@@ -544,9 +705,20 @@ function getFormulaHints(input, caret = input.length, options = {}) {
   let suggestions = [];
   if (context.prefix) {
     const query = context.prefix.text.toUpperCase();
-    suggestions = searchFormulaFunctions(query, { limit: void 0 }).filter((def) => def.name.startsWith(query)).slice(0, options.limit ?? 8).map(toSuggestion);
+    const names = (options.names ?? []).filter((n) => n.name.toUpperCase().startsWith(query)).map((n) => ({
+      name: n.name,
+      signature: n.isLambda ? `${n.name}(\u2026)` : n.name,
+      description: n.description ?? "",
+      category: "lookup",
+      kind: "name",
+      ...n.isLambda ? { isLambda: true } : {}
+    }));
+    suggestions = [
+      ...names,
+      ...searchFormulaFunctions(query, { limit: void 0 }).filter((def) => def.name.startsWith(query) && !names.some((n) => n.name.toUpperCase() === def.name)).map(toSuggestion)
+    ].slice(0, options.limit ?? 8);
     const followedByParen = input.slice(context.prefix.end).trimStart().startsWith("(");
-    if (followedByParen || suggestions.length === 1 && suggestions[0].name === query) suggestions = [];
+    if (followedByParen || suggestions.length === 1 && suggestions[0].name.toUpperCase() === query) suggestions = [];
   }
   let activeCall = null;
   if (context.call) {
@@ -565,12 +737,20 @@ function getFormulaHints(input, caret = input.length, options = {}) {
   }
   return { context, suggestions, activeCall };
 }
-function applyFormulaSuggestion(input, caret, name) {
+function applyFormulaSuggestion(input, caret, suggestion, options = {}) {
   const context = getFormulaCaretContext(input, caret);
   const start = context.prefix?.start ?? caret;
   const end = context.prefix?.end ?? caret;
+  const definedName = typeof suggestion !== "string" && suggestion.kind === "name";
+  const name = typeof suggestion === "string" ? suggestion : suggestion.name;
+  const call = options.call ?? (definedName ? !!suggestion.isLambda : true);
+  if (!call) {
+    const value2 = input.slice(0, start) + name + input.slice(end);
+    return { value: value2, caret: start + name.length };
+  }
   const hasParen = input[end] === "(";
-  const insert = hasParen ? name.toUpperCase() : `${name.toUpperCase()}(`;
+  const spelled = definedName ? name : name.toUpperCase();
+  const insert = hasParen ? spelled : `${spelled}(`;
   const value = input.slice(0, start) + insert + input.slice(end);
   return { value, caret: start + insert.length + (hasParen ? 1 : 0) };
 }
@@ -707,6 +887,61 @@ var DataSourceBinder = class {
   }
 };
 
+// src/spreadsheet/workbook.ts
+var MAX_SHEET_NAME_LENGTH = 31;
+var MAX_DEFINED_NAME_LENGTH = 255;
+var sameName2 = (a, b) => a.toUpperCase() === b.toUpperCase();
+function validateSheetName(name, existingNames = []) {
+  const length = Array.from(name).length;
+  if (length === 0 || name.trim() === "") return "A sheet name can't be blank.";
+  if (length > MAX_SHEET_NAME_LENGTH) return `A sheet name can't be longer than ${MAX_SHEET_NAME_LENGTH} characters.`;
+  if (/[:\\/?*[\]]/.test(name)) return "A sheet name can't contain any of these characters: : \\ / ? * [ ]";
+  if (name.startsWith("'") || name.endsWith("'")) return "A sheet name can't begin or end with an apostrophe.";
+  if (sameName2(name, "History")) return '"History" is a reserved name.';
+  if (existingNames.some((existing) => sameName2(existing, name))) return "That name is already taken. Try a different one.";
+  return null;
+}
+function nextSheetName(existingNames, base = "Sheet") {
+  for (let n = 1; ; n++) {
+    const candidate = `${base} ${n}`;
+    if (!existingNames.some((existing) => sameName2(existing, candidate))) return candidate;
+  }
+}
+function copySheetName(name, existingNames) {
+  for (let k = 2; ; k++) {
+    const suffix = ` (${k})`;
+    const keep = Math.max(0, MAX_SHEET_NAME_LENGTH - suffix.length);
+    const candidate = `${Array.from(name).slice(0, keep).join("").trimEnd()}${suffix}`;
+    if (!existingNames.some((existing) => sameName2(existing, candidate))) return candidate;
+  }
+}
+function isR1C1Like(name) {
+  let i = 0;
+  if (/[Rr]/.test(name[i] ?? "")) {
+    i++;
+    while (i < name.length && /\d/.test(name[i])) i++;
+  }
+  if (/[Cc]/.test(name[i] ?? "")) {
+    i++;
+    while (i < name.length && /\d/.test(name[i])) i++;
+  }
+  return name.length > 0 && i === name.length;
+}
+function validateDefinedName(name) {
+  if (name === "") return "A name can't be blank.";
+  if (Array.from(name).length > MAX_DEFINED_NAME_LENGTH) return `A name can't be longer than ${MAX_DEFINED_NAME_LENGTH} characters.`;
+  if (!/^[\p{L}_\\][\p{L}\p{N}_.\\?]*$/u.test(name)) {
+    return /^[\p{L}_\\]/u.test(name) ? "A name can only contain letters, numbers, periods, underscores, backslashes and question marks." : "A name must start with a letter, an underscore or a backslash.";
+  }
+  if (/^\$?[A-Za-z]+\$?\d+$/.test(name)) return "A name can't look like a cell reference (such as A1).";
+  if (isR1C1Like(name)) return "A name can't look like an R1C1 reference (such as R1C1, R or C).";
+  if (sameName2(name, "TRUE") || sameName2(name, "FALSE")) return "A name can't be TRUE or FALSE.";
+  return null;
+}
+function isLambdaDefinition(definition) {
+  return /^=?\s*LAMBDA\s*\(/i.test(definition.refersTo);
+}
+
 // src/spreadsheet/table.ts
 function normalizeRange(range) {
   return {
@@ -1118,6 +1353,988 @@ function rebaseClipboardRows(rows, origin, target) {
   );
 }
 
+// src/spreadsheet/rule-ranges.ts
+function adjustRangeForStructuralChange(range, change) {
+  const r = normalizeRange(range);
+  const startKey = change.axis === "row" ? "startRow" : "startCol";
+  const endKey = change.axis === "row" ? "endRow" : "endCol";
+  if (change.type === "insert") {
+    if (r[startKey] >= change.index) r[startKey]++;
+    if (r[endKey] >= change.index) r[endKey]++;
+    return r;
+  }
+  if (r[startKey] === change.index && r[endKey] === change.index) return null;
+  if (r[startKey] > change.index) r[startKey]--;
+  if (r[endKey] >= change.index) r[endKey]--;
+  return r;
+}
+function adjustRangesForStructuralChange(ranges, change) {
+  const out = [];
+  for (const range of ranges) {
+    const next = adjustRangeForStructuralChange(range, change);
+    if (next) out.push(next);
+  }
+  return out;
+}
+function subtractRange(range, cut) {
+  const r = normalizeRange(range);
+  const c = normalizeRange(cut);
+  if (!rangesIntersect(r, c)) return [r];
+  const out = [];
+  const top = Math.max(r.startRow, c.startRow);
+  const bottom = Math.min(r.endRow, c.endRow);
+  if (r.startRow < c.startRow) out.push({ startRow: r.startRow, startCol: r.startCol, endRow: c.startRow - 1, endCol: r.endCol });
+  if (r.endRow > c.endRow) out.push({ startRow: c.endRow + 1, startCol: r.startCol, endRow: r.endRow, endCol: r.endCol });
+  if (r.startCol < c.startCol) out.push({ startRow: top, startCol: r.startCol, endRow: bottom, endCol: c.startCol - 1 });
+  if (r.endCol > c.endCol) out.push({ startRow: top, startCol: c.endCol + 1, endRow: bottom, endCol: r.endCol });
+  return out;
+}
+function subtractRangeFromRanges(ranges, cut) {
+  return ranges.flatMap((range) => subtractRange(range, cut));
+}
+function rangesContain(ranges, row, col) {
+  for (const r of ranges) {
+    const minR = Math.min(r.startRow, r.endRow);
+    const maxR = Math.max(r.startRow, r.endRow);
+    const minC = Math.min(r.startCol, r.endCol);
+    const maxC = Math.max(r.startCol, r.endCol);
+    if (row >= minR && row <= maxR && col >= minC && col <= maxC) return true;
+  }
+  return false;
+}
+function ruleAnchor(ranges) {
+  const first2 = ranges[0];
+  if (!first2) return { row: 0, col: 0 };
+  return { row: Math.min(first2.startRow, first2.endRow), col: Math.min(first2.startCol, first2.endCol) };
+}
+var withEquals = (formula) => formula.trimStart().startsWith("=") ? formula.trimStart() : `=${formula}`;
+function ruleFormulaAt(formula, anchor, row, col) {
+  return offsetFormulaReferences(withEquals(formula), row - anchor.row, col - anchor.col);
+}
+function shiftRuleFormula(formula, change) {
+  const hadEquals = formula.trimStart().startsWith("=");
+  const shifted = shiftFormulaReferences(withEquals(formula), change);
+  return hadEquals ? shifted : shifted.slice(1);
+}
+function forEachRangeCell(ranges, rowCount, colCount, fn) {
+  const seen = ranges.length > 1 ? /* @__PURE__ */ new Set() : null;
+  for (const range of ranges) {
+    const r = normalizeRange(range);
+    const endRow = Math.min(r.endRow, rowCount - 1);
+    const endCol = Math.min(r.endCol, colCount - 1);
+    for (let row = Math.max(0, r.startRow); row <= endRow; row++) {
+      for (let col = Math.max(0, r.startCol); col <= endCol; col++) {
+        if (seen) {
+          const key = row * (colCount + 1) + col;
+          if (seen.has(key)) continue;
+          seen.add(key);
+        }
+        fn(row, col);
+      }
+    }
+  }
+}
+function formatRuleRanges(ranges) {
+  return ranges.map((range) => {
+    const r = normalizeRange(range);
+    const start = `${indexToColName(r.startCol)}${r.startRow + 1}`;
+    const end = `${indexToColName(r.endCol)}${r.endRow + 1}`;
+    return start === end ? start : `${start}:${end}`;
+  }).join(", ");
+}
+var A1_RANGE = /^\$?([A-Za-z]{1,3})\$?(\d{1,7})(?::\$?([A-Za-z]{1,3})\$?(\d{1,7}))?$/;
+function parseRuleRanges(text) {
+  const parts = text.split(/[,;\s]+/).filter((p) => p !== "");
+  if (parts.length === 0) return null;
+  const out = [];
+  for (const part of parts) {
+    const m = A1_RANGE.exec(part);
+    if (!m) return null;
+    const startRow = Number(m[2]) - 1;
+    const startCol = colNameToIndex(m[1]);
+    const endRow = m[4] ? Number(m[4]) - 1 : startRow;
+    const endCol = m[3] ? colNameToIndex(m[3]) : startCol;
+    if (startRow < 0 || endRow < 0 || startCol < 0 || endCol < 0) return null;
+    out.push(normalizeRange({ startRow, startCol, endRow, endCol }));
+  }
+  return out;
+}
+
+// src/spreadsheet/conditional-format/icons.ts
+var RED = "#d9534f";
+var YELLOW = "#e0a800";
+var GREEN = "#2e9d4f";
+var GRAY = "#7a7f87";
+var BLACK = "#3b3f45";
+var BLUE = "#3b73b9";
+var g = (glyph, color, label) => ({ glyph, color, label });
+var ICON_SETS = {
+  "3Arrows": [g("\u2193", RED, "Down arrow"), g("\u2192", YELLOW, "Side arrow"), g("\u2191", GREEN, "Up arrow")],
+  "3ArrowsGray": [g("\u2193", GRAY, "Down arrow"), g("\u2192", GRAY, "Side arrow"), g("\u2191", GRAY, "Up arrow")],
+  "3TrafficLights1": [g("\u25CF", RED, "Red light"), g("\u25CF", YELLOW, "Yellow light"), g("\u25CF", GREEN, "Green light")],
+  "3Flags": [g("\u2691", RED, "Red flag"), g("\u2691", YELLOW, "Yellow flag"), g("\u2691", GREEN, "Green flag")],
+  "3Symbols": [g("\u2716", RED, "Cross"), g("!", YELLOW, "Exclamation"), g("\u2714", GREEN, "Check")],
+  "3Stars": [g("\u2606", YELLOW, "Empty star"), g("\u272C", YELLOW, "Half star"), g("\u2605", YELLOW, "Full star")],
+  "4Arrows": [g("\u2193", RED, "Down arrow"), g("\u2198", YELLOW, "Down-right arrow"), g("\u2197", YELLOW, "Up-right arrow"), g("\u2191", GREEN, "Up arrow")],
+  "4Rating": [g("\u2582", BLUE, "Rating 1 of 4"), g("\u2584", BLUE, "Rating 2 of 4"), g("\u2586", BLUE, "Rating 3 of 4"), g("\u2588", BLUE, "Rating 4 of 4")],
+  "4TrafficLights": [g("\u25CF", BLACK, "Black light"), g("\u25CF", RED, "Red light"), g("\u25CF", YELLOW, "Yellow light"), g("\u25CF", GREEN, "Green light")],
+  "5Arrows": [
+    g("\u2193", RED, "Down arrow"),
+    g("\u2198", YELLOW, "Down-right arrow"),
+    g("\u2192", YELLOW, "Side arrow"),
+    g("\u2197", GREEN, "Up-right arrow"),
+    g("\u2191", GREEN, "Up arrow")
+  ],
+  "5Rating": [
+    g("\u2581", BLUE, "Rating 1 of 5"),
+    g("\u2582", BLUE, "Rating 2 of 5"),
+    g("\u2584", BLUE, "Rating 3 of 5"),
+    g("\u2586", BLUE, "Rating 4 of 5"),
+    g("\u2588", BLUE, "Rating 5 of 5")
+  ],
+  "5Quarters": [g("\u25CB", BLACK, "Empty"), g("\u25D4", BLACK, "Quarter"), g("\u25D1", BLACK, "Half"), g("\u25D5", BLACK, "Three quarters"), g("\u25CF", BLACK, "Full")]
+};
+var CONDITIONAL_FORMAT_ICON_SETS = Object.keys(ICON_SETS);
+function conditionalFormatIconCount(set) {
+  const n = Number(set.charAt(0));
+  return Number.isFinite(n) ? Math.min(5, Math.max(3, n)) : 3;
+}
+function getConditionalFormatIcon(set, index) {
+  const icons = ICON_SETS[set] ?? ICON_SETS["3TrafficLights1"];
+  return icons[Math.max(0, Math.min(icons.length - 1, index))];
+}
+
+// src/spreadsheet/conditional-format/evaluate.ts
+var DEFAULT_BAR_COLOR = "#638ec6";
+var isBlank2 = (v) => v === "" || v === null || v === void 0;
+var ISO_DATE = /^(\d{4})-(\d{1,2})-(\d{1,2})(?: (\d{1,2}):(\d{2})(?::(\d{2}))?)?$/;
+function conditionalFormatNumber(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value !== "string" || value.length < 8 || value.length > 19) return null;
+  const m = ISO_DATE.exec(value);
+  if (!m) return null;
+  const serial = serialFromYmd(Number(m[1]), Number(m[2]), Number(m[3]));
+  if (serial === null) return null;
+  const time = m[4] ? (Number(m[4]) * 3600 + Number(m[5]) * 60 + Number(m[6] ?? 0)) / 86400 : 0;
+  return serial + time;
+}
+function valueText(value) {
+  if (isBlank2(value)) return "";
+  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+  if (typeof value === "number") return numberToText(value);
+  return String(value);
+}
+function firstValue(value) {
+  return Array.isArray(value) ? value.length ? value[0] : "" : value;
+}
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  const rank = Math.min(Math.max(p, 0), 100) / 100 * (sorted.length - 1);
+  const lo = Math.floor(rank);
+  const hi = Math.ceil(rank);
+  const a = sorted[lo] ?? 0;
+  const b = sorted[hi] ?? a;
+  return a + (b - a) * (rank - lo);
+}
+function parseHexColor(color) {
+  if (!color) return null;
+  let hex = color.trim().replace(/^#/, "");
+  if (hex.length === 3) hex = hex.split("").map((c) => c + c).join("");
+  if (!/^[0-9a-fA-F]{6}$/.test(hex)) return null;
+  return [parseInt(hex.slice(0, 2), 16), parseInt(hex.slice(2, 4), 16), parseInt(hex.slice(4, 6), 16)];
+}
+var toHex = (rgb) => `#${rgb.map((c) => c.toString(16).padStart(2, "0")).join("")}`;
+function blendConditionalFormatColors(a, b, t) {
+  const ca = parseHexColor(a) ?? [255, 255, 255];
+  const cb = parseHexColor(b) ?? [255, 255, 255];
+  const k = Math.min(Math.max(Number.isFinite(t) ? t : 0, 0), 1);
+  return toHex([0, 1, 2].map((i) => Math.round(ca[i] + (cb[i] - ca[i]) * k)));
+}
+function defaultIconThresholds(set) {
+  const k = conditionalFormatIconCount(set);
+  return Array.from({ length: k }, (_, i) => ({ type: "percent", value: Math.round(i * 100 / k) }));
+}
+var usesStats = (rule) => rule.type === "colorScale" || rule.type === "dataBar" || rule.type === "iconSet" || rule.type === "top10" || rule.type === "aboveAverage" || rule.type === "duplicate" || rule.type === "unique";
+var isFormulaText = (text) => !!text && text.trimStart().startsWith("=");
+function usesFormulas(rule) {
+  switch (rule.type) {
+    case "expression":
+      return true;
+    case "cellIs":
+      return isFormulaText(rule.value) || isFormulaText(rule.value2);
+    case "colorScale":
+      return rule.stops.some((s) => s.value.type === "formula");
+    case "dataBar":
+      return rule.min?.type === "formula" || rule.max?.type === "formula";
+    case "iconSet":
+      return !!rule.thresholds?.some((t) => t.type === "formula");
+    default:
+      return false;
+  }
+}
+function layerStyle(out, style) {
+  if (out.fill === void 0 && style.fill) out.fill = style.fill;
+  if (out.color === void 0 && style.color) out.color = style.color;
+  if (style.bold) out.bold = true;
+  if (style.italic) out.italic = true;
+  if (style.underline) out.underline = true;
+  if (style.strikethrough) out.strikethrough = true;
+}
+var COL_SPAN = 1048576;
+var cellKey = (row, col) => row * COL_SPAN + col;
+var Overlay = class {
+  constructor(cells) {
+    this.cells = cells;
+  }
+  cells;
+  get(row, col) {
+    return this.cells.size === 0 ? void 0 : this.cells.get(cellKey(row, col));
+  }
+  get size() {
+    return this.cells.size;
+  }
+  *entries() {
+    for (const [key, format] of this.cells) {
+      const row = Math.floor(key / COL_SPAN);
+      const col = key - row * COL_SPAN;
+      yield [{ row, col }, format];
+    }
+  }
+};
+var EMPTY_CONDITIONAL_FORMAT_OVERLAY = new Overlay(/* @__PURE__ */ new Map());
+var ConditionalFormatEngine = class {
+  constructor(sheet) {
+    this.sheet = sheet;
+  }
+  sheet;
+  cells = /* @__PURE__ */ new Map();
+  stats = /* @__PURE__ */ new Map();
+  rulesKey = null;
+  current = EMPTY_CONDITIONAL_FORMAT_OVERLAY;
+  /** Replaces the sheet accessor (e.g. after rows or columns were added). */
+  setSheet(sheet) {
+    this.sheet = sheet;
+  }
+  /** The last evaluated overlay. */
+  get overlay() {
+    return this.current;
+  }
+  /** Evaluates every rule over every cell it applies to. */
+  evaluate(rules) {
+    this.rulesKey = JSON.stringify(rules);
+    this.stats.clear();
+    this.cells = /* @__PURE__ */ new Map();
+    const { rowCount, colCount } = this.sheet;
+    const done = /* @__PURE__ */ new Set();
+    for (const rule of rules) {
+      forEachRangeCell(rule.ranges, rowCount, colCount, (row, col) => {
+        const key = cellKey(row, col);
+        if (done.has(key)) return;
+        done.add(key);
+        const look = this.computeLook(rules, row, col);
+        if (look) this.cells.set(key, look);
+      });
+    }
+    this.current = new Overlay(this.cells);
+    return this.current;
+  }
+  /**
+   * Re-evaluates after the values of `changed` cells changed (the edited
+   * cells and the formulas that depend on them). Rules that look at the whole
+   * range (scales, bars, icons, top/bottom, average, duplicates) are
+   * re-evaluated over their range when a changed cell is inside it; formula
+   * rules always are, since their formulas may read any cell; other rules
+   * only at the changed cells. Falls back to `evaluate` when the rules
+   * changed.
+   */
+  update(rules, changed) {
+    const key = JSON.stringify(rules);
+    if (key !== this.rulesKey) return this.evaluate(rules);
+    if (rules.length === 0) return this.current;
+    const changedCells = Array.from(changed);
+    const { rowCount, colCount } = this.sheet;
+    const affected = /* @__PURE__ */ new Map();
+    const addCell = (row, col) => affected.set(cellKey(row, col), { row, col });
+    for (const rule of rules) {
+      const wholeRange = usesFormulas(rule);
+      const touched = changedCells.some((c) => rangesContain(rule.ranges, c.row, c.col));
+      if (usesStats(rule) && touched) this.stats.delete(rule.id);
+      if (wholeRange || usesStats(rule) && touched) {
+        forEachRangeCell(rule.ranges, rowCount, colCount, addCell);
+      } else if (touched) {
+        for (const c of changedCells) {
+          if (c.row < rowCount && c.col < colCount && rangesContain(rule.ranges, c.row, c.col)) addCell(c.row, c.col);
+        }
+      }
+    }
+    if (affected.size === 0) return this.current;
+    const next = new Map(this.cells);
+    for (const [k, { row, col }] of affected) {
+      const look = this.computeLook(rules, row, col);
+      if (look) next.set(k, look);
+      else next.delete(k);
+    }
+    this.cells = next;
+    this.current = new Overlay(next);
+    return this.current;
+  }
+  statsFor(rule) {
+    let st = this.stats.get(rule.id);
+    if (st) return st;
+    const sorted = [];
+    const counts = /* @__PURE__ */ new Map();
+    forEachRangeCell(rule.ranges, this.sheet.rowCount, this.sheet.colCount, (row, col) => {
+      const v = this.sheet.getValue(row, col);
+      const n2 = conditionalFormatNumber(v);
+      if (n2 !== null) sorted.push(n2);
+      if (!isBlank2(v)) {
+        const text = valueText(v).toLowerCase();
+        counts.set(text, (counts.get(text) ?? 0) + 1);
+      }
+    });
+    sorted.sort((a, b) => a - b);
+    const n = Math.max(sorted.length, 1);
+    let sum = 0;
+    for (const x of sorted) sum += x;
+    const avg = sum / n;
+    let sq = 0;
+    for (const x of sorted) sq += (x - avg) * (x - avg);
+    st = { sorted, avg, std: Math.sqrt(sq / n), counts };
+    this.stats.set(rule.id, st);
+    return st;
+  }
+  evalFormula(formula, rule, row, col) {
+    if (!this.sheet.evaluateFormula) return "#NAME?";
+    try {
+      return firstValue(this.sheet.evaluateFormula(ruleFormulaAt(formula, ruleAnchor(rule.ranges), row, col), row, col));
+    } catch {
+      return "#ERROR!";
+    }
+  }
+  threshold(rule, st, k, row, col) {
+    const min = st.sorted[0] ?? 0;
+    const max = st.sorted[st.sorted.length - 1] ?? 0;
+    switch (k.type) {
+      case "min":
+        return min;
+      case "max":
+        return max;
+      case "number":
+        return k.value;
+      case "percent":
+        return min + (max - min) * k.value / 100;
+      case "percentile":
+        return percentile(st.sorted, k.value);
+      case "formula": {
+        const n = conditionalFormatNumber(this.evalFormula(k.formula, rule, row, col));
+        return n ?? 0;
+      }
+    }
+  }
+  /** The operand of a `cellIs` rule: a formula result, or typed input. */
+  operand(text, rule, row, col) {
+    if (text === void 0) return "";
+    if (isFormulaText(text)) return this.evalFormula(text, rule, row, col);
+    return parseCellInput(text).value;
+  }
+  /** Combines every rule that applies to (row, col). */
+  computeLook(rules, row, col) {
+    const out = {};
+    let any = false;
+    let v;
+    let loaded = false;
+    const value = () => {
+      if (!loaded) {
+        v = this.sheet.getValue(row, col);
+        loaded = true;
+      }
+      return v;
+    };
+    for (const rule of rules) {
+      if (!rangesContain(rule.ranges, row, col)) continue;
+      const matched = this.matchRule(rule, value(), row, col, out);
+      if (matched === "look") any = true;
+      if (matched && matched !== "look") {
+        any = true;
+        layerStyle(out, matched);
+        if (rule.stopIfTrue) break;
+      }
+    }
+    return any ? out : void 0;
+  }
+  /**
+   * Checks one rule: returns its style when it matches, 'look' when it set a
+   * scale fill, bar or icon on `out`, or null.
+   */
+  matchRule(rule, v, row, col, out) {
+    const error = isFormulaError(v);
+    switch (rule.type) {
+      case "cellIs": {
+        if (error) return null;
+        const a = this.operand(rule.value, rule, row, col);
+        let ok;
+        if (rule.operator === "between" || rule.operator === "notBetween") {
+          const b = this.operand(rule.value2, rule, row, col);
+          const [lo, hi] = compareValues(a, b) > 0 ? [b, a] : [a, b];
+          const inside = compareValues(v, lo) >= 0 && compareValues(v, hi) <= 0;
+          ok = rule.operator === "between" ? inside : !inside;
+        } else {
+          if (isFormulaError(a)) return null;
+          const cmp = compareValues(v, a);
+          ok = rule.operator === "equal" ? cmp === 0 : rule.operator === "notEqual" ? cmp !== 0 : rule.operator === "greaterThan" ? cmp > 0 : rule.operator === "lessThan" ? cmp < 0 : rule.operator === "greaterThanOrEqual" ? cmp >= 0 : cmp <= 0;
+        }
+        return ok ? rule.style : null;
+      }
+      case "expression": {
+        const result = toBoolean(this.evalFormula(rule.formula, rule, row, col));
+        return result === true ? rule.style : null;
+      }
+      case "containsText":
+      case "notContainsText":
+      case "beginsWith":
+      case "endsWith": {
+        const text = valueText(v).toLowerCase();
+        const t = rule.text.toLowerCase();
+        const ok = rule.type === "containsText" ? text.includes(t) : rule.type === "notContainsText" ? !text.includes(t) : rule.type === "beginsWith" ? text.startsWith(t) : text.endsWith(t);
+        return ok ? rule.style : null;
+      }
+      case "blanks":
+        return isBlank2(v) || valueText(v).trim() === "" ? rule.style : null;
+      case "noBlanks":
+        return !isBlank2(v) && valueText(v).trim() !== "" ? rule.style : null;
+      case "errors":
+        return error ? rule.style : null;
+      case "noErrors":
+        return !error ? rule.style : null;
+      case "duplicate":
+      case "unique": {
+        if (isBlank2(v)) return null;
+        const count = this.statsFor(rule).counts.get(valueText(v).toLowerCase()) ?? 0;
+        return (rule.type === "duplicate" ? count > 1 : count === 1) ? rule.style : null;
+      }
+      case "top10": {
+        const n = conditionalFormatNumber(v);
+        const st = this.statsFor(rule);
+        if (n === null || st.sorted.length === 0) return null;
+        const rank = Math.max(1, Math.floor(rule.rank || 1));
+        let k = rule.percent ? Math.max(1, Math.floor(st.sorted.length * rank / 100)) : rank;
+        k = Math.min(Math.max(k, 1), st.sorted.length);
+        const ok = rule.bottom ? n <= st.sorted[k - 1] : n >= st.sorted[st.sorted.length - k];
+        return ok ? rule.style : null;
+      }
+      case "aboveAverage": {
+        const n = conditionalFormatNumber(v);
+        if (n === null) return null;
+        const st = this.statsFor(rule);
+        const thr = st.avg + (rule.below ? -1 : 1) * st.std * (rule.stdDev ?? 0);
+        const ok = rule.below ? n < thr || !!rule.equal && n === thr : n > thr || !!rule.equal && n === thr;
+        return ok ? rule.style : null;
+      }
+      case "timePeriod": {
+        const n = conditionalFormatNumber(v);
+        if (n === null) return null;
+        return matchesTimePeriod(rule.period, Math.floor(n), this.sheet.today?.() ?? /* @__PURE__ */ new Date()) ? rule.style : null;
+      }
+      case "colorScale": {
+        const n = conditionalFormatNumber(v);
+        if (n === null || out.fill !== void 0) return null;
+        const st = this.statsFor(rule);
+        const pts = rule.stops.map((s) => ({ at: this.threshold(rule, st, s.value, row, col), color: s.color }));
+        let fill;
+        if (pts.length === 2) {
+          const [a, b] = pts;
+          fill = blendConditionalFormatColors(a.color, b.color, b.at > a.at ? (n - a.at) / (b.at - a.at) : 0);
+        } else if (pts.length >= 3) {
+          const [a, m, b] = pts;
+          fill = n <= m.at ? blendConditionalFormatColors(a.color, m.color, m.at > a.at ? (n - a.at) / (m.at - a.at) : 0) : blendConditionalFormatColors(m.color, b.color, b.at > m.at ? (n - m.at) / (b.at - m.at) : 1);
+        }
+        if (!fill) return null;
+        out.fill = fill;
+        return "look";
+      }
+      case "dataBar": {
+        const n = conditionalFormatNumber(v);
+        if (n === null || out.dataBar) return null;
+        const st = this.statsFor(rule);
+        let lo = this.threshold(rule, st, rule.min ?? { type: "min" }, row, col);
+        const hi = this.threshold(rule, st, rule.max ?? { type: "max" }, row, col);
+        if (lo > 0) lo = 0;
+        const frac = hi > lo ? Math.min(Math.max((n - lo) / (hi - lo), 0), 1) : 1;
+        out.dataBar = {
+          // A minimum length keeps small positive values visible.
+          fraction: frac * 0.9 + (frac > 0 ? 0.1 : 0),
+          color: rule.color ?? DEFAULT_BAR_COLOR,
+          gradient: rule.gradient ?? true
+        };
+        if (rule.showValue === false) out.hideValue = true;
+        return "look";
+      }
+      case "iconSet": {
+        const n = conditionalFormatNumber(v);
+        if (n === null || out.icon) return null;
+        const set = rule.set ?? "3TrafficLights1";
+        const k = conditionalFormatIconCount(set);
+        const thresholds = rule.thresholds ?? [];
+        const lower = thresholds.length === k ? thresholds.slice(1) : thresholds.length + 1 === k ? thresholds : defaultIconThresholds(set).slice(1);
+        const st = this.statsFor(rule);
+        let idx = 0;
+        for (const t of lower) if (n >= this.threshold(rule, st, t, row, col)) idx++;
+        if (rule.reverse) idx = k - 1 - Math.min(idx, k - 1);
+        idx = Math.min(idx, k - 1);
+        out.icon = { set, index: idx, id: `${set}:${idx}` };
+        if (rule.showValue === false) out.hideValue = true;
+        return "look";
+      }
+    }
+    return null;
+  }
+};
+function matchesTimePeriod(period, d, today) {
+  const t = serialFromYmd(today.getFullYear(), today.getMonth() + 1, today.getDate());
+  if (t === null) return false;
+  const weekStart = t - today.getDay();
+  const date = serialToDate(d);
+  const monthOffset = (k) => {
+    if (!date) return false;
+    const m = today.getMonth() + k;
+    const y = today.getFullYear() + Math.floor(m / 12);
+    const mm = (m % 12 + 12) % 12;
+    return date.getFullYear() === y && date.getMonth() === mm;
+  };
+  switch (period) {
+    case "yesterday":
+      return d === t - 1;
+    case "today":
+      return d === t;
+    case "tomorrow":
+      return d === t + 1;
+    case "last7Days":
+      return d > t - 7 && d <= t;
+    case "lastWeek":
+      return d >= weekStart - 7 && d < weekStart;
+    case "thisWeek":
+      return d >= weekStart && d < weekStart + 7;
+    case "nextWeek":
+      return d >= weekStart + 7 && d < weekStart + 14;
+    case "lastMonth":
+      return monthOffset(-1);
+    case "thisMonth":
+      return monthOffset(0);
+    case "nextMonth":
+      return monthOffset(1);
+    default:
+      return false;
+  }
+}
+function evaluateConditionalFormats(sheet, rules) {
+  return new ConditionalFormatEngine(sheet).evaluate(rules);
+}
+
+// src/spreadsheet/conditional-format/describe.ts
+var OPERATOR_TEXT = {
+  between: "between",
+  notBetween: "not between",
+  equal: "=",
+  notEqual: "\u2260",
+  greaterThan: ">",
+  lessThan: "<",
+  greaterThanOrEqual: "\u2265",
+  lessThanOrEqual: "\u2264"
+};
+var anchorText = (v, fallback) => {
+  if (!v) return fallback;
+  switch (v.type) {
+    case "min":
+      return "min";
+    case "max":
+      return "max";
+    case "number":
+      return String(v.value);
+    case "percent":
+      return `${v.value}%`;
+    case "percentile":
+      return `P${v.value}`;
+    case "formula":
+      return v.formula;
+  }
+};
+function describeConditionalFormat(rule) {
+  switch (rule.type) {
+    case "cellIs":
+      return rule.operator === "between" || rule.operator === "notBetween" ? `Cell value ${OPERATOR_TEXT[rule.operator]} ${rule.value} and ${rule.value2 ?? ""}` : `Cell value ${OPERATOR_TEXT[rule.operator]} ${rule.value}`;
+    case "expression":
+      return `Formula: ${rule.formula.startsWith("=") ? rule.formula : `=${rule.formula}`}`;
+    case "containsText":
+      return `Text contains "${rule.text}"`;
+    case "notContainsText":
+      return `Text does not contain "${rule.text}"`;
+    case "beginsWith":
+      return `Text begins with "${rule.text}"`;
+    case "endsWith":
+      return `Text ends with "${rule.text}"`;
+    case "blanks":
+      return "Blank cells";
+    case "noBlanks":
+      return "Non-blank cells";
+    case "errors":
+      return "Errors";
+    case "noErrors":
+      return "No errors";
+    case "duplicate":
+      return "Duplicate values";
+    case "unique":
+      return "Unique values";
+    case "top10":
+      return `${rule.bottom ? "Bottom" : "Top"} ${rule.rank}${rule.percent ? "%" : ""}`;
+    case "aboveAverage":
+      return `${rule.below ? "Below" : "Above"} average${rule.stdDev ? ` by ${rule.stdDev} std dev` : ""}`;
+    case "timePeriod":
+      return `Date occurring: ${rule.period}`;
+    case "colorScale":
+      return `Color scale (${rule.stops.map((s) => anchorText(s.value, "")).join(" \u2192 ")})`;
+    case "dataBar":
+      return `Data bar (${anchorText(rule.min, "min")} \u2192 ${anchorText(rule.max, "max")})`;
+    case "iconSet":
+      return `Icon set ${rule.set ?? "3TrafficLights1"}${rule.reverse ? " (reversed)" : ""}`;
+  }
+}
+var VALIDATION_OPERATOR_TEXT = OPERATOR_TEXT;
+function describeDataValidation(rule) {
+  const op = rule.operator ?? "between";
+  const bounds = op === "between" || op === "notBetween" ? `${VALIDATION_OPERATOR_TEXT[op]} ${rule.formula1 ?? ""} and ${rule.formula2 ?? ""}` : `${VALIDATION_OPERATOR_TEXT[op]} ${rule.formula1 ?? ""}`;
+  switch (rule.type) {
+    case "any":
+      return "Any value";
+    case "whole":
+      return `Whole number ${bounds}`;
+    case "decimal":
+      return `Decimal ${bounds}`;
+    case "date":
+      return `Date ${bounds}`;
+    case "time":
+      return `Time ${bounds}`;
+    case "textLength":
+      return `Text length ${bounds}`;
+    case "list":
+      return `List: ${rule.formula1 ?? ""}`;
+    case "custom":
+      return `Custom: ${rule.formula1 ?? ""}`;
+  }
+}
+
+// src/spreadsheet/conditional-format/presets.ts
+var CONDITIONAL_FORMAT_STYLE_PRESETS = [
+  { id: "lightRed", label: "Light red fill, dark red text", style: { fill: "#ffc7ce", color: "#9c0006" } },
+  { id: "yellow", label: "Yellow fill, dark yellow text", style: { fill: "#ffeb9c", color: "#9c5700" } },
+  { id: "green", label: "Green fill, dark green text", style: { fill: "#c6efce", color: "#006100" } },
+  { id: "redText", label: "Red text", style: { color: "#9c0006" } },
+  { id: "bold", label: "Bold", style: { bold: true } }
+];
+var DEFAULT_CONDITIONAL_FORMAT_STYLE = CONDITIONAL_FORMAT_STYLE_PRESETS[0].style;
+var CONDITIONAL_FORMAT_PRESETS = [
+  { kind: "greaterThan", label: "Cell value greater than", fields: ["value"], usesStyle: true },
+  { kind: "lessThan", label: "Cell value less than", fields: ["value"], usesStyle: true },
+  { kind: "between", label: "Cell value between", fields: ["value", "value2"], usesStyle: true },
+  { kind: "equal", label: "Cell value equal to", fields: ["value"], usesStyle: true },
+  { kind: "textContains", label: "Text that contains", fields: ["text"], usesStyle: true },
+  { kind: "dateOccurring", label: "A date occurring", fields: ["period"], usesStyle: true },
+  { kind: "duplicate", label: "Duplicate values", fields: [], usesStyle: true },
+  { kind: "unique", label: "Unique values", fields: [], usesStyle: true },
+  { kind: "top10", label: "Top N items", fields: ["rank"], usesStyle: true },
+  { kind: "bottom10", label: "Bottom N items", fields: ["rank"], usesStyle: true },
+  { kind: "aboveAverage", label: "Above average", fields: [], usesStyle: true },
+  { kind: "belowAverage", label: "Below average", fields: [], usesStyle: true },
+  { kind: "blanks", label: "Blank cells", fields: [], usesStyle: true },
+  { kind: "errors", label: "Errors", fields: [], usesStyle: true },
+  { kind: "formula", label: "Use a formula", fields: ["formula"], usesStyle: true },
+  { kind: "colorScale2", label: "2-color scale", fields: [], usesStyle: false },
+  { kind: "colorScale3", label: "3-color scale", fields: [], usesStyle: false },
+  { kind: "dataBar", label: "Data bars", fields: ["color"], usesStyle: false },
+  { kind: "iconSet", label: "Icon set", fields: ["iconSet"], usesStyle: false }
+];
+var CONDITIONAL_FORMAT_TIME_PERIODS = [
+  { period: "yesterday", label: "Yesterday" },
+  { period: "today", label: "Today" },
+  { period: "tomorrow", label: "Tomorrow" },
+  { period: "last7Days", label: "In the last 7 days" },
+  { period: "lastWeek", label: "Last week" },
+  { period: "thisWeek", label: "This week" },
+  { period: "nextWeek", label: "Next week" },
+  { period: "lastMonth", label: "Last month" },
+  { period: "thisMonth", label: "This month" },
+  { period: "nextMonth", label: "Next month" }
+];
+function createConditionalFormatRule(input) {
+  const style = input.style ?? DEFAULT_CONDITIONAL_FORMAT_STYLE;
+  const base = { ranges: input.ranges, ...input.stopIfTrue ? { stopIfTrue: true } : {} };
+  switch (input.kind) {
+    case "greaterThan":
+    case "lessThan":
+    case "equal":
+      return { ...base, type: "cellIs", operator: input.kind, value: input.value ?? "0", style };
+    case "between":
+      return { ...base, type: "cellIs", operator: "between", value: input.value ?? "0", value2: input.value2 ?? "0", style };
+    case "textContains":
+      return { ...base, type: "containsText", text: input.text ?? "", style };
+    case "dateOccurring":
+      return { ...base, type: "timePeriod", period: input.period ?? "today", style };
+    case "duplicate":
+    case "unique":
+    case "blanks":
+    case "errors":
+      return { ...base, type: input.kind, style };
+    case "top10":
+    case "bottom10":
+      return { ...base, type: "top10", bottom: input.kind === "bottom10", rank: input.rank ?? 10, style };
+    case "aboveAverage":
+    case "belowAverage":
+      return { ...base, type: "aboveAverage", below: input.kind === "belowAverage", style };
+    case "formula":
+      return { ...base, type: "expression", formula: input.formula ?? "=TRUE", style };
+    case "colorScale2":
+      return {
+        ...base,
+        type: "colorScale",
+        stops: [
+          { value: { type: "min" }, color: "#ffffff" },
+          { value: { type: "max" }, color: "#63be7b" }
+        ]
+      };
+    case "colorScale3":
+      return {
+        ...base,
+        type: "colorScale",
+        stops: [
+          { value: { type: "min" }, color: "#f8696b" },
+          { value: { type: "percentile", value: 50 }, color: "#ffeb84" },
+          { value: { type: "max" }, color: "#63be7b" }
+        ]
+      };
+    case "dataBar":
+      return { ...base, type: "dataBar", color: input.color ?? "#638ec6" };
+    case "iconSet":
+      return { ...base, type: "iconSet", set: input.iconSet ?? "3TrafficLights1" };
+  }
+}
+var DATA_VALIDATION_TYPE_OPTIONS = [
+  { type: "any", label: "Any value" },
+  { type: "whole", label: "Whole number" },
+  { type: "decimal", label: "Decimal" },
+  { type: "list", label: "List" },
+  { type: "date", label: "Date" },
+  { type: "time", label: "Time" },
+  { type: "textLength", label: "Text length" },
+  { type: "custom", label: "Custom formula" }
+];
+var DATA_VALIDATION_OPERATOR_OPTIONS = [
+  { operator: "between", label: "between" },
+  { operator: "notBetween", label: "not between" },
+  { operator: "equal", label: "equal to" },
+  { operator: "notEqual", label: "not equal to" },
+  { operator: "greaterThan", label: "greater than" },
+  { operator: "lessThan", label: "less than" },
+  { operator: "greaterThanOrEqual", label: "greater than or equal to" },
+  { operator: "lessThanOrEqual", label: "less than or equal to" }
+];
+var DATA_VALIDATION_ERROR_STYLE_OPTIONS = [
+  { style: "stop", label: "Stop" },
+  { style: "warning", label: "Warning" },
+  { style: "information", label: "Information" }
+];
+
+// src/spreadsheet/conditional-format/render.ts
+function conditionalFormatContrastColor(fill) {
+  let hex = fill.trim().replace(/^#/, "");
+  if (hex.length === 3) hex = hex.split("").map((c) => c + c).join("");
+  if (!/^[0-9a-fA-F]{6}$/.test(hex)) return void 0;
+  const [r, g2, b] = [0, 2, 4].map((i) => parseInt(hex.slice(i, i + 2), 16) / 255);
+  return 0.299 * r + 0.587 * g2 + 0.114 * b > 0.55 ? "#1f2328" : "#ffffff";
+}
+function getConditionalFormatCss(format) {
+  if (!format) return {};
+  const css = {};
+  if (format.fill) css.background = format.fill;
+  if (format.color) css.color = format.color;
+  else if (format.fill) {
+    const contrast = conditionalFormatContrastColor(format.fill);
+    if (contrast) css.color = contrast;
+  }
+  if (format.bold) css.fontWeight = "700";
+  if (format.italic) css.fontStyle = "italic";
+  const decorations = [format.underline ? "underline" : "", format.strikethrough ? "line-through" : ""].filter(Boolean);
+  if (decorations.length) css.textDecoration = decorations.join(" ");
+  return css;
+}
+function getDataBarCss(bar) {
+  const width = `${Math.round(Math.min(Math.max(bar.fraction, 0), 1) * 1e3) / 10}%`;
+  return {
+    position: "absolute",
+    left: "0",
+    top: "2px",
+    bottom: "2px",
+    width,
+    pointerEvents: "none",
+    borderRadius: "1px",
+    background: bar.gradient ? `linear-gradient(90deg, ${bar.color}, color-mix(in srgb, ${bar.color} 20%, transparent))` : bar.color,
+    opacity: bar.gradient ? "0.9" : "0.75"
+  };
+}
+var kebab = (name) => name.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
+function conditionalFormatStyleString(css) {
+  let out = "";
+  for (const [key, value] of Object.entries(css)) {
+    if (value !== void 0 && value !== "") out += `${kebab(key)}: ${value}; `;
+  }
+  return out.trim();
+}
+
+// src/spreadsheet/validation/validate.ts
+var DEFAULT_DATA_VALIDATION_MESSAGE = "This value doesn't match the data validation restrictions defined for this cell.";
+var DEFAULT_DATA_VALIDATION_TITLE = "Invalid value";
+var BARE_REFERENCE = /^\$?[A-Za-z]{1,3}\$?\d{1,7}(?::\$?[A-Za-z]{1,3}\$?\d{1,7})?$/;
+var isBlank3 = (v) => v === "" || v === null || v === void 0;
+function valueText2(value) {
+  if (isBlank3(value)) return "";
+  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+  if (typeof value === "number") return numberToText(value);
+  return String(value);
+}
+function findDataValidation(rules, row, col) {
+  if (!rules) return void 0;
+  for (const rule of rules) if (rangesContain(rule.ranges, row, col)) return rule;
+  return void 0;
+}
+function evaluate(sheet, rule, formula, row, col, entered) {
+  if (!sheet.evaluateFormula) return "#NAME?";
+  try {
+    return sheet.evaluateFormula(ruleFormulaAt(formula, ruleAnchor(rule.ranges), row, col), row, col, entered);
+  } catch {
+    return "#ERROR!";
+  }
+}
+var first = (v) => Array.isArray(v) ? v.length ? v[0] : "" : v;
+function getValidationListValues(sheet, rule) {
+  const f = (rule.formula1 ?? "").trim();
+  if (f === "") return [];
+  if (f.startsWith("=") || BARE_REFERENCE.test(f)) {
+    const anchor = ruleAnchor(rule.ranges);
+    const result = evaluate(sheet, rule, f, anchor.row, anchor.col);
+    const values = Array.isArray(result) ? result : [result];
+    const out = [];
+    for (const v of values) if (!isBlank3(v) && !isFormulaError(v)) out.push(valueText2(v));
+    return out;
+  }
+  const unquoted = f.length >= 2 && f.startsWith('"') && f.endsWith('"') ? f.slice(1, -1) : f;
+  return unquoted.split(",").map((x) => x.trim()).filter((x) => x !== "");
+}
+function compareOp(op, n, a, b) {
+  if (a === null) return false;
+  switch (op) {
+    case "between":
+      return b !== null && n >= Math.min(a, b) && n <= Math.max(a, b);
+    case "notBetween":
+      return b !== null && (n < Math.min(a, b) || n > Math.max(a, b));
+    case "equal":
+      return n === a;
+    case "notEqual":
+      return n !== a;
+    case "greaterThan":
+      return n > a;
+    case "lessThan":
+      return n < a;
+    case "greaterThanOrEqual":
+      return n >= a;
+    case "lessThanOrEqual":
+      return n <= a;
+  }
+}
+function bound(sheet, rule, text, row, col, entered) {
+  if (text === void 0 || text.trim() === "") return null;
+  const value = text.trim().startsWith("=") ? first(evaluate(sheet, rule, text, row, col, entered)) : parseCellInput(text.trim()).value;
+  return conditionalFormatNumber(value);
+}
+function satisfies(sheet, rule, row, col, value, text, entered) {
+  const op = rule.operator ?? "between";
+  switch (rule.type) {
+    case "any":
+      return true;
+    case "list": {
+      const typed = text.trim().toLowerCase();
+      return getValidationListValues(sheet, rule).some(
+        (item) => item.toLowerCase() === typed || compareValues(parseCellInput(item).value, value) === 0
+      );
+    }
+    case "custom":
+      return toBoolean(first(evaluate(sheet, rule, rule.formula1 ?? "", row, col, entered))) === true;
+    case "textLength":
+      return compareOp(op, Array.from(text).length, bound(sheet, rule, rule.formula1, row, col, entered), bound(sheet, rule, rule.formula2, row, col, entered));
+    case "whole":
+    case "decimal":
+    case "date":
+    case "time": {
+      if (isFormulaError(value)) return false;
+      let n = conditionalFormatNumber(value);
+      if (n === null) return false;
+      if (rule.type === "whole" && !Number.isInteger(n)) return false;
+      if (rule.type === "time" && typeof value === "string") n -= Math.floor(n);
+      return compareOp(op, n, bound(sheet, rule, rule.formula1, row, col, entered), bound(sheet, rule, rule.formula2, row, col, entered));
+    }
+  }
+}
+function invalid(rule) {
+  return {
+    valid: false,
+    rule,
+    errorStyle: rule.errorStyle ?? "stop",
+    title: rule.errorTitle || DEFAULT_DATA_VALIDATION_TITLE,
+    message: rule.errorMessage || DEFAULT_DATA_VALIDATION_MESSAGE
+  };
+}
+function validateCellInput(sheet, rules, row, col, input) {
+  const rule = findDataValidation(rules, row, col);
+  if (!rule) return { valid: true };
+  if (rule.type === "any" || rule.showErrorAlert === false) return { valid: true, rule };
+  if (input.trim() === "" && (rule.ignoreBlank ?? true)) return { valid: true, rule };
+  let value;
+  let text = input;
+  if (input.startsWith("=")) {
+    value = first(sheet.evaluateFormula ? safeEval(sheet, input, row, col) : "#NAME?");
+    text = valueText2(value);
+  } else {
+    value = parseCellInput(input).value;
+    if (input.startsWith("'")) text = input.slice(1);
+  }
+  const entered = { row, col, value };
+  return satisfies(sheet, rule, row, col, value, text, entered) ? { valid: true, rule } : invalid(rule);
+}
+function safeEval(sheet, formula, row, col) {
+  try {
+    return sheet.evaluateFormula(formula, row, col);
+  } catch {
+    return "#ERROR!";
+  }
+}
+function findInvalidCells(sheet, rules) {
+  const out = [];
+  if (!rules?.length) return out;
+  const seen = /* @__PURE__ */ new Set();
+  for (const rule of rules) {
+    if (rule.type === "any") continue;
+    forEachRangeCell(rule.ranges, sheet.rowCount, sheet.colCount, (row, col) => {
+      const key = `${row}:${col}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+      if (findDataValidation(rules, row, col) !== rule) return;
+      const value = sheet.getValue(row, col);
+      if (isBlank3(value)) return;
+      const raw = sheet.getInput?.(row, col);
+      const text = raw !== void 0 && raw !== "" && !raw.startsWith("=") ? raw.startsWith("'") ? raw.slice(1) : raw : valueText2(value);
+      if (!satisfies(sheet, rule, row, col, value, text)) out.push({ row, col });
+    });
+  }
+  return out;
+}
+
 // src/spreadsheet/view.ts
 var DEFAULT_ROW_HEIGHT = 32;
 var DEFAULT_COLUMN_WIDTH = 130;
@@ -1278,11 +2495,19 @@ function buildSpreadsheetView(doc, getValue) {
 
 // src/spreadsheet/controller.ts
 var nextIdSequence = 0;
+var createRuntime = (doc) => ({
+  doc,
+  spills: /* @__PURE__ */ new Map(),
+  spilledBy: /* @__PURE__ */ new Map(),
+  spillCells: /* @__PURE__ */ new Map(),
+  activeCell: null,
+  selectedRange: null
+});
+var sameName3 = (a, b) => a.toUpperCase() === b.toUpperCase();
 var DEFAULT_MAX_HISTORY_BYTES = 64 * 1024 * 1024;
 var MAX_SPILL_PASSES = 25;
 var spillCellId = (rowId, colId) => `${rowId}\0${colId}`;
 var SpreadsheetController = class {
-  document;
   activeCell = null;
   selectedRange = null;
   editingCell = null;
@@ -1292,6 +2517,17 @@ var SpreadsheetController = class {
   evaluator;
   primaryDataSourceId;
   onDocumentChange;
+  onWorkbookChange;
+  onActiveSheetChange;
+  // Workbook: sheets in tab order, the active one, and the one being worked
+  // on (the active sheet, or another sheet while one of its cells is read or
+  // evaluated). Everything that uses `this.document` works on `ctx`.
+  runtimes = [];
+  active;
+  ctx;
+  // The sheet bound to the primary data source (the first sheet).
+  boundSheetId = null;
+  names = [];
   onSelectionChange;
   onCellCommit;
   // History stack for undo/redo
@@ -1306,16 +2542,39 @@ var SpreadsheetController = class {
   evaluatingRowIndex = null;
   // Cell being evaluated, for implicit intersection (`=@A:A`).
   evaluatingCell = null;
-  // Dynamic arrays. Spilled values are derived state: they live here, not in
-  // the document, and every recalculation rebuilds them.
-  spills = /* @__PURE__ */ new Map();
-  // anchor key -> spill
-  spilledBy = /* @__PURE__ */ new Map();
-  // spilled cell key -> anchor key
-  spillCells = /* @__PURE__ */ new Map();
-  // spillCellId -> displayed cell
-  // Cells whose spill ownership changed during the current pass.
+  // Dynamic arrays. Spilled values are derived state: they live in the sheet
+  // runtimes, not in the documents, and every recalculation rebuilds them.
+  // Cells (sheet-qualified keys) whose spill ownership changed during the current pass.
   spillChanges = null;
+  /** The active sheet's document (the sheet the editor shows). */
+  get document() {
+    return this.ctx.doc;
+  }
+  set document(doc) {
+    this.ctx.doc = doc;
+  }
+  get spills() {
+    return this.ctx.spills;
+  }
+  get spilledBy() {
+    return this.ctx.spilledBy;
+  }
+  get spillCells() {
+    return this.ctx.spillCells;
+  }
+  // Conditional formatting is evaluated lazily (getConditionalFormatOverlay).
+  // Cell keys whose values changed since, or 'all' to evaluate from scratch.
+  cfEngine = null;
+  cfDirty = "all";
+  // Set while a single cell edit notifies, so the change stays incremental.
+  cfIncremental = false;
+  // Value being entered, seen by validation formulas instead of the cell's value.
+  valueOverride = null;
+  // "Circle invalid data": on/off and the cached cells.
+  circlesShown = false;
+  invalidCircles = null;
+  /** Invalid input waiting for the user's answer (see `resolveValidationPrompt`). */
+  validationPrompt = null;
   constructor(options = {}) {
     const defaultCols = [
       { id: "col_a", key: "A", title: "A", width: 120, type: "freeform" },
@@ -1329,7 +2588,7 @@ var SpreadsheetController = class {
       height: 32,
       type: "freeform"
     }));
-    this.document = {
+    const first2 = {
       id: options.document?.id || `sheet_${Date.now()}`,
       name: options.document?.name || "Sheet 1",
       columns: options.document?.columns || defaultCols,
@@ -1339,27 +2598,123 @@ var SpreadsheetController = class {
       updatedAt: options.document?.updatedAt || Date.now(),
       ...options.document?.table ? { table: options.document.table } : {}
     };
+    if (options.workbook && options.workbook.sheets.length > 0) {
+      this.setWorkbookState(options.workbook, false);
+    } else {
+      this.runtimes = [createRuntime(first2)];
+      this.active = this.ctx = this.runtimes[0];
+    }
+    this.boundSheetId = this.runtimes[0].doc.id;
     this.primaryDataSourceId = options.primaryDataSourceId;
     this.maxHistoryBytes = Math.max(0, options.maxHistoryBytes ?? DEFAULT_MAX_HISTORY_BYTES);
     this.onDocumentChange = options.onDocumentChange;
     this.onSelectionChange = options.onSelectionChange;
     this.onCellCommit = options.onCellCommit;
+    this.onWorkbookChange = options.onWorkbookChange;
+    this.onActiveSheetChange = options.onActiveSheetChange;
     if (options.dataSources) {
       options.dataSources.forEach((ds) => this.binder.register(ds));
     }
     this.evaluator = new FormulaEvaluator({
-      resolveCell: (colStr, rowNum) => this.resolveCellByCoord(colStr, rowNum),
-      resolveRange: (sCol, sRow, eCol, eRow) => this.resolveRangeByCoords(sCol, sRow, eCol, eRow),
+      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)),
       resolveProperty: (prop) => this.resolveCurrentRowProperty(prop),
-      resolveSpill: (colStr, rowNum) => this.resolveSpillByCoord(colStr, rowNum),
+      resolveSpill: (colStr, rowNum, sheet) => this.onSheet(sheet, () => this.resolveSpillByCoord(colStr, rowNum)),
+      resolveSheetSpan: (first3, last) => this.resolveSheetSpan(first3, last),
+      resolveName: (name, sheet) => this.resolveDefinedName(name, sheet),
       getFormulaCell: () => this.evaluatingCell
     });
     this.syncWithDataSource();
-    this.rederiveTypedValues();
+    for (const rt of this.runtimes) this.withSheet(rt, () => this.rederiveTypedValues());
     this.recalculateAll();
   }
+  // --- Workbook: sheet runtimes ---
+  get boundRuntime() {
+    return this.boundSheetId === null ? null : this.findRuntimeById(this.boundSheetId) ?? null;
+  }
+  /** Runs `fn` with `rt` as the sheet `this.document` (and spills) refer to. */
+  withSheet(rt, fn) {
+    if (rt === this.ctx) return fn();
+    const saved = this.ctx;
+    this.ctx = rt;
+    try {
+      return fn();
+    } finally {
+      this.ctx = saved;
+    }
+  }
+  /**
+   * Runs `fn` on the sheet named `sheet` (a sheet-qualified reference), or
+   * on the current sheet when undefined. `#REF!` when no sheet has that name.
+   */
+  onSheet(sheet, fn) {
+    if (sheet === void 0) return fn();
+    const rt = this.findRuntimeByName(sheet);
+    return rt ? this.withSheet(rt, fn) : "#REF!";
+  }
+  findRuntimeByName(name) {
+    return this.runtimes.find((rt) => sameName3(rt.doc.name, name));
+  }
+  findRuntimeById(id) {
+    return this.runtimes.find((rt) => rt.doc.id === id) ?? this.runtimes.find((rt) => sameName3(rt.doc.id, id));
+  }
+  /** A sheet by id or name. */
+  findRuntime(idOrName) {
+    return this.runtimes.find((rt) => rt.doc.id === idOrName) ?? this.findRuntimeByName(idOrName);
+  }
+  /** Dependency-graph key of a cell (`A1`) on a sheet: sheet-qualified, so keys are unique in the workbook. */
+  qualify(key, rt = this.ctx) {
+    return `${rt.doc.id}!${key}`.toUpperCase();
+  }
+  /** The sheet and A1 key of a qualified key. */
+  unqualify(qualified) {
+    const bang = qualified.lastIndexOf("!");
+    if (bang < 0) return null;
+    const id = qualified.slice(0, bang);
+    const rt = this.runtimes.find((r) => r.doc.id.toUpperCase() === id);
+    return rt ? { rt, key: qualified.slice(bang + 1) } : null;
+  }
+  resolveSheetSpan(first2, last) {
+    const a = this.runtimes.findIndex((rt) => sameName3(rt.doc.name, first2));
+    const b = this.runtimes.findIndex((rt) => sameName3(rt.doc.name, last));
+    if (a < 0 || b < 0) return "#REF!";
+    return this.runtimes.slice(Math.min(a, b), Math.max(a, b) + 1).map((rt) => rt.doc.name);
+  }
+  /** The defined name `name` visible from `rt`: its sheet-scoped name first, then the workbook one. */
+  findName(name, rt) {
+    return (rt ? this.names.find((n) => n.sheetId === rt.doc.id && sameName3(n.name, name)) : void 0) ?? this.names.find((n) => n.sheetId === void 0 && sameName3(n.name, name));
+  }
+  resolveDefinedName(name, sheet) {
+    const rt = sheet === void 0 ? this.ctx : this.findRuntimeByName(sheet);
+    if (!rt) return null;
+    const def = this.findName(name, rt);
+    if (!def) return null;
+    const scope = def.sheetId !== void 0 ? this.findRuntimeById(def.sheetId) : void 0;
+    return {
+      formula: def.refersTo,
+      ...scope ? { sheet: scope.doc.name } : {},
+      key: `${def.sheetId ?? ""}!${def.name}`
+    };
+  }
+  /**
+   * Replaces the active sheet with `document` (its name becomes the sheet's
+   * name, made unique). Clears undo history.
+   */
   loadDocument(document) {
-    this.document = JSON.parse(JSON.stringify(document));
+    const loaded = JSON.parse(JSON.stringify(document));
+    const others = this.runtimes.filter((rt) => rt !== this.active);
+    if (others.some((rt) => rt.doc.id === loaded.id)) loaded.id = this.generateSheetId();
+    const otherNames = others.map((rt) => rt.doc.name);
+    if (!loaded.name || otherNames.some((n) => sameName3(n, loaded.name))) {
+      loaded.name = loaded.name ? copySheetName(loaded.name, otherNames) : nextSheetName(otherNames);
+    }
+    const previousId = this.active.doc.id;
+    this.ctx = this.active;
+    this.document = loaded;
+    if (previousId !== loaded.id) {
+      for (const n of this.names) if (n.sheetId === previousId) n.sheetId = loaded.id;
+      if (this.boundSheetId === previousId) this.boundSheetId = loaded.id;
+    }
     this.activeCell = null;
     this.selectedRange = null;
     this.editingCell = null;
@@ -1371,6 +2726,60 @@ var SpreadsheetController = class {
     this.recalculateAll();
     this.notifyChange();
   }
+  // --- Workbook: loading and saving ---
+  /** A deep copy of the workbook: every sheet, the active sheet and the defined names. */
+  getWorkbook() {
+    return JSON.parse(JSON.stringify(this.workbookSnapshot()));
+  }
+  /** Replaces the whole workbook (sheets, names, active sheet). Clears undo history. */
+  loadWorkbook(workbook) {
+    if (!workbook.sheets.length) return;
+    this.setWorkbookState(JSON.parse(JSON.stringify(workbook)), true);
+    this.boundSheetId = this.runtimes[0].doc.id;
+    this.editingCell = null;
+    this.draftValue = "";
+    this.undoStack = [];
+    this.redoStack = [];
+    this.syncWithDataSource();
+    for (const rt of this.runtimes) this.withSheet(rt, () => this.rederiveTypedValues());
+    this.recalculateAll();
+    this.notifyChange();
+    this.onSelectionChange?.(this.activeCell, this.selectedRange);
+  }
+  workbookSnapshot() {
+    return {
+      sheets: this.runtimes.map((rt) => rt.doc),
+      activeSheetId: this.active.doc.id,
+      names: this.names
+    };
+  }
+  /**
+   * Installs a workbook's sheets and names (taking ownership of the objects).
+   * Duplicate sheet ids and names are made unique.
+   */
+  setWorkbookState(workbook, resetSelection) {
+    const ids = /* @__PURE__ */ new Set();
+    const names = [];
+    const runtimes = workbook.sheets.map((doc) => {
+      if (!doc.id || ids.has(doc.id)) doc.id = this.generateSheetId();
+      ids.add(doc.id);
+      if (!doc.name || names.some((n) => sameName3(n, doc.name))) {
+        doc.name = doc.name ? copySheetName(doc.name, names) : nextSheetName(names);
+      }
+      names.push(doc.name);
+      doc.columns ??= [];
+      doc.rows ??= [];
+      doc.cells ??= {};
+      return createRuntime(doc);
+    });
+    this.runtimes = runtimes;
+    this.active = this.ctx = runtimes.find((rt) => rt.doc.id === workbook.activeSheetId) ?? runtimes[0];
+    this.names = (workbook.names ?? []).filter((n) => n.sheetId === void 0 || ids.has(n.sheetId)).map((n) => ({ ...n, refersTo: n.refersTo.startsWith("=") ? n.refersTo : `=${n.refersTo}` }));
+    if (resetSelection) {
+      this.activeCell = null;
+      this.selectedRange = null;
+    }
+  }
   /**
    * Re-parses the value of every stored typed (non-formula) cell from its
    * `raw` input, so documents saved before typed input was parsed (whose
@@ -1452,9 +2861,12 @@ var SpreadsheetController = class {
     this.recalculateAll();
   }
   syncWithDataSource() {
-    if (!this.primaryDataSourceId) return;
-    this.document.rows = this.binder.syncRows(this.document.rows, this.primaryDataSourceId);
-    this.recomputeRowIndices();
+    if (!this.primaryDataSourceId || !this.boundRuntime) return;
+    const id = this.primaryDataSourceId;
+    this.withSheet(this.boundRuntime, () => {
+      this.document.rows = this.binder.syncRows(this.document.rows, id);
+      this.recomputeRowIndices();
+    });
   }
   recomputeRowIndices() {
     this.document.rows.forEach((r, idx) => {
@@ -1534,18 +2946,24 @@ var SpreadsheetController = class {
     } else {
       cell = { raw, ...this.typedCell(raw, col?.format, col, existing) };
     }
-    const cellKey = this.getCellKey(rowId, colId);
-    this.depGraph.setCellFormula(cellKey, isFormula ? raw : null);
+    const cellKey2 = this.getCellKey(rowId, colId);
+    this.registerFormula(cellKey2, isFormula ? raw : null);
     this.document.cells[rowId][colId] = cell;
     this.document.updatedAt = Date.now();
     if (this.batching) {
       this.pendingCommits.push([rowId, colId, raw]);
       return;
     }
+    if (this.cfDirty !== "all") this.cfDirty.add(cellKey2);
     this.recalculateCell(rowId, colId);
-    this.notifyChange();
-    const evaluatedVal = this.document.cells[rowId][colId]?.value;
-    this.onCellCommit?.(rowId, colId, raw, evaluatedVal);
+    this.cfIncremental = true;
+    try {
+      this.notifyChange();
+    } finally {
+      this.cfIncremental = false;
+    }
+    const evaluatedVal = this.document.cells[rowId][colId]?.value;
+    this.onCellCommit?.(rowId, colId, raw, evaluatedVal);
   }
   getCellKey(rowId, colId) {
     const row = this.document.rows.find((r) => r.id === rowId);
@@ -1558,9 +2976,66 @@ var SpreadsheetController = class {
    * order. Every cell in a reference cycle is marked `#CYCLE!`.
    */
   recalculateCell(rowId, colId) {
-    const cellKey = this.getCellKey(rowId, colId);
-    const anchor = this.spilledBy.get(cellKey);
-    this.recalculateKeys(anchor ? [cellKey, anchor] : [cellKey], true);
+    const cellKey2 = this.getCellKey(rowId, colId);
+    const anchor = this.spilledBy.get(cellKey2);
+    this.recalculateKeys(anchor ? [this.qualify(cellKey2), this.qualify(anchor)] : [this.qualify(cellKey2)], true);
+  }
+  /**
+   * Registers the dependencies of the formula in `cellKey` (A1 key on the
+   * current sheet), or removes them when `formula` is null: its references
+   * (sheet-qualified ones on their sheet, 3-D ones on every sheet of the
+   * span) and, through defined names, the cells those names refer to.
+   */
+  registerFormula(cellKey2, formula) {
+    const key = this.qualify(cellKey2);
+    if (!formula || !formula.startsWith("=")) {
+      this.depGraph.setCellDependencies(key, []);
+      return;
+    }
+    let ast;
+    try {
+      ast = parseFormula(formula);
+    } catch {
+      this.depGraph.setCellDependencies(key, []);
+      return;
+    }
+    const deps = /* @__PURE__ */ new Set();
+    this.collectDependencies(ast, this.ctx, deps, /* @__PURE__ */ new Set());
+    this.depGraph.setCellDependencies(key, deps);
+  }
+  /** Adds the qualified keys `ast` depends on, with unqualified references on `home`. */
+  collectDependencies(ast, home, out, seenNames) {
+    for (const dep of extractCellDependencies(ast)) {
+      let sheets;
+      if (dep.sheet === void 0) {
+        sheets = [home];
+      } else if (dep.sheetEnd === void 0) {
+        const rt = this.findRuntimeByName(dep.sheet);
+        sheets = rt ? [rt] : [];
+      } else {
+        const span = this.resolveSheetSpan(dep.sheet, dep.sheetEnd);
+        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));
+      }
+    }
+    for (const used of extractNameDependencies(ast)) {
+      if (used.call && getFormulaFunction(used.name)) continue;
+      const lookupSheet = used.sheet === void 0 ? home : this.findRuntimeByName(used.sheet);
+      if (!lookupSheet) continue;
+      const def = this.findName(used.name, lookupSheet);
+      if (!def) continue;
+      const scope = def.sheetId !== void 0 ? this.findRuntimeById(def.sheetId) : void 0;
+      const nameHome = scope ?? home;
+      const seenKey = `${def.sheetId ?? ""}!${def.name.toUpperCase()}@${nameHome.doc.id}`;
+      if (seenNames.has(seenKey)) continue;
+      seenNames.add(seenKey);
+      try {
+        this.collectDependencies(parseFormula(def.refersTo), nameHome, out, seenNames);
+      } catch {
+      }
+    }
   }
   /**
    * Recalculates `keys` (and, with `includeDependents`, their dependents) in
@@ -1589,56 +3064,69 @@ var SpreadsheetController = class {
    * in dependency order.
    */
   recalculateAll() {
+    this.cfDirty = "all";
     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 = this.document.cells[row.id]?.[col.id] ?? this.getDerivedCell(row, col);
-        if (cell.raw.startsWith("=")) {
-          const cellKey = `${col.key}${row.index + 1}`.toUpperCase();
-          this.depGraph.setCellFormula(cellKey, cell.raw);
-          formulaKeys.push(cellKey);
+    for (const rt of this.runtimes) {
+      this.withSheet(rt, () => {
+        this.spills.clear();
+        this.spilledBy.clear();
+        this.spillCells.clear();
+        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 cellKey2 = `${col.key}${row.index + 1}`.toUpperCase();
+              this.registerFormula(cellKey2, cell.raw);
+              formulaKeys.push(this.qualify(cellKey2));
+            }
+          }
         }
-      }
+      });
     }
     this.recalculateKeys(formulaKeys, false);
   }
   runEvaluationPlan(plan) {
-    for (const key of plan.order) {
-      if (plan.cyclic.has(key)) {
-        this.markCycle(key);
-      } else {
-        this.evalSingleCellByKey(key);
-      }
+    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);
+      });
     }
   }
-  locateCellKey(cellKey) {
-    const match = cellKey.match(/^([A-Za-z]+)(\d+)$/);
+  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 row = this.document.rows[parseInt(match[2], 10) - 1];
     return col && row ? { row, col } : null;
   }
-  markCycle(cellKey) {
-    const located = this.locateCellKey(cellKey);
+  markCycle(cellKey2) {
+    const located = this.locateCellKey(cellKey2);
     if (!located) return;
     const { row, col } = located;
     const cell = this.getCell(row.id, col.id);
     if (!cell.raw.startsWith("=")) return;
     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 spilledKeys = this.depGraph.getSpilledKeys(cellKey);
+    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 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);
+    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 };
   }
-  evalSingleCellByKey(cellKey) {
-    const match = cellKey.match(/^([A-Za-z]+)(\d+)$/);
+  evalSingleCellByKey(cellKey2) {
+    const match = cellKey2.match(/^([A-Za-z]+)(\d+)$/);
     if (!match) return;
     const colName = match[1].toUpperCase();
     const rowNum = parseInt(match[2], 10);
@@ -1723,7 +3211,7 @@ var SpreadsheetController = class {
     }
     if (reason) {
       this.clearSpill(anchor);
-      this.depGraph.setSpillEdges(anchor, [], blockers);
+      this.depGraph.setSpillEdges(this.qualify(anchor), [], blockers.map((key) => this.qualify(key)));
       return reason;
     }
     const previous = this.spills.get(anchor);
@@ -1749,7 +3237,7 @@ var SpreadsheetController = class {
         this.spillCells.set(spillCellId(rowObj.id, column.id), display);
         if (this.spilledBy.get(key) !== anchor) {
           this.spilledBy.set(key, anchor);
-          this.spillChanges?.add(key);
+          this.spillChanges?.add(this.qualify(key));
         }
         cells.push({ key, rowId: rowObj.id, colId: column.id });
       }
@@ -1762,7 +3250,7 @@ var SpreadsheetController = class {
       }
     }
     this.spills.set(anchor, { anchor, row, col, rows, cols, values: array.values, cells });
-    this.depGraph.setSpillEdges(anchor, cells.map((cell) => cell.key));
+    this.depGraph.setSpillEdges(this.qualify(anchor), cells.map((cell) => this.qualify(cell.key)));
     return null;
   }
   /** Removes the array spilled from `anchor`. With `keepEdges`, its dependency edges stay. */
@@ -1772,13 +3260,13 @@ var SpreadsheetController = class {
       for (const cell of record.cells) this.forgetSpilledCell(anchor, cell);
       this.spills.delete(anchor);
     }
-    if (!keepEdges) this.depGraph.setSpillEdges(anchor, []);
+    if (!keepEdges) this.depGraph.setSpillEdges(this.qualify(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));
-    this.spillChanges?.add(cell.key);
+    this.spillChanges?.add(this.qualify(cell.key));
   }
   resolveSpillByCoord(colStr, rowNum) {
     const record = this.spills.get(`${colStr}${rowNum}`.toUpperCase());
@@ -1832,6 +3320,8 @@ var SpreadsheetController = class {
     const col = this.document.columns.find((c) => c.key.toUpperCase() === colStr.toUpperCase());
     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 ?? "";
   }
   resolveRangeByCoords(sCol, sRow, eCol, eRow) {
@@ -1846,9 +3336,14 @@ var SpreadsheetController = class {
       const colName = indexToColName(c);
       const col = this.document.columns.find((colDef) => colDef.key.toUpperCase() === colName);
       if (!col) continue;
+      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];
         if (!row) continue;
+        if (override && override.row === r - 1) {
+          results.push(override.value);
+          continue;
+        }
         results.push(this.getCell(row.id, col.id).value ?? "");
       }
     }
@@ -1915,14 +3410,75 @@ var SpreadsheetController = class {
     const cell = this.getCell(rowObj.id, colObj.id);
     this.draftValue = initialValue !== void 0 ? initialValue : cell.raw;
   }
+  /**
+   * Commits the cell editor's draft (or `valueToCommit`). Input that breaks
+   * the cell's data validation is not committed: the editor stays open and
+   * `validationPrompt` holds the alert until `resolveValidationPrompt`.
+   * Unchanged input is not validated.
+   */
   commitEditing(valueToCommit) {
-    if (!this.editingCell) return;
+    if (!this.editingCell) return { status: "none" };
+    if (this.validationPrompt) return { status: "pending", prompt: this.validationPrompt };
     const val = valueToCommit !== void 0 ? valueToCommit : this.draftValue;
-    if (this.editingCell.rowId && this.editingCell.colId) {
-      this.setCellValue(this.editingCell.rowId, this.editingCell.colId, val);
+    const { rowId, colId, row, col } = this.editingCell;
+    if (rowId && colId) {
+      const failed = this.checkInput(rowId, colId, row, col, val, true);
+      if (failed) return failed;
+      this.setCellValue(rowId, colId, val);
     }
     this.editingCell = null;
     this.draftValue = "";
+    return { status: "committed" };
+  }
+  /**
+   * Commits typed input to a cell (e.g. from the formula bar or a list
+   * dropdown) with data validation, like `commitEditing` without an open
+   * editor. `setCellValue` never validates (paste, import and code bypass
+   * validation, as in Excel).
+   */
+  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);
+    if (row === -1 || col === -1) return { status: "none" };
+    const failed = this.checkInput(rowId, colId, row, col, raw, false);
+    if (failed) return failed;
+    this.setCellValue(rowId, colId, raw);
+    return { status: "committed" };
+  }
+  /** Validates input; when it fails, records and returns the prompt. */
+  checkInput(rowId, colId, row, col, raw, editing) {
+    if (!this.document.table?.dataValidations?.length) return null;
+    if (this.getCell(rowId, colId).raw === raw) return null;
+    const result = this.validateCellInput(row, col, raw);
+    if (result.valid) return null;
+    const prompt = { rowId, colId, row, col, raw, result, editing };
+    this.validationPrompt = prompt;
+    return { status: result.errorStyle === "stop" ? "rejected" : "confirm", prompt };
+  }
+  /**
+   * Answers `validationPrompt`: `accept` keeps the input (warning and
+   * information alerts only; for a stop alert it acts as `retry`), `retry`
+   * returns to editing it, `cancel` discards it.
+   */
+  resolveValidationPrompt(action) {
+    const prompt = this.validationPrompt;
+    if (!prompt) return;
+    this.validationPrompt = null;
+    const editingSameCell = prompt.editing && this.editingCell?.rowId === prompt.rowId && this.editingCell?.colId === prompt.colId;
+    if (action === "accept" && prompt.result.errorStyle !== "stop") {
+      this.setCellValue(prompt.rowId, prompt.colId, prompt.raw);
+      if (editingSameCell) {
+        this.editingCell = null;
+        this.draftValue = "";
+      }
+    } else if (action === "cancel") {
+      if (editingSameCell) this.cancelEditing();
+    } else if (editingSameCell) {
+      this.draftValue = prompt.raw;
+    } else {
+      this.startEditing(prompt.row, prompt.col, prompt.raw);
+    }
   }
   cancelEditing() {
     this.editingCell = null;
@@ -2027,20 +3583,36 @@ var SpreadsheetController = class {
    * column formula) so they keep pointing at the same cells.
    */
   shiftReferences(change) {
-    for (const rowCells of Object.values(this.document.cells)) {
-      for (const cell of Object.values(rowCells)) {
-        if (cell.raw?.startsWith("=")) {
-          cell.raw = shiftFormulaReferences(cell.raw, change);
+    const changed = this.ctx;
+    for (const rt of this.runtimes) {
+      const filter = this.referencesTo(changed, rt);
+      for (const rowCells of Object.values(rt.doc.cells)) {
+        for (const cell of Object.values(rowCells)) {
+          if (cell.raw?.startsWith("=")) {
+            cell.raw = shiftFormulaReferences(cell.raw, change, filter);
+          }
         }
       }
-    }
-    if (change.axis === "col") {
-      for (const col of this.document.columns) {
-        if (col.formula?.startsWith("=")) {
-          col.formula = shiftFormulaReferences(col.formula, change);
+      if (change.axis === "col") {
+        for (const col of rt.doc.columns) {
+          if (col.formula?.startsWith("=")) {
+            col.formula = shiftFormulaReferences(col.formula, change, filter);
+          }
         }
       }
     }
+    for (const n of this.names) {
+      const scope = n.sheetId !== void 0 ? this.findRuntimeById(n.sheetId) : void 0;
+      n.refersTo = shiftFormulaReferences(n.refersTo, change, {
+        appliesTo: (sheet, sheetEnd) => sheetEnd === void 0 && (sheet === void 0 ? scope === changed : sameName3(sheet, changed.doc.name))
+      });
+    }
+  }
+  /** Filter for references, in formulas on sheet `on`, that point at sheet `target`. */
+  referencesTo(target, on) {
+    return {
+      appliesTo: (sheet, sheetEnd) => sheetEnd === void 0 && (sheet === void 0 ? on === target : sameName3(sheet, target.doc.name))
+    };
   }
   setColumnWidth(colId, width) {
     const col = this.document.columns.find((c) => c.id === colId);
@@ -2174,14 +3746,24 @@ var SpreadsheetController = class {
    */
   importFromCsv(csv, options = {}) {
     const matrix = parseCsv(csv, { delimiter: options.delimiter });
-    this.writeMatrix(matrix, options.startRow ?? 0, options.startCol ?? 0);
+    this.onTargetSheet(options.sheet, () => this.writeMatrix(matrix, options.startRow ?? 0, options.startCol ?? 0));
+  }
+  /** Runs `fn` on the sheet `sheet` (id or name), default the active one. Throws for an unknown sheet. */
+  onTargetSheet(sheet, fn) {
+    if (sheet === void 0) {
+      fn();
+      return;
+    }
+    const rt = this.findRuntime(sheet);
+    if (!rt) throw new Error(`There is no sheet "${sheet}".`);
+    this.withSheet(rt, fn);
   }
   /**
    * Writes already-parsed rows of raw inputs (e.g. from an import adapter)
    * starting at (startRow, startCol), as a single undo step.
    */
   importRows(rows, options = {}) {
-    this.writeMatrix(rows, options.startRow ?? 0, options.startCol ?? 0);
+    this.onTargetSheet(options.sheet, () => this.writeMatrix(rows, options.startRow ?? 0, options.startCol ?? 0));
   }
   /** The cells of `range` (or the whole sheet), row by row. */
   readMatrix(range) {
@@ -2271,10 +3853,14 @@ var SpreadsheetController = class {
   };
   /** Rewrites every formula so references follow cells that moved. */
   remapAllFormulas(moveCell) {
-    for (const rowCells of Object.values(this.document.cells)) {
-      for (const cell of Object.values(rowCells)) {
-        if (cell.raw?.startsWith("=")) {
-          cell.raw = remapFormulaReferences(cell.raw, moveCell);
+    const moved = this.ctx;
+    for (const rt of this.runtimes) {
+      const filter = this.referencesTo(moved, rt);
+      for (const rowCells of Object.values(rt.doc.cells)) {
+        for (const cell of Object.values(rowCells)) {
+          if (cell.raw?.startsWith("=")) {
+            cell.raw = remapFormulaReferences(cell.raw, moveCell, filter);
+          }
         }
       }
     }
@@ -2285,6 +3871,7 @@ var SpreadsheetController = class {
    * merges reduced to a single cell are dropped.
    */
   adjustTableForStructuralChange(change) {
+    this.adjustRulesForStructuralChange(change);
     const merges = this.document.table?.merges;
     if (!merges?.length) return;
     const startKey = change.axis === "row" ? "startRow" : "startCol";
@@ -2806,10 +4393,361 @@ var SpreadsheetController = class {
   getViewModel() {
     return buildSpreadsheetView(this.document, this.getCellValueAt);
   }
+  // --- Sheets ---
+  /** The sheets in tab order. */
+  getSheets() {
+    return this.runtimes.map((rt, index) => ({ id: rt.doc.id, name: rt.doc.name, index, active: rt === this.active }));
+  }
+  /** Id of the active sheet (the one `document` is). */
+  get activeSheetId() {
+    return this.active.doc.id;
+  }
+  /** A sheet's document by id or name (live: don't mutate it directly). */
+  getSheetDocument(idOrName) {
+    return this.findRuntime(idOrName)?.doc;
+  }
+  /** Why `name` can't name a sheet (or null): see `validateSheetName`. `exceptSheet` is the sheet being renamed. */
+  validateSheetName(name, exceptSheet) {
+    const except = exceptSheet === void 0 ? void 0 : this.findRuntime(exceptSheet);
+    return validateSheetName(
+      name,
+      this.runtimes.filter((rt) => rt !== except).map((rt) => rt.doc.name)
+    );
+  }
+  /**
+   * Shows another sheet (by id or name). The current edit is committed and
+   * each sheet keeps its own selection. Returns false for an unknown sheet.
+   */
+  setActiveSheet(idOrName) {
+    const rt = this.findRuntime(idOrName);
+    if (!rt) return false;
+    if (rt === this.active) return true;
+    if (this.editingCell) this.commitEditing();
+    this.activateRuntime(rt);
+    this.notifyChange();
+    return true;
+  }
+  activateRuntime(rt) {
+    if (rt === this.active) return;
+    if (this.runtimes.includes(this.active)) {
+      this.active.activeCell = this.activeCell;
+      this.active.selectedRange = this.selectedRange;
+    }
+    this.active = this.ctx = rt;
+    this.activeCell = rt.activeCell;
+    this.selectedRange = rt.selectedRange;
+    this.editingCell = null;
+    this.draftValue = "";
+    this.onSelectionChange?.(this.activeCell, this.selectedRange);
+    this.onActiveSheetChange?.(rt.doc.id);
+  }
+  /**
+   * Adds a sheet (default: `Sheet N`, empty, after the last sheet) and
+   * activates it unless `activate` is false. Returns its id. Throws when
+   * `name` is invalid or taken. Undoable.
+   */
+  addSheet(options = {}) {
+    const existing = this.runtimes.map((rt2) => rt2.doc.name);
+    const name = options.name ?? options.document?.name ?? nextSheetName(existing);
+    const invalid2 = validateSheetName(name, existing);
+    if (invalid2) throw new Error(invalid2);
+    this.recordWorkbookSnapshot();
+    const id = options.document?.id && !this.findRuntimeById(options.document.id) ? options.document.id : this.generateSheetId();
+    const doc = {
+      columns: Array.from({ length: 4 }, (_, i) => ({
+        id: `col_${String.fromCharCode(97 + i)}`,
+        key: indexToColName(i),
+        title: indexToColName(i),
+        width: 120,
+        type: "freeform"
+      })),
+      rows: Array.from({ length: 10 }, (_, i) => ({ id: `row_${i + 1}`, index: i, height: 32, type: "freeform" })),
+      cells: {},
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      ...JSON.parse(JSON.stringify(options.document ?? {})),
+      id,
+      name
+    };
+    const rt = createRuntime(doc);
+    const index = Math.max(0, Math.min(options.index ?? this.runtimes.length, this.runtimes.length));
+    this.runtimes.splice(index, 0, rt);
+    this.withSheet(rt, () => {
+      this.recomputeRowIndices();
+      this.rederiveTypedValues();
+    });
+    if (options.activate !== false) this.activateRuntime(rt);
+    this.recalculateAll();
+    this.notifyChange();
+    return id;
+  }
+  /**
+   * Renames a sheet. Formulas on every sheet and defined names that refer to
+   * it follow (`=Old!A1` becomes `='New Name'!A1`). Throws when the name is
+   * invalid or taken. Undoable.
+   */
+  renameSheet(idOrName, newName) {
+    const rt = this.findRuntime(idOrName);
+    if (!rt) throw new Error(`There is no sheet "${idOrName}".`);
+    if (rt.doc.name === newName) return;
+    const invalid2 = this.validateSheetName(newName, rt.doc.id);
+    if (invalid2) throw new Error(invalid2);
+    this.recordWorkbookSnapshot();
+    const oldName = rt.doc.name;
+    this.rewriteAllFormulas((formula) => renameSheetInFormula(formula, oldName, newName));
+    rt.doc.name = newName;
+    rt.doc.updatedAt = Date.now();
+    this.recalculateAll();
+    this.notifyChange();
+  }
+  /** Moves a sheet to position `toIndex` in tab order. Returns false for an unknown sheet. Undoable. */
+  moveSheet(idOrName, toIndex) {
+    const rt = this.findRuntime(idOrName);
+    if (!rt) return false;
+    const from = this.runtimes.indexOf(rt);
+    const to = Math.max(0, Math.min(Math.floor(toIndex), this.runtimes.length - 1));
+    if (from === to) return true;
+    this.recordWorkbookSnapshot();
+    this.runtimes.splice(from, 1);
+    this.runtimes.splice(to, 0, rt);
+    this.recalculateAll();
+    this.notifyChange();
+    return true;
+  }
+  /**
+   * Deletes a sheet and its sheet-scoped names. References to it become
+   * `#REF!` (a 3-D reference losing an end sheet shrinks). The last sheet
+   * can't be deleted (returns false). Undoable.
+   */
+  deleteSheet(idOrName) {
+    const rt = this.findRuntime(idOrName);
+    if (!rt || this.runtimes.length <= 1) return false;
+    this.recordWorkbookSnapshot();
+    const order = this.runtimes.map((r) => r.doc.name);
+    const index = this.runtimes.indexOf(rt);
+    this.runtimes.splice(index, 1);
+    this.names = this.names.filter((n) => n.sheetId !== rt.doc.id);
+    this.rewriteAllFormulas((formula) => deleteSheetInFormula(formula, rt.doc.name, order));
+    if (this.active === rt) {
+      this.ctx = this.active;
+      this.activateRuntime(this.runtimes[Math.min(index, this.runtimes.length - 1)]);
+    } else if (this.ctx === rt) {
+      this.ctx = this.active;
+    }
+    this.recalculateAll();
+    this.notifyChange();
+    return true;
+  }
+  /**
+   * Copies a sheet (default name `Name (2)`, placed after it) with its
+   * sheet-scoped names, which refer to the copy. Activates the copy unless
+   * `activate` is false. Returns the new sheet's id, or null for an unknown
+   * sheet. Undoable.
+   */
+  duplicateSheet(idOrName, options = {}) {
+    const source = this.findRuntime(idOrName);
+    if (!source) return null;
+    const existing = this.runtimes.map((rt2) => rt2.doc.name);
+    const name = options.name ?? copySheetName(source.doc.name, existing);
+    const invalid2 = validateSheetName(name, existing);
+    if (invalid2) throw new Error(invalid2);
+    this.recordWorkbookSnapshot();
+    const doc = JSON.parse(JSON.stringify(source.doc));
+    doc.id = this.generateSheetId();
+    doc.name = name;
+    doc.createdAt = doc.updatedAt = Date.now();
+    const copies = this.names.filter((n) => n.sheetId === source.doc.id).map((n) => ({ ...n, sheetId: doc.id, refersTo: renameSheetInFormula(n.refersTo, source.doc.name, name) }));
+    this.names.push(...copies);
+    const rt = createRuntime(doc);
+    const index = Math.max(0, Math.min(options.index ?? this.runtimes.indexOf(source) + 1, this.runtimes.length));
+    this.runtimes.splice(index, 0, rt);
+    if (options.activate !== false) this.activateRuntime(rt);
+    this.recalculateAll();
+    this.notifyChange();
+    return doc.id;
+  }
+  /** Applies `rewrite` to every formula: cells and column formulas on every sheet, and defined names. */
+  rewriteAllFormulas(rewrite) {
+    for (const rt of this.runtimes) {
+      for (const [rowId, rowCells] of Object.entries(rt.doc.cells)) {
+        for (const [colId, cell] of Object.entries(rowCells)) {
+          if (!cell.raw?.startsWith("=")) continue;
+          const raw = rewrite(cell.raw);
+          if (raw !== cell.raw) rt.doc.cells[rowId][colId] = { ...cell, raw };
+        }
+      }
+      for (const col of rt.doc.columns) {
+        if (col.formula?.startsWith("=")) col.formula = rewrite(col.formula);
+      }
+    }
+    for (const n of this.names) n.refersTo = rewrite(n.refersTo);
+  }
+  generateSheetId() {
+    return `sheet_${Date.now()}_${(nextIdSequence++).toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
+  }
+  // --- Defined names (Name Manager) ---
+  /** Every defined name, workbook-scoped and sheet-scoped. */
+  getNames() {
+    return this.names.map((n) => {
+      const scope = n.sheetId !== void 0 ? this.findRuntimeById(n.sheetId) : void 0;
+      return {
+        ...n,
+        ...scope ? { sheetName: scope.doc.name } : {},
+        isLambda: isLambdaDefinition(n)
+      };
+    });
+  }
+  /** The defined name `name` visible from the active sheet (its own sheet-scoped name first), or undefined. */
+  getName(name, scope) {
+    const rt = scope?.sheet !== void 0 ? this.findRuntime(scope.sheet) : void 0;
+    const def = scope?.sheet !== void 0 ? rt ? this.names.find((n) => n.sheetId === rt.doc.id && sameName3(n.name, name)) : void 0 : this.findName(name, this.active);
+    return def ? this.getNames().find((n) => n.name === def.name && n.sheetId === def.sheetId) : void 0;
+  }
+  /** Why `name` can't be a defined name (or null): see `validateDefinedName`. */
+  validateDefinedName(name) {
+    return validateDefinedName(name);
+  }
+  scopeRuntime(scope) {
+    if (scope?.sheet === void 0) return void 0;
+    const rt = this.findRuntime(scope.sheet);
+    if (!rt) throw new Error(`There is no sheet "${scope.sheet}".`);
+    return rt;
+  }
+  /**
+   * Defines (or redefines) a name in the workbook, or on one sheet with
+   * `sheet`. `refersTo` is a formula: a range (`=Data!$A$2:$A$20`), a
+   * constant (`=0.07`), a formula or a LAMBDA (`=LAMBDA(x, x*2)`, called as
+   * `=Double(4)`). Formulas using the name recalculate. Throws when the name
+   * is invalid or the formula can't be read. Undoable.
+   */
+  defineName(name, refersTo, options = {}) {
+    const invalid2 = validateDefinedName(name);
+    if (invalid2) throw new Error(invalid2);
+    const formula = refersTo.trim().startsWith("=") ? refersTo.trim() : `=${refersTo.trim()}`;
+    try {
+      parseFormula(formula);
+    } catch (err) {
+      throw new Error(`There's a problem with this formula: ${err?.message ?? formula}`);
+    }
+    const rt = this.scopeRuntime(options);
+    this.recordWorkbookSnapshot();
+    const sheetId = rt?.doc.id;
+    const index = this.names.findIndex((n) => n.sheetId === sheetId && sameName3(n.name, name));
+    const def = {
+      name,
+      refersTo: formula,
+      ...sheetId !== void 0 ? { sheetId } : {},
+      ...options.comment ? { comment: options.comment } : {}
+    };
+    if (index >= 0) this.names[index] = def;
+    else this.names.push(def);
+    this.recalculateAll();
+    this.notifyChange();
+  }
+  /**
+   * Renames a defined name. Formulas that use it (cells, column formulas and
+   * other names) follow, on the sheets where the old name meant this one.
+   * Throws when the name doesn't exist or the new name is invalid or taken.
+   * Undoable.
+   */
+  renameName(oldName, newName, options = {}) {
+    const rt = this.scopeRuntime(options);
+    const sheetId = rt?.doc.id;
+    const def = this.names.find((n) => n.sheetId === sheetId && sameName3(n.name, oldName));
+    if (!def) throw new Error(`There is no name "${oldName}"${rt ? ` on sheet ${rt.doc.name}` : ""}.`);
+    if (def.name === newName) return;
+    const invalid2 = validateDefinedName(newName);
+    if (invalid2) throw new Error(invalid2);
+    if (!sameName3(oldName, newName) && this.names.some((n) => n.sheetId === sheetId && sameName3(n.name, newName))) {
+      throw new Error("The name entered already exists. Enter a unique name.");
+    }
+    this.recordWorkbookSnapshot();
+    const shadowedOn = new Set(this.names.filter((n) => n.sheetId !== void 0 && sameName3(n.name, oldName)).map((n) => n.sheetId));
+    const appliesOn = (sheet) => sheetId !== void 0 ? sheet?.doc.id === sheetId : !sheet || !shadowedOn.has(sheet.doc.id);
+    const appliesToSheetName = (sheetName) => appliesOn(this.findRuntimeByName(sheetName));
+    for (const sheet of this.runtimes) {
+      const options2 = { appliesTo: appliesToSheetName, qualifiedOnly: !appliesOn(sheet) };
+      for (const [rowId, rowCells] of Object.entries(sheet.doc.cells)) {
+        for (const [colId, cell] of Object.entries(rowCells)) {
+          if (!cell.raw?.startsWith("=")) continue;
+          const raw = renameNameInFormula(cell.raw, oldName, newName, options2);
+          if (raw !== cell.raw) sheet.doc.cells[rowId][colId] = { ...cell, raw };
+        }
+      }
+      for (const col of sheet.doc.columns) {
+        if (col.formula?.startsWith("=")) col.formula = renameNameInFormula(col.formula, oldName, newName, options2);
+      }
+    }
+    for (const n of this.names) {
+      const scope = n.sheetId !== void 0 ? this.findRuntimeById(n.sheetId) : void 0;
+      n.refersTo = renameNameInFormula(n.refersTo, oldName, newName, {
+        appliesTo: appliesToSheetName,
+        qualifiedOnly: scope ? !appliesOn(scope) : sheetId !== void 0
+      });
+    }
+    def.name = newName;
+    this.recalculateAll();
+    this.notifyChange();
+  }
+  /**
+   * Deletes a defined name. Formulas still using it show `#NAME?`. Returns
+   * false when there is no such name. Undoable.
+   */
+  deleteName(name, options = {}) {
+    const rt = this.scopeRuntime(options);
+    const sheetId = rt?.doc.id;
+    const index = this.names.findIndex((n) => n.sheetId === sheetId && sameName3(n.name, name));
+    if (index < 0) return false;
+    this.recordWorkbookSnapshot();
+    this.names.splice(index, 1);
+    this.recalculateAll();
+    this.notifyChange();
+    return true;
+  }
+  /**
+   * Names formula autocomplete can offer on the active sheet: its
+   * sheet-scoped names and the workbook names they don't hide.
+   */
+  getNameSuggestions() {
+    const visible = /* @__PURE__ */ new Map();
+    for (const n of this.names) {
+      if (n.sheetId === this.active.doc.id) visible.set(n.name.toUpperCase(), n);
+    }
+    for (const n of this.names) {
+      if (n.sheetId === void 0 && !visible.has(n.name.toUpperCase())) visible.set(n.name.toUpperCase(), n);
+    }
+    return Array.from(visible.values(), (n) => ({
+      name: n.name,
+      description: n.comment ? `${n.comment} (${n.refersTo})` : n.refersTo,
+      isLambda: isLambdaDefinition(n)
+    })).sort((a, b) => a.name.localeCompare(b.name));
+  }
+  /**
+   * Evaluates a formula (e.g. `=Rate*2`, `=SUM(Sales)`) as if it were in a
+   * cell of `sheet` (id or name; default the active sheet), without storing
+   * it. Used by the Name Manager to show a name's current value.
+   */
+  evaluateFormula(formula, options = {}) {
+    const rt = options.sheet === void 0 ? this.active : this.findRuntime(options.sheet);
+    if (!rt) return { value: "#REF!", error: "#REF!", message: `There is no sheet "${options.sheet}".` };
+    const text = formula.startsWith("=") ? formula : `=${formula}`;
+    return this.withSheet(rt, () => this.evaluator.evaluateWithDiagnostics(text));
+  }
   // --- Undo/Redo Snapshots ---
+  //
+  // Most steps snapshot one sheet (the one changed); sheet and name
+  // operations snapshot the whole workbook. Undoing a sheet's step shows
+  // that sheet.
   recordSnapshot() {
     if (this.isApplyingHistory || this.batching) return;
-    this.undoStack.push(JSON.stringify(this.document));
+    this.pushUndo({ kind: "sheet", sheetId: this.ctx.doc.id, data: JSON.stringify(this.ctx.doc) });
+  }
+  recordWorkbookSnapshot() {
+    if (this.isApplyingHistory || this.batching) return;
+    this.pushUndo({ kind: "workbook", data: JSON.stringify(this.workbookSnapshot()) });
+  }
+  pushUndo(entry) {
+    this.undoStack.push(entry);
     if (this.undoStack.length > 50) this.undoStack.shift();
     this.redoStack = [];
     this.trimHistory();
@@ -2817,18 +4755,16 @@ var SpreadsheetController = class {
   /** 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;
+    let total = this.getHistoryByteSize();
     while (total > this.maxHistoryBytes && this.undoStack.length > 1) {
-      total -= this.undoStack.shift().length * 2;
+      total -= this.undoStack.shift().data.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;
+    for (const s of this.undoStack) total += s.data.length * 2;
+    for (const s of this.redoStack) total += s.data.length * 2;
     return total;
   }
   /** Number of undo / redo snapshots currently held. */
@@ -2836,32 +4772,340 @@ var SpreadsheetController = class {
     return { undo: this.undoStack.length, redo: this.redoStack.length };
   }
   undo() {
-    if (this.undoStack.length === 0) return;
+    this.applyHistory(this.undoStack, this.redoStack);
+  }
+  redo() {
+    this.applyHistory(this.redoStack, this.undoStack);
+  }
+  /** Restores the newest entry of `from`, saving the current state of the same scope on `to`. */
+  applyHistory(from, to) {
+    const entry = from.pop();
+    if (!entry) return;
     this.isApplyingHistory = true;
     try {
-      this.redoStack.push(JSON.stringify(this.document));
-      this.document = JSON.parse(this.undoStack.pop());
+      if (entry.kind === "sheet") {
+        const rt = this.findRuntimeById(entry.sheetId);
+        if (!rt) return;
+        to.push({ kind: "sheet", sheetId: rt.doc.id, data: JSON.stringify(rt.doc) });
+        rt.doc = JSON.parse(entry.data);
+        if (rt !== this.active) {
+          this.ctx = this.active;
+          this.activateRuntime(rt);
+        }
+      } else {
+        to.push({ kind: "workbook", data: JSON.stringify(this.workbookSnapshot()) });
+        const previousActive = this.active.doc.id;
+        const selection = { activeCell: this.activeCell, selectedRange: this.selectedRange };
+        const saved = new Map(this.runtimes.map((rt) => [rt.doc.id, rt]));
+        this.setWorkbookState(JSON.parse(entry.data), false);
+        for (const rt of this.runtimes) {
+          const old = saved.get(rt.doc.id);
+          if (old) {
+            rt.activeCell = old.activeCell;
+            rt.selectedRange = old.selectedRange;
+          }
+        }
+        if (this.active.doc.id === previousActive) {
+          this.activeCell = selection.activeCell;
+          this.selectedRange = selection.selectedRange;
+        } else {
+          this.activeCell = this.active.activeCell;
+          this.selectedRange = this.active.selectedRange;
+          this.onSelectionChange?.(this.activeCell, this.selectedRange);
+          this.onActiveSheetChange?.(this.active.doc.id);
+        }
+      }
       this.recalculateAll();
       this.notifyChange();
     } finally {
       this.isApplyingHistory = false;
     }
   }
-  redo() {
-    if (this.redoStack.length === 0) return;
-    this.isApplyingHistory = true;
+  notifyChange() {
+    if (!this.cfIncremental) this.cfDirty = "all";
+    this.invalidCircles = null;
+    this.onDocumentChange?.(this.active.doc);
+    if (this.onWorkbookChange) {
+      const snapshot = this.workbookSnapshot();
+      this.onWorkbookChange({ sheets: snapshot.sheets, activeSheetId: snapshot.activeSheetId, names: snapshot.names });
+    }
+  }
+  // --- Conditional formatting and data validation ---
+  /** The sheet as rule evaluation sees it. */
+  ruleSheet() {
+    return {
+      rowCount: this.document.rows.length,
+      colCount: this.document.columns.length,
+      getValue: (row, col) => this.getCellValueAt(row, col) ?? "",
+      getInput: (row, col) => {
+        const r = this.document.rows[row];
+        const c = this.document.columns[col];
+        return r && c ? this.getCell(r.id, c.id).raw : "";
+      },
+      evaluateFormula: (formula, row, col, entered) => this.evaluateFormulaAt(formula, row, col, entered)
+    };
+  }
+  /**
+   * Evaluates `formula` as if it were in (row, col), without storing it:
+   * relative references and `[property]` resolve from that cell. With
+   * `entered`, that cell reads as the given value (input being validated).
+   * Returns the value, or an array's values (column-major) for a range.
+   */
+  evaluateFormulaAt(formula, row, col, entered) {
+    const saved = { rowIndex: this.evaluatingRowIndex, cell: this.evaluatingCell, override: this.valueOverride };
+    this.evaluatingRowIndex = row;
+    this.evaluatingCell = { col: this.document.columns[col]?.key ?? indexToColName(col), row: row + 1 };
+    this.valueOverride = entered ?? null;
     try {
-      this.undoStack.push(JSON.stringify(this.document));
-      this.document = JSON.parse(this.redoStack.pop());
-      this.recalculateAll();
-      this.notifyChange();
+      const result = this.evaluator.evaluateWithDiagnostics(formula.startsWith("=") ? formula : `=${formula}`);
+      return result.array ? result.array.values : result.value;
     } finally {
-      this.isApplyingHistory = false;
+      this.evaluatingRowIndex = saved.rowIndex;
+      this.evaluatingCell = saved.cell;
+      this.valueOverride = saved.override;
     }
   }
-  notifyChange() {
+  /** Records that the value of `cellKey` (and of the array it spills) may have changed. */
+  markValueChanged(cellKey2) {
+    if (this.cfDirty === "all") return;
+    this.cfDirty.add(cellKey2);
+    const spill = this.spills.get(cellKey2);
+    if (spill) for (const cell of spill.cells) this.cfDirty.add(cell.key);
+  }
+  generateRuleId(prefix) {
+    return `${prefix}_${Date.now()}_${(nextIdSequence++).toString(36)}`;
+  }
+  /** Moves rule ranges and rule formulas with inserted / deleted rows and columns. */
+  adjustRulesForStructuralChange(change) {
+    const table = this.document.table;
+    if (!table) return;
+    const shiftIfFormula = (text) => text !== void 0 && text.trimStart().startsWith("=") ? shiftRuleFormula(text, change) : text;
+    const shiftAnchor = (value) => value.type === "formula" ? { ...value, formula: shiftRuleFormula(value.formula, change) } : value;
+    if (table.conditionalFormats?.length) {
+      table.conditionalFormats = table.conditionalFormats.map((rule) => {
+        const next = { ...rule, ranges: adjustRangesForStructuralChange(rule.ranges, change) };
+        if (next.type === "expression") next.formula = shiftRuleFormula(next.formula, change);
+        if (next.type === "cellIs") {
+          next.value = shiftIfFormula(next.value) ?? "";
+          if (next.value2 !== void 0) next.value2 = shiftIfFormula(next.value2);
+        }
+        if (next.type === "colorScale") next.stops = next.stops.map((s) => ({ ...s, value: shiftAnchor(s.value) }));
+        if (next.type === "dataBar") {
+          if (next.min) next.min = shiftAnchor(next.min);
+          if (next.max) next.max = shiftAnchor(next.max);
+        }
+        if (next.type === "iconSet" && next.thresholds) next.thresholds = next.thresholds.map(shiftAnchor);
+        return next;
+      }).filter((rule) => rule.ranges.length > 0);
+    }
+    if (table.dataValidations?.length) {
+      table.dataValidations = table.dataValidations.map((rule) => {
+        const next = { ...rule, ranges: adjustRangesForStructuralChange(rule.ranges, change) };
+        if (rule.formula1 !== void 0) next.formula1 = shiftIfFormula(rule.formula1);
+        if (rule.formula2 !== void 0) next.formula2 = shiftIfFormula(rule.formula2);
+        return next;
+      }).filter((rule) => rule.ranges.length > 0);
+    }
+  }
+  /** Conditional formats of the sheet, highest priority first. */
+  getConditionalFormats() {
+    return this.document.table?.conditionalFormats ?? [];
+  }
+  /**
+   * Adds a conditional format (one undo step). New rules get the highest
+   * priority, as in Excel; pass `priority: 'last'` to add it below the
+   * others. Returns the rule id.
+   */
+  addConditionalFormat(rule, options = {}) {
+    const id = rule.id || this.generateRuleId("cf");
+    const stored = { ...rule, id, ranges: rule.ranges.map((r) => normalizeRange(r)) };
+    this.applyTableChange(() => {
+      const rules = [...this.table.conditionalFormats ?? []];
+      if (options.priority === "last") rules.push(stored);
+      else rules.unshift(stored);
+      this.table.conditionalFormats = rules;
+    });
+    return id;
+  }
+  /** Changes a conditional format (its condition, ranges or stop-if-true). Returns false when not found. */
+  updateConditionalFormat(id, changes) {
+    const rules = this.document.table?.conditionalFormats ?? [];
+    const index = rules.findIndex((r) => r.id === id);
+    if (index === -1) return false;
+    this.applyTableChange(() => {
+      const next = [...rules];
+      const updated = { ...rules[index], ...changes, id };
+      if (changes.ranges) updated.ranges = changes.ranges.map((r) => normalizeRange(r));
+      next[index] = updated;
+      this.table.conditionalFormats = next;
+    });
+    return true;
+  }
+  /** Removes a conditional format. Returns false when not found. */
+  deleteConditionalFormat(id) {
+    const rules = this.document.table?.conditionalFormats ?? [];
+    if (!rules.some((r) => r.id === id)) return false;
+    this.applyTableChange(() => {
+      this.table.conditionalFormats = rules.filter((r) => r.id !== id);
+    });
+    return true;
+  }
+  /**
+   * Moves a conditional format to priority `to` (0 = highest), or by
+   * `{ by: -1 }` (up) / `{ by: 1 }` (down). Returns false when nothing moved.
+   */
+  moveConditionalFormat(id, to) {
+    const rules = this.document.table?.conditionalFormats ?? [];
+    const from = rules.findIndex((r) => r.id === id);
+    if (from === -1) return false;
+    const target = Math.max(0, Math.min(rules.length - 1, typeof to === "number" ? to : from + to.by));
+    if (target === from) return false;
+    this.applyTableChange(() => {
+      const next = [...rules];
+      const [moved] = next.splice(from, 1);
+      next.splice(target, 0, moved);
+      this.table.conditionalFormats = next;
+    });
+    return true;
+  }
+  /**
+   * Removes conditional formatting from the cells of `range` (rules keep
+   * their other cells; rules left without cells are deleted), or every rule
+   * when `range` is null.
+   */
+  clearConditionalFormats(range = null) {
+    const rules = this.document.table?.conditionalFormats ?? [];
+    if (rules.length === 0) return;
+    this.applyTableChange(() => {
+      this.table.conditionalFormats = range ? rules.map((rule) => ({ ...rule, ranges: subtractRangeFromRanges(rule.ranges, range) })).filter((rule) => rule.ranges.length > 0) : [];
+    });
+  }
+  /**
+   * The conditional look of every formatted cell. Evaluated on demand and
+   * cached: after a cell edit only the affected cells are re-evaluated.
+   */
+  getConditionalFormatOverlay() {
+    const rules = this.document.table?.conditionalFormats ?? [];
+    if (rules.length === 0) {
+      this.cfEngine = null;
+      this.cfDirty = "all";
+      return EMPTY_CONDITIONAL_FORMAT_OVERLAY;
+    }
+    const sheet = this.ruleSheet();
+    if (!this.cfEngine || this.cfDirty === "all") {
+      this.cfEngine = new ConditionalFormatEngine(sheet);
+      this.cfEngine.evaluate(rules);
+    } else if (this.cfDirty.size > 0) {
+      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) });
+      }
+      this.cfEngine.setSheet(sheet);
+      this.cfEngine.update(rules, changed);
+    }
+    this.cfDirty = /* @__PURE__ */ new Set();
+    return this.cfEngine.overlay;
+  }
+  /** The conditional look of (row, col), if any. */
+  getConditionalFormat(row, col) {
+    return this.getConditionalFormatOverlay().get(row, col);
+  }
+  /** Data validation rules of the sheet. */
+  getDataValidations() {
+    return this.document.table?.dataValidations ?? [];
+  }
+  /** The rule that applies to (row, col), if any. */
+  getDataValidationAt(row, col) {
+    return findDataValidation(this.document.table?.dataValidations, row, col);
+  }
+  /**
+   * Adds a data validation rule (one undo step). Its cells are first
+   * removed from other rules, so each cell has at most one. Returns the id.
+   */
+  addDataValidation(rule) {
+    const id = rule.id || this.generateRuleId("dv");
+    const ranges = rule.ranges.map((r) => normalizeRange(r));
+    this.applyTableChange(() => {
+      let rules = this.table.dataValidations ?? [];
+      for (const cut of ranges) {
+        rules = rules.map((r) => ({ ...r, ranges: subtractRangeFromRanges(r.ranges, cut) })).filter((r) => r.ranges.length > 0);
+      }
+      this.table.dataValidations = [...rules, { ...rule, id, ranges }];
+    });
+    return id;
+  }
+  /** Changes a data validation rule. Returns false when not found. */
+  updateDataValidation(id, changes) {
+    const rules = this.document.table?.dataValidations ?? [];
+    const index = rules.findIndex((r) => r.id === id);
+    if (index === -1) return false;
+    this.applyTableChange(() => {
+      const next = [...rules];
+      const updated = { ...rules[index], ...changes, id };
+      if (changes.ranges) updated.ranges = changes.ranges.map((r) => normalizeRange(r));
+      next[index] = updated;
+      this.table.dataValidations = next;
+    });
+    return true;
+  }
+  /** Removes a data validation rule. Returns false when not found. */
+  deleteDataValidation(id) {
+    const rules = this.document.table?.dataValidations ?? [];
+    if (!rules.some((r) => r.id === id)) return false;
+    this.applyTableChange(() => {
+      this.table.dataValidations = rules.filter((r) => r.id !== id);
+    });
+    return true;
+  }
+  /** Removes validation from the cells of `range`, or every rule when `range` is null. */
+  clearDataValidation(range = null) {
+    const rules = this.document.table?.dataValidations ?? [];
+    if (rules.length === 0) return;
+    this.applyTableChange(() => {
+      this.table.dataValidations = range ? rules.map((r) => ({ ...r, ranges: subtractRangeFromRanges(r.ranges, range) })).filter((r) => r.ranges.length > 0) : [];
+    });
+  }
+  /** Checks input for (row, col) against its data validation, without committing it. */
+  validateCellInput(row, col, raw) {
+    return validateCellInput(this.ruleSheet(), this.document.table?.dataValidations, row, col, raw);
+  }
+  /**
+   * Dropdown items of a list-validated cell, or null when the cell has no
+   * list rule (or its in-cell dropdown is off).
+   */
+  getValidationListValues(row, col) {
+    const rule = this.getDataValidationAt(row, col);
+    if (!rule || rule.type !== "list" || rule.inCellDropdown === false) return null;
+    return getValidationListValues(this.ruleSheet(), rule);
+  }
+  /** Cells whose current value breaks their validation rule. */
+  findInvalidCells() {
+    return findInvalidCells(this.ruleSheet(), this.document.table?.dataValidations);
+  }
+  /**
+   * Turns "circle invalid data" on or off. View state, not part of the
+   * document (not undoable, not saved); listeners are notified so the grid
+   * redraws.
+   */
+  setInvalidDataCircles(show) {
+    if (this.circlesShown === show) return;
+    this.circlesShown = show;
+    this.invalidCircles = null;
     this.onDocumentChange?.(this.document);
   }
+  /** Whether invalid cells are circled. */
+  getInvalidDataCircles() {
+    return this.circlesShown;
+  }
+  /** Whether (row, col) is circled as invalid (always false while circles are off). */
+  isInvalidDataCircled(row, col) {
+    if (!this.circlesShown) return false;
+    if (!this.invalidCircles) {
+      this.invalidCircles = new Set(this.findInvalidCells().map((c) => `${c.row}:${c.col}`));
+    }
+    return this.invalidCircles.has(`${row}:${col}`);
+  }
 };
 function stepInOrder(order, from, delta) {
   if (order.length === 0) return from;
@@ -2875,7 +5119,11 @@ function stepInOrder(order, from, delta) {
 }
 
 // src/spreadsheet/menu.ts
-function runSpreadsheetMenuItem(item, ask) {
+function runSpreadsheetMenuItem(item, ask, confirm) {
+  if (item.confirm) {
+    const confirmed = confirm ? confirm(item.confirm) : typeof window !== "undefined" && typeof window.confirm === "function" ? window.confirm(item.confirm) : true;
+    if (!confirmed) return false;
+  }
   if (!item.input) {
     item.run();
     return true;
@@ -3067,8 +5315,91 @@ function getSpreadsheetMenuItems(controller, cell) {
       run: () => controller.groupRowsBy(column.id)
     });
   }
+  items.push(...getRuleMenuItems(controller, selection));
   return items;
 }
+function getRuleMenuItems(controller, selection) {
+  const ranges = [selection];
+  const hasFormats = controller.getConditionalFormats().some((rule) => rule.ranges.some((r) => rangesIntersect(r, selection)));
+  const hasValidation = controller.getDataValidations().some((rule) => rule.ranges.some((r) => rangesIntersect(r, selection)));
+  const add = (input) => {
+    controller.addConditionalFormat(createConditionalFormatRule({ ...input, ranges }));
+  };
+  const circles = controller.getInvalidDataCircles();
+  return [
+    {
+      id: "conditional-format-manage",
+      label: "Conditional formatting\u2026",
+      separatorBefore: true,
+      panel: "conditionalFormatting",
+      run: () => {
+      }
+    },
+    {
+      id: "conditional-format-greater-than",
+      label: "Conditional formatting: Highlight cells greater than\u2026",
+      input: { label: "Highlight cells greater than", defaultValue: "0" },
+      run: (value) => {
+        if (value !== void 0 && value.trim() !== "") add({ kind: "greaterThan", value: value.trim() });
+      }
+    },
+    {
+      id: "conditional-format-duplicates",
+      label: "Conditional formatting: Highlight duplicate values",
+      run: () => add({ kind: "duplicate" })
+    },
+    {
+      id: "conditional-format-color-scale",
+      label: "Conditional formatting: Color scale",
+      run: () => add({ kind: "colorScale3" })
+    },
+    {
+      id: "conditional-format-data-bars",
+      label: "Conditional formatting: Data bars",
+      run: () => add({ kind: "dataBar" })
+    },
+    {
+      id: "conditional-format-icon-set",
+      label: "Conditional formatting: Icon set",
+      run: () => add({ kind: "iconSet", iconSet: "3Arrows" })
+    },
+    {
+      id: "conditional-format-clear",
+      label: "Clear conditional formatting from selection",
+      disabled: !hasFormats,
+      run: () => controller.clearConditionalFormats(selection)
+    },
+    {
+      id: "data-validation-manage",
+      label: "Data validation\u2026",
+      separatorBefore: true,
+      panel: "dataValidation",
+      run: () => {
+      }
+    },
+    {
+      id: "data-validation-list",
+      label: "Data validation: List of values\u2026",
+      input: { label: "Allowed values, separated by commas (or a range such as =$H$1:$H$5)", defaultValue: "" },
+      run: (value) => {
+        if (value === void 0 || value.trim() === "") return;
+        controller.addDataValidation({ ranges, type: "list", formula1: value.trim() });
+      }
+    },
+    {
+      id: "data-validation-clear",
+      label: "Clear data validation from selection",
+      disabled: !hasValidation,
+      run: () => controller.clearDataValidation(selection)
+    },
+    {
+      id: "data-validation-circles",
+      label: circles ? "Clear validation circles" : "Circle invalid data",
+      disabled: !circles && controller.getDataValidations().length === 0,
+      run: () => controller.setInvalidDataCircles(!circles)
+    }
+  ];
+}
 
 // src/spreadsheet/actions.ts
 var SPREADSHEET_TABLE_ACTIONS = [
@@ -3108,7 +5439,28 @@ var SPREADSHEET_TABLE_ACTIONS = [
   "exportToCsv",
   "importFromCsv",
   "copyToClipboardData",
-  "pasteClipboardData"
+  "pasteClipboardData",
+  // Conditional formatting and data validation
+  "getConditionalFormats",
+  "addConditionalFormat",
+  "updateConditionalFormat",
+  "deleteConditionalFormat",
+  "moveConditionalFormat",
+  "clearConditionalFormats",
+  "getConditionalFormatOverlay",
+  "getConditionalFormat",
+  "getDataValidations",
+  "getDataValidationAt",
+  "addDataValidation",
+  "updateDataValidation",
+  "deleteDataValidation",
+  "clearDataValidation",
+  "validateCellInput",
+  "getValidationListValues",
+  "findInvalidCells",
+  "setInvalidDataCircles",
+  "getInvalidDataCircles",
+  "isInvalidDataCircled"
 ];
 function bindSpreadsheetTableActions(controller) {
   const actions = {};
@@ -3156,13 +5508,106 @@ function registerSpreadsheetImportAdapters(registry) {
   return () => unregisters.forEach((unregister) => unregister());
 }
 async function importFileIntoSpreadsheet(controller, input, options) {
-  const { registry, startRow, startCol, ...rest } = options;
+  const { registry, startRow, startCol, sheet, ...rest } = options;
   const outcome = await registry.importFile(input, { ...rest, target: "spreadsheet" });
-  controller.importRows(outcome.result.rows, { startRow, startCol });
+  controller.importRows(outcome.result.rows, { startRow, startCol, sheet });
   return outcome;
 }
 
+// src/spreadsheet/sheet-tabs.ts
+function getSheetTabMenuItems(controller, sheetId, options = {}) {
+  const sheets = controller.getSheets();
+  const sheet = sheets.find((s) => s.id === sheetId);
+  if (!sheet) return [];
+  const guard = (fn) => () => {
+    try {
+      fn();
+    } catch (err) {
+      if (!options.onError) throw err;
+      options.onError(err?.message ?? String(err));
+    }
+  };
+  return [
+    {
+      id: "sheet-insert",
+      label: "Insert sheet",
+      run: guard(() => {
+        controller.addSheet({ index: sheet.index + 1 });
+      })
+    },
+    {
+      id: "sheet-rename",
+      label: "Rename\u2026",
+      input: { label: "Sheet name", defaultValue: sheet.name },
+      run: (name) => guard(() => {
+        const next = (name ?? "").trim();
+        if (next && next !== sheet.name) controller.renameSheet(sheetId, next);
+      })()
+    },
+    {
+      id: "sheet-duplicate",
+      label: "Duplicate",
+      run: guard(() => {
+        controller.duplicateSheet(sheetId);
+      })
+    },
+    {
+      id: "sheet-move-left",
+      label: "Move left",
+      disabled: sheet.index === 0,
+      separatorBefore: true,
+      run: () => {
+        controller.moveSheet(sheetId, sheet.index - 1);
+      }
+    },
+    {
+      id: "sheet-move-right",
+      label: "Move right",
+      disabled: sheet.index === sheets.length - 1,
+      run: () => {
+        controller.moveSheet(sheetId, sheet.index + 1);
+      }
+    },
+    {
+      id: "sheet-delete",
+      label: "Delete",
+      disabled: sheets.length <= 1,
+      separatorBefore: true,
+      confirm: `Delete the sheet "${sheet.name}"? Formulas that refer to it will show #REF!.`,
+      run: () => {
+        controller.deleteSheet(sheetId);
+      }
+    }
+  ];
+}
+function sheetDropIndex(fromIndex, targetIndex, dropAfter) {
+  let to = dropAfter ? targetIndex + 1 : targetIndex;
+  if (fromIndex < to) to--;
+  return to;
+}
+function getNameManagerRows(controller) {
+  return controller.getNames().map((n) => {
+    let value;
+    if (n.isLambda) {
+      value = "[LAMBDA]";
+    } else {
+      const result = controller.evaluateFormula(`=${n.name}`, n.sheetId ? { sheet: n.sheetId } : {});
+      value = result.array ? `{${result.array.rows}\xD7${result.array.cols} array}` : isFormulaError(result.value) ? String(result.value) : formatCellDisplay({ value: result.value });
+    }
+    return {
+      name: n.name,
+      refersTo: n.refersTo,
+      scopeLabel: n.sheetName ?? "Workbook",
+      ...n.sheetId ? { sheetId: n.sheetId } : {},
+      value,
+      ...n.comment ? { comment: n.comment } : {},
+      isLambda: n.isLambda
+    };
+  }).sort((a, b) => a.name.localeCompare(b.name) || a.scopeLabel.localeCompare(b.scopeLabel));
+}
+
 export {
+  extractNameDependencies,
   columnDependencyKey,
   extractCellDependencies,
   DependencyGraph,
@@ -3170,6 +5615,13 @@ export {
   mapFormulaReferences,
   offsetFormulaReferences,
   remapFormulaReferences,
+  sheetNameNeedsQuotes,
+  quoteSheetName,
+  formatSheetPrefix,
+  renameSheetInFormula,
+  deleteSheetInFormula,
+  renameNameInFormula,
+  formulaIdentifiers,
   getFormulaCaretContext,
   getFormulaHints,
   applyFormulaSuggestion,
@@ -3181,6 +5633,13 @@ export {
   formatCellDisplay,
   formatValueWithCode,
   DataSourceBinder,
+  MAX_SHEET_NAME_LENGTH,
+  MAX_DEFINED_NAME_LENGTH,
+  validateSheetName,
+  nextSheetName,
+  copySheetName,
+  validateDefinedName,
+  isLambdaDefinition,
   normalizeRange,
   rangeContains,
   rangesIntersect,
@@ -3201,6 +5660,47 @@ export {
   createSpreadsheetClipboardData,
   readSpreadsheetClipboard,
   rebaseClipboardRows,
+  adjustRangeForStructuralChange,
+  adjustRangesForStructuralChange,
+  subtractRange,
+  subtractRangeFromRanges,
+  rangesContain,
+  ruleAnchor,
+  ruleFormulaAt,
+  shiftRuleFormula,
+  forEachRangeCell,
+  formatRuleRanges,
+  parseRuleRanges,
+  CONDITIONAL_FORMAT_ICON_SETS,
+  conditionalFormatIconCount,
+  getConditionalFormatIcon,
+  conditionalFormatNumber,
+  blendConditionalFormatColors,
+  defaultIconThresholds,
+  EMPTY_CONDITIONAL_FORMAT_OVERLAY,
+  ConditionalFormatEngine,
+  matchesTimePeriod,
+  evaluateConditionalFormats,
+  describeConditionalFormat,
+  describeDataValidation,
+  CONDITIONAL_FORMAT_STYLE_PRESETS,
+  DEFAULT_CONDITIONAL_FORMAT_STYLE,
+  CONDITIONAL_FORMAT_PRESETS,
+  CONDITIONAL_FORMAT_TIME_PERIODS,
+  createConditionalFormatRule,
+  DATA_VALIDATION_TYPE_OPTIONS,
+  DATA_VALIDATION_OPERATOR_OPTIONS,
+  DATA_VALIDATION_ERROR_STYLE_OPTIONS,
+  conditionalFormatContrastColor,
+  getConditionalFormatCss,
+  getDataBarCss,
+  conditionalFormatStyleString,
+  DEFAULT_DATA_VALIDATION_MESSAGE,
+  DEFAULT_DATA_VALIDATION_TITLE,
+  findDataValidation,
+  getValidationListValues,
+  validateCellInput,
+  findInvalidCells,
   DEFAULT_ROW_HEIGHT,
   DEFAULT_COLUMN_WIDTH,
   getTableSections,
@@ -3218,6 +5718,9 @@ export {
   tsvImportAdapter,
   SPREADSHEET_IMPORT_ADAPTERS,
   registerSpreadsheetImportAdapters,
-  importFileIntoSpreadsheet
+  importFileIntoSpreadsheet,
+  getSheetTabMenuItems,
+  sheetDropIndex,
+  getNameManagerRows
 };
-//# sourceMappingURL=chunk-U5KWZU4X.js.map
+//# sourceMappingURL=chunk-RR7F5GUM.js.map