@ai-matrx/office 0.8.12 → 0.8.13

package/dist/collab-sheets-transform.js

@@ -6,12 +6,11 @@ var covered = (family, ...allow) => ({ kind: "covered", family, allow: ["subUnit
 var never = (reason) => ({ kind: "never-travels", reason });
 var barrier = (until, reason) => ({ kind: "barrier", until, reason });
 var FORMULA_RESULT = "formula engine output; every seat computes it (dropped at capture)";
-var FORMULA = "formula state; C5b rewrites references";
 var RESOURCE = "ranged resource keyed by id; C5c";
 var UNIVER_COMMENTS = "Univer's own thread-comment store; our comments anchor elsewhere (design \xA78)";
 var SHEET_MUTATIONS = {
   // ── covered (C5a) ────────────────────────────────────────────────────────────────────────────────
-  "sheet.mutation.set-range-values": covered("cell", "cellValue"),
+  "sheet.mutation.set-range-values": covered("cell", "cellValue", "refSheets", "derived"),
   "sheet.mutation.insert-row": covered("structure", "range", "rowInfo"),
   "sheet.mutation.remove-rows": covered("structure", "range"),
   "sheet.mutation.insert-col": covered("structure", "range", "colInfo"),
@@ -88,16 +87,16 @@ var SHEET_MUTATIONS = {
   "sheet.mutation.set-worksheet-protection": barrier("X", "permissions: not in C5a"),
   "sheet.mutation.delete-worksheet-protection": barrier("X", "permissions: not in C5a"),
   "sheet.mutation.set-worksheet-permission-points": barrier("X", "permissions: not in C5a"),
-  // ── barriers until C5b (formulas) ────────────────────────────────────────────────────────────────
-  "formula.mutation.set-defined-name": barrier("C5b", FORMULA),
-  "formula.mutation.remove-defined-name": barrier("C5b", FORMULA),
-  "formula.mutation.set-feature-calculation": barrier("C5b", FORMULA),
-  "formula.mutation.remove-feature-calculation": barrier("C5b", FORMULA),
-  "formula.mutation.set-other-formula": barrier("C5b", FORMULA),
-  "formula.mutation.remove-other-formula": barrier("C5b", FORMULA),
-  "formula.mutation.set-super-table": barrier("C5b", FORMULA),
-  "formula.mutation.remove-super-table": barrier("C5b", FORMULA),
-  "formula.mutation.set-super-table-option": barrier("C5b", FORMULA),
+  // ── formulas (C5b) ───────────────────────────────────────────────────────────────────────────────
+  "formula.mutation.set-defined-name": covered("defname", "id", "name", "formulaOrRefString", "formulaOrRefStringWithPrefix", "comment", "localSheetId", "hidden", "refSheets", "previousName", "derived"),
+  "formula.mutation.remove-defined-name": covered("defname", "id", "name"),
+  "formula.mutation.set-feature-calculation": barrier("X", "a plugin's registered calculation (feature id + dependency ranges); no transform yet"),
+  "formula.mutation.remove-feature-calculation": barrier("X", "a plugin's registered calculation; no transform yet"),
+  "formula.mutation.set-other-formula": barrier("C5c", "formulas owned by conditional formats and data validation travel with their rule"),
+  "formula.mutation.remove-other-formula": barrier("C5c", "formulas owned by conditional formats and data validation travel with their rule"),
+  "formula.mutation.set-super-table": barrier("C5c", "table names in structured references belong to tables (C5c)"),
+  "formula.mutation.remove-super-table": barrier("C5c", "table names in structured references belong to tables (C5c)"),
+  "formula.mutation.set-super-table-option": barrier("C5c", "table names in structured references belong to tables (C5c)"),
   // ── barriers until C5c (ranged resources) ────────────────────────────────────────────────────────
   "sheet.mutation.add-conditional-rule": barrier("C5c", RESOURCE),
   "sheet.mutation.set-conditional-rule": barrier("C5c", RESOURCE),
@@ -254,8 +253,237 @@ function transformAxis(x, y, side) {
   }
 }
 
+// src/collab/sheets/transform/formula.ts
+import { Direction, RANGE_TYPE, Rectangle, getIntersectRange } from "@univerjs/core";
+import { LexerTreeBuilder, deserializeRangeWithSheet, generateStringWithSequence, sequenceNodeType, serializeRangeToRefString } from "@univerjs/engine-formula";
+import {
+  EffectRefRangId,
+  handleIRemoveCol,
+  handleIRemoveRow,
+  handleInsertCol,
+  handleInsertRow,
+  handleMoveCols,
+  handleMoveRows,
+  runRefRangeMutations
+} from "@univerjs/sheets";
+var REF_ERROR = "#REF!";
+var FULL = 16383 * 64;
+var lexer = null;
+var lex = (body) => (lexer ??= new LexerTreeBuilder()).sequenceNodesBuilder(body);
+var isFormulaText = (f) => typeof f === "string" && f.length > 1 && f.startsWith("=");
+var IDENT = /^[A-Za-z_\\][A-Za-z0-9_.\\]*$/;
+var ERROR_TOKEN = /^(?:[^!]+!)?#(?:REF!|NAME\?|VALUE!|DIV\/0!|N\/A|NUM!|NULL!|SPILL!|CALC!)$/i;
+function parse(text) {
+  const prefix = text.startsWith("=") ? "=" : "";
+  const nodes = lex(text.slice(prefix.length));
+  if (!nodes) return "the formula lexer could not read the text";
+  for (const n of nodes) {
+    if (typeof n === "string") continue;
+    if (n.nodeType === sequenceNodeType.TABLE || n.nodeType === sequenceNodeType.FUNCTION && n.token.includes("[")) return "a structured table reference (tables are C5c)";
+    if (n.nodeType === sequenceNodeType.FUNCTION && !IDENT.test(n.token) && !ERROR_TOKEN.test(n.token))
+      return `the lexer read "${n.token}" as one name (an intersection or a reference it cannot split)`;
+    if (n.nodeType === sequenceNodeType.REFERENCE) {
+      const d = deserializeRangeWithSheet(n.token);
+      if (d.unitId) return "a reference into another workbook";
+    }
+  }
+  return { prefix, nodes };
+}
+function targetSheet(sheetName, ctx) {
+  if (!sheetName) return ctx.ownSheet;
+  const id = ctx.refSheets?.[sheetName];
+  if (id === void 0) return void 0;
+  return id ?? "";
+}
+function formulaBarrier(text, ctx) {
+  const p = parse(text);
+  if (typeof p === "string") return p;
+  for (const n of p.nodes) {
+    if (typeof n === "string" || n.nodeType !== sequenceNodeType.REFERENCE) continue;
+    const { sheetName } = deserializeRangeWithSheet(n.token);
+    if (targetSheet(sheetName, ctx) === void 0) return `sheet "${sheetName}" is not in refSheets (capture must call annotateRefSheets)`;
+  }
+  return null;
+}
+function referencedSheetNames(text) {
+  const p = parse(text);
+  if (typeof p === "string") return [];
+  const out = /* @__PURE__ */ new Set();
+  for (const n of p.nodes) if (typeof n !== "string" && n.nodeType === sequenceNodeType.REFERENCE) {
+    const { sheetName } = deserializeRangeWithSheet(n.token);
+    if (sheetName) out.add(sheetName);
+  }
+  return [...out];
+}
+var fullRowsRange = (start, count) => ({ startRow: start, endRow: start + count - 1, startColumn: 0, endColumn: FULL, rangeType: RANGE_TYPE.ROW });
+var fullColsRange = (start, count) => ({ startRow: 0, endRow: FULL, startColumn: start, endColumn: start + count - 1, rangeType: RANGE_TYPE.COLUMN });
+var startV = (v) => Number.isNaN(v) || v == null ? -Infinity : v;
+var endV = (v) => Number.isNaN(v) || v == null ? Infinity : v;
+function startEnd(r) {
+  return { ...r, startRow: startV(r.startRow), endRow: endV(r.endRow), startColumn: startV(r.startColumn), endColumn: endV(r.endColumn) };
+}
+function checkMoveEdge(origin, from) {
+  const startRow = startV(origin.startRow), endRow = endV(origin.endRow), startColumn = startV(origin.startColumn), endColumn = endV(origin.endColumn);
+  const fromStartRow = startV(from.startRow), fromEndRow = endV(from.endRow), fromStartColumn = startV(from.startColumn), fromEndColumn = endV(from.endColumn);
+  const rowsCover = () => origin.rangeType === RANGE_TYPE.COLUMN && from.rangeType === RANGE_TYPE.COLUMN || startRow >= fromStartRow && endRow <= fromEndRow;
+  const columnsCover = () => origin.rangeType === RANGE_TYPE.ROW && from.rangeType === RANGE_TYPE.ROW || startColumn >= fromStartColumn && endColumn <= fromEndColumn;
+  const allCover = () => origin.rangeType === RANGE_TYPE.ALL && from.rangeType === RANGE_TYPE.ALL;
+  if (rowsCover() && columnsCover() || allCover()) return 4;
+  if (columnsCover() && startRow >= fromStartRow && startRow <= fromEndRow && endRow > fromEndRow) return 0;
+  if (columnsCover() && endRow >= fromStartRow && endRow <= fromEndRow && startRow < fromStartRow) return 1;
+  if (rowsCover() && startColumn >= fromStartColumn && startColumn <= fromEndColumn && endColumn > fromEndColumn) return 2;
+  if (rowsCover() && endColumn >= fromStartColumn && endColumn <= fromEndColumn && startColumn < fromStartColumn) return 3;
+  return null;
+}
+function getMoveNewRange(moveEdge, result, from, to, origin, remain) {
+  const { startRow, endRow, startColumn, endColumn, rangeType } = startEnd(result);
+  const f = startEnd(from);
+  const fromRangeType = from.rangeType ?? RANGE_TYPE.NORMAL;
+  const t = startEnd(to);
+  const rm = startEnd(remain);
+  const o = startEnd(origin);
+  const originRangeType = origin.rangeType ?? RANGE_TYPE.NORMAL;
+  const newRange = { ...origin };
+  const rowsCover = () => rangeType === RANGE_TYPE.COLUMN && originRangeType === RANGE_TYPE.COLUMN || startColumn >= o.startColumn && endColumn <= o.endColumn;
+  const columnsCover = () => rangeType === RANGE_TYPE.ROW && originRangeType === RANGE_TYPE.ROW || startRow >= o.startRow && endRow <= o.endRow;
+  if (moveEdge === 0) {
+    if (!rowsCover()) return void 0;
+    if (startRow < o.startRow) newRange.startRow = startRow;
+    else if (startRow >= o.endRow) newRange.endRow -= f.endRow + 1 - o.startRow;
+    else return void 0;
+  } else if (moveEdge === 1) {
+    if (!rowsCover()) return void 0;
+    if (endRow > o.endRow) newRange.endRow = endRow;
+    else if (endRow <= o.startRow) newRange.startRow += o.endRow - f.startRow + 1;
+    else return void 0;
+  } else if (moveEdge === 2) {
+    if (!columnsCover()) return void 0;
+    if (startColumn < o.startColumn) newRange.startColumn = startColumn;
+    else if (startColumn >= o.endColumn) newRange.endColumn -= f.endColumn + 1 - o.startColumn;
+    else return void 0;
+  } else if (moveEdge === 3) {
+    if (!columnsCover()) return void 0;
+    if (endColumn > o.endColumn) newRange.endColumn = endColumn;
+    else if (endColumn <= o.startColumn) newRange.startColumn += o.endColumn - f.startColumn + 1;
+    else return void 0;
+  } else if (moveEdge === 4) {
+    Object.assign(newRange, { startRow, startColumn, endRow, endColumn });
+  } else if (f.startColumn <= o.startColumn && f.endColumn >= o.endColumn || fromRangeType === RANGE_TYPE.ROW && originRangeType === RANGE_TYPE.ROW) {
+    const n = f.endRow - f.startRow + 1;
+    if (from.endRow < o.startRow) {
+      if (t.startRow >= o.startRow) newRange.startRow -= n;
+      if (t.startRow >= o.endRow) newRange.endRow -= n;
+    } else if (from.startRow > o.endRow) {
+      if (t.endRow <= o.endRow) newRange.endRow += n;
+      if (t.endRow <= o.startRow) newRange.startRow += n;
+    } else if (from.startRow >= o.startRow && from.endRow <= o.endRow) {
+      if (t.startRow <= o.startRow) newRange.startRow += n;
+      else if (t.startRow >= o.endRow) newRange.endRow -= n;
+    }
+  } else if (f.startRow <= o.startRow && f.endRow >= o.endRow || fromRangeType === RANGE_TYPE.COLUMN && originRangeType === RANGE_TYPE.COLUMN) {
+    const n = f.endColumn - f.startColumn + 1;
+    if (from.endColumn < o.startColumn) {
+      if (t.startColumn >= o.startColumn) newRange.startColumn -= n;
+      if (t.startColumn >= o.endColumn) newRange.endColumn -= n;
+    } else if (from.startColumn > o.endColumn) {
+      if (t.endColumn <= o.endColumn) newRange.endColumn += n;
+      if (t.endColumn <= o.startColumn) newRange.startColumn += n;
+    } else if (from.startColumn >= o.startColumn && from.endColumn <= o.endColumn) {
+      if (t.startColumn <= o.startColumn) newRange.startColumn += n;
+      else if (t.startColumn >= o.endColumn) newRange.endColumn -= n;
+    }
+  } else {
+    Object.assign(newRange, { startRow, startColumn, endRow, endColumn });
+    void rm;
+  }
+  return newRange;
+}
+function moveRange(range, axis, op) {
+  const isRow = axis === "row";
+  if (op.kind === "insert") {
+    const r = isRow ? fullRowsRange(op.at, op.count) : fullColsRange(op.at, op.count);
+    const ops2 = isRow ? handleInsertRow({ id: EffectRefRangId.InsertRowCommandId, params: { range: r, unitId: "", subUnitId: "", direction: Direction.DOWN } }, range) : handleInsertCol({ id: EffectRefRangId.InsertColCommandId, params: { range: r, unitId: "", subUnitId: "", direction: Direction.RIGHT } }, range);
+    const res2 = runRefRangeMutations(ops2, range);
+    return res2 == null ? void 0 : { ...range, ...res2 };
+  }
+  if (op.kind === "remove") {
+    const r = isRow ? fullRowsRange(op.start, op.count) : fullColsRange(op.start, op.count);
+    const ops2 = isRow ? handleIRemoveRow({ id: EffectRefRangId.RemoveRowCommandId, params: { range: r } }, range, []) : handleIRemoveCol({ id: EffectRefRangId.RemoveColCommandId, params: { range: r } }, range);
+    const res2 = runRefRangeMutations(ops2, range);
+    return res2 == null ? REF_ERROR : { ...range, ...res2 };
+  }
+  const from = isRow ? fullRowsRange(op.from, op.count) : fullColsRange(op.from, op.count);
+  const to = isRow ? fullRowsRange(op.to, op.count) : fullColsRange(op.to, op.count);
+  const moveEdge = checkMoveEdge(range, from);
+  let remain = getIntersectRange(range, from);
+  if (isRow) {
+    if (remain == null && (from.endRow < range.startRow && to.endRow <= range.startRow || from.startRow > range.endRow && to.startRow > range.endRow)) return void 0;
+  } else if (remain == null && (from.endColumn < range.startColumn && to.endColumn <= range.startColumn || from.startColumn > range.endColumn && to.startColumn > range.endColumn)) return void 0;
+  remain ??= { startRow: range.startRow, endRow: range.endRow, startColumn: range.startColumn, endColumn: range.endColumn, rangeType: RANGE_TYPE.NORMAL };
+  const ops = isRow ? handleMoveRows({ id: EffectRefRangId.MoveRowsCommandId, params: { toRange: to, fromRange: from } }, remain) : handleMoveCols({ id: EffectRefRangId.MoveColsCommandId, params: { toRange: to, fromRange: from } }, remain);
+  const res = runRefRangeMutations(ops, remain);
+  if (res == null) return REF_ERROR;
+  return getMoveNewRange(moveEdge, res, from, to, range, remain);
+}
+function rewriteFormula(text, ctx, change) {
+  const p = parse(text);
+  if (typeof p === "string") return p;
+  const nodes = p.nodes.slice();
+  const changedIds = [];
+  for (let i = 0; i < nodes.length; i++) {
+    const n = nodes[i];
+    if (typeof n === "string") continue;
+    if (change.kind === "defined-name") {
+      if ((n.nodeType === sequenceNodeType.DEFINED_NAME || n.nodeType === sequenceNodeType.FUNCTION) && n.token === change.from) {
+        nodes[i] = { ...n, token: change.to ?? REF_ERROR };
+        changedIds.push(i);
+      }
+      continue;
+    }
+    if (n.nodeType !== sequenceNodeType.REFERENCE) continue;
+    const { range, sheetName, unitId } = deserializeRangeWithSheet(n.token);
+    const target = targetSheet(sheetName, ctx);
+    if (target === void 0) return `sheet "${sheetName}" is not in refSheets (capture must call annotateRefSheets)`;
+    if (target !== change.sheet) continue;
+    let token;
+    if (change.kind === "rename") {
+      if (!sheetName) continue;
+      token = serializeRangeToRefString({ range, sheetName: change.name, unitId });
+    } else {
+      const moved = moveRange(Rectangle.moveOffset(range, 0, 0), change.axis, change.op);
+      if (moved === void 0) continue;
+      token = moved === REF_ERROR ? REF_ERROR : serializeRangeToRefString({ range: moved, sheetName: target === ctx.ownSheet && !ctx.keepQualifier ? "" : sheetName, unitId });
+    }
+    nodes[i] = { ...n, token };
+    changedIds.push(i);
+  }
+  if (!changedIds.length) return { text, changed: false };
+  for (let i = 0; i < nodes.length; i++) {
+    const n = nodes[i];
+    if (typeof n === "string" || n.nodeType !== sequenceNodeType.REFERENCE || changedIds.includes(i)) continue;
+    nodes[i] = { ...n, token: serializeRangeToRefString(deserializeRangeWithSheet(n.token)) };
+  }
+  const out = p.prefix + generateStringWithSequence(nodes);
+  return { text: out, changed: out !== text };
+}
+function refSheetsAfter(refSheets, change) {
+  if (change.kind !== "rename" || !refSheets) return refSheets;
+  const entries = Object.entries(refSheets);
+  if (!entries.some(([name, id]) => id === change.sheet || name === change.name)) return refSheets;
+  const next = {};
+  for (const [name, id] of entries) if (id !== change.sheet && name !== change.name) next[name] = id;
+  next[change.name] = change.sheet;
+  return next;
+}
+function refSheetsFor(texts, sheets) {
+  const byName = new Map(Object.entries(sheets).map(([id, name]) => [name, id]));
+  const out = {};
+  for (const t of texts) for (const name of referencedSheetNames(t)) out[name] = byName.get(name) ?? null;
+  return Object.keys(out).length ? out : void 0;
+}
+
 // src/collab/sheets/transform/transform.ts
-var SHEET_TRANSFORMER_VERSION = "c5a-1";
+var SHEET_TRANSFORMER_VERSION = "c5b-1";
 var ID = {
   values: "sheet.mutation.set-range-values",
   insertRow: "sheet.mutation.insert-row",
@@ -270,7 +498,9 @@ var ID = {
   rowIsAuto: "sheet.mutation.set-worksheet-row-is-auto-height",
   rowAutoHeight: "sheet.mutation.set-worksheet-row-auto-height",
   colWidth: "sheet.mutation.set-worksheet-col-width",
-  name: "sheet.mutation.set-worksheet-name"
+  name: "sheet.mutation.set-worksheet-name",
+  setName: "formula.mutation.set-defined-name",
+  removeName: "formula.mutation.remove-defined-name"
 };
 var PAIR_BARRIERS = {};
 var pairKey = (a, b) => a < b ? `${a}|${b}` : `${b}|${a}`;
@@ -335,9 +565,9 @@ function buildStructural(template, axis, op) {
   return { id: template.id, params: { ...p, range: { ...p.range, [a0]: start, [a1]: start + op.count - 1 } } };
 }
 function univerMutationInfo(axis, op) {
-  const FULL = { startRow: 0, endRow: Number.MAX_SAFE_INTEGER, startColumn: 0, endColumn: Number.MAX_SAFE_INTEGER };
+  const FULL2 = { startRow: 0, endRow: Number.MAX_SAFE_INTEGER, startColumn: 0, endColumn: Number.MAX_SAFE_INTEGER };
   const start = op.kind === "insert" ? op.at : op.start;
-  const range = axis === "row" ? { ...FULL, startRow: start, endRow: start + op.count - 1 } : { ...FULL, startColumn: start, endColumn: start + op.count - 1 };
+  const range = axis === "row" ? { ...FULL2, startRow: start, endRow: start + op.count - 1 } : { ...FULL2, startColumn: start, endColumn: start + op.count - 1 };
   const id = op.kind === "insert" ? axis === "row" ? ID.insertRow : ID.insertCol : axis === "row" ? ID.removeRows : ID.removeCol;
   return { id, params: { unitId: "", subUnitId: "", range } };
 }
@@ -404,8 +634,8 @@ function exactMergeRemovals(group, merges) {
 var mergeRanges = (m) => m.params.ranges ?? [];
 var withRanges = (m, ranges) => ({ id: m.id, params: { ...m.params, ranges } });
 var mergeMutation = (id, sheet, ranges) => ({ id, params: { subUnitId: sheet, ranges } });
-var CONTENT_KEYS = ["v", "t", "p", "f", "si", "custom"];
-var CONTENT_TOUCH = ["v", "p", "f", "si", "custom"];
+var CONTENT_KEYS = ["v", "t", "p", "f", "si", "custom", "ref", "xf", "ft", "fd"];
+var CONTENT_TOUCH = ["v", "p", "f", "si", "custom", "ref", "xf", "ft", "fd"];
 var KNOWN_CELL_KEYS = /* @__PURE__ */ new Set([...CONTENT_KEYS, "s"]);
 function completeCellContent(entry, post) {
   if (entry === null) return null;
@@ -435,8 +665,10 @@ function cellBarrier(m) {
   forEachCell(cellsOf(m), (_r, _c, v) => {
     if (why || v === null) return;
     for (const k of Object.keys(v)) {
+      if (why) break;
       if (!KNOWN_CELL_KEYS.has(k)) why = `cell key "${k}" is not covered`;
-      else if ((k === "f" || k === "si") && v[k] != null) why = "formula content (f/si) belongs to C5b";
+      else if (k === "si" && v.si != null) why = "shared formula (si): its text lives in a master cell this op does not carry";
+      else if (k === "f" && isFormulaText(v.f) || k === "ref" && typeof v.ref === "string") why = formulaBarrier(v[k], formulaCtx(m));
     }
     if (typeof v.s === "string") why = "a style id travels (style ids are seat-local; capture must send the style object)";
     if (!why && CONTENT_TOUCH.some((k) => k in v) && !CONTENT_KEYS.every((k) => k in v || k === "t" && v.v == null))
@@ -509,6 +741,9 @@ function transformCell(X, Y, side) {
 function transformCellsOverCells(x, y, side) {
   if (sheetOf(x) !== sheetOf(y)) return ok([x]);
   const ycells = cellsOf(y);
+  const xd = isDerived(x);
+  const yd = isDerived(y);
+  const eff = derivedSide(x, y, side);
   const passes = [{}];
   const lost = [];
   const dropped = [];
@@ -520,29 +755,218 @@ function transformCellsOverCells(x, y, side) {
       putCell(passes[0], r, c, X);
       return;
     }
-    const res = transformCell(X, yRow[c] ?? null, side);
+    const res = transformCell(X, yRow[c] ?? null, eff);
     if (typeof res === "string") {
       why = res;
       return;
     }
     res.entries.forEach((e, i) => putCell(passes[i] ??= {}, r, c, e));
-    if (res.xLost) dropped.push(cellRef(sheetOf(x), r, c));
-    if (res.yLost) lost.push(cellRef(sheetOf(x), r, c));
+    if (res.xLost && !xd) dropped.push(cellRef(sheetOf(x), r, c));
+    if (res.yLost && !yd) lost.push(cellRef(sheetOf(x), r, c));
   });
   if (why) return barrier2(why);
   const op = passes.filter((p) => !isEmptyMatrix(p)).map((p) => cellsMutation(x, p));
   return ok(op, lost, dropped);
 }
-function transformCellsOverStructural(x, s) {
+var SIDE_CAR_PARAMS = ["refSheets", "previousName", "derived"];
+var isDerived = (m) => m.params.derived === true;
+function derivedSide(x, y, side) {
+  const xd = isDerived(x);
+  const yd = isDerived(y);
+  return xd === yd ? side : xd ? "right" : "left";
+}
+function forApply(m) {
+  if (!SIDE_CAR_PARAMS.some((k) => k in m.params)) return m;
+  const params = { ...m.params };
+  for (const k of SIDE_CAR_PARAMS) delete params[k];
+  return { id: m.id, params };
+}
+var refSheetsOf = (m) => m.params.refSheets;
+var formulaCtx = (m) => ({ ownSheet: sheetOf(m), refSheets: refSheetsOf(m) });
+function withRefSheets(params, rs) {
+  const out = { ...params };
+  if (rs) out.refSheets = rs;
+  else delete out.refSheets;
+  return out;
+}
+var hasFormulaText = (v) => !!v && (isFormulaText(v.f) || typeof v.ref === "string");
+function hasFormula(m) {
+  let any = false;
+  forEachCell(cellsOf(m), (_r, _c, v) => {
+    any ||= hasFormulaText(v);
+  });
+  return any;
+}
+var setNameWithoutPrevious = (m) => m.id === ID.setName && !("previousName" in m.params);
+function refChangeOf(m) {
+  const st = structuralOf(m);
+  if (st) return { kind: "axis", sheet: sheetOf(m), axis: st.axis, op: st.op };
+  if (m.id === ID.name) return { kind: "rename", sheet: sheetOf(m), name: String(m.params.name) };
+  if (m.id === ID.removeName) return { kind: "defined-name", from: String(m.params.name), to: null };
+  if (m.id === ID.setName && typeof m.params.previousName === "string" && m.params.previousName !== m.params.name)
+    return { kind: "defined-name", from: m.params.previousName, to: String(m.params.name) };
+  return null;
+}
+function rewriteEntry(v, ctx, change) {
+  let entry = v;
+  let changed = false;
+  for (const k of ["f", "ref"]) {
+    const t = v[k];
+    if (k === "f" ? !isFormulaText(t) : typeof t !== "string") continue;
+    const r = rewriteFormula(t, ctx, change);
+    if (typeof r === "string") return r;
+    if (!r.changed) continue;
+    if (k === "ref" && r.text.includes(REF_ERROR)) return "an array formula's range was removed under it";
+    entry = { ...entry, [k]: r.text };
+    changed = true;
+  }
+  return { entry, changed };
+}
+function cellThrough(sheet, change, r, c) {
+  if (change.kind !== "axis" || change.sheet !== sheet) return [r, c];
+  const nr = change.axis === "row" ? mapIndex(change.op, r) : r;
+  const nc = change.axis === "col" ? mapIndex(change.op, c) : c;
+  return nr === null || nc === null ? null : [nr, nc];
+}
+function cellsOverChange(x, change) {
+  const ctx = formulaCtx(x);
   const out = {};
   const dropped = [];
+  let why = null;
   forEachCell(cellsOf(x), (r, c, v) => {
-    const nr = s.axis === "row" ? mapIndex(s.op, r) : r;
-    const nc = s.axis === "col" ? mapIndex(s.op, c) : c;
-    if (nr === null || nc === null) dropped.push(cellRef(sheetOf(x), r, c));
-    else putCell(out, nr, nc, v);
+    if (why) return;
+    const at = cellThrough(sheetOf(x), change, r, c);
+    if (!at) {
+      dropped.push(cellRef(sheetOf(x), r, c));
+      return;
+    }
+    let e = v;
+    if (hasFormulaText(v)) {
+      const res = rewriteEntry(v, ctx, change);
+      if (typeof res === "string") {
+        why = res;
+        return;
+      }
+      e = res.entry;
+    }
+    putCell(out, at[0], at[1], e);
+  });
+  if (why) return barrier2(why);
+  const params = { ...withRefSheets(x.params, refSheetsAfter(ctx.refSheets, change)), cellValue: out };
+  return ok(isEmptyMatrix(out) ? [] : [{ id: x.id, params }], [], dropped);
+}
+function rewritesOf(y, change) {
+  const ctx = formulaCtx(y);
+  const out = {};
+  let why = null;
+  forEachCell(cellsOf(y), (r, c, v) => {
+    if (why || !hasFormulaText(v)) return;
+    const at = cellThrough(sheetOf(y), change, r, c);
+    if (!at) return;
+    const res = rewriteEntry(v, ctx, change);
+    if (typeof res === "string") {
+      why = res;
+      return;
+    }
+    if (res.changed) putCell(out, at[0], at[1], contentOf(res.entry));
+  });
+  if (why) return why;
+  if (isEmptyMatrix(out)) return null;
+  return { id: ID.values, params: withRefSheets({ subUnitId: sheetOf(y), cellValue: out, derived: true }, refSheetsAfter(ctx.refSheets, change)) };
+}
+var NAME_TEXT_KEYS = ["formulaOrRefString", "formulaOrRefStringWithPrefix"];
+function definedNameThrough(m, change) {
+  if (change.kind === "defined-name" || m.id !== ID.setName) return { op: m, changed: false };
+  const ctx = { ownSheet: change.sheet, refSheets: refSheetsOf(m), keepQualifier: true };
+  const params = { ...m.params };
+  let changed = false;
+  for (const k of NAME_TEXT_KEYS) {
+    if (typeof params[k] !== "string" || !params[k]) continue;
+    const r = rewriteFormula(params[k], ctx, change);
+    if (typeof r === "string") return r;
+    if (r.changed) {
+      params[k] = r.text;
+      changed = true;
+    }
+  }
+  return { op: { id: m.id, params: withRefSheets(params, refSheetsAfter(ctx.refSheets, change)) }, changed };
+}
+function asDerived(m) {
+  return { id: m.id, params: { ...m.params, derived: true } };
+}
+function formulaPair(x, y, side) {
+  const fx = familyOf(x.id);
+  const fy = familyOf(y.id);
+  const SET_NAME_BARRIER = "set-defined-name without previousName (capture must record the name it replaces) against formula text";
+  if (fx === "defname" && fy === "defname") {
+    if (String(x.params.id) !== String(y.params.id)) return ok([x]);
+    const eff = derivedSide(x, y, side);
+    if (eff === "left") return ok([x], isDerived(y) ? [] : [`defined name "${String(y.params.name)}"`]);
+    return ok([], [], isDerived(x) ? [] : [`defined name "${String(x.params.name)}"`]);
+  }
+  if (fx === "defname") {
+    if (fy === "cell") {
+      if (setNameWithoutPrevious(x) && hasFormula(y)) return barrier2(SET_NAME_BARRIER);
+      const ch2 = refChangeOf(x);
+      if (!ch2) return ok([x]);
+      const add = rewritesOf(y, ch2);
+      if (typeof add === "string") return barrier2(add);
+      return ok(add ? [x, add] : [x]);
+    }
+    const ch = refChangeOf(y);
+    if (!ch) return ok([x]);
+    const r = definedNameThrough(x, ch);
+    return typeof r === "string" ? barrier2(r) : ok([r.op]);
+  }
+  if (fy === "defname") {
+    if (fx === "cell") {
+      if (setNameWithoutPrevious(y) && hasFormula(x)) return barrier2(SET_NAME_BARRIER);
+      const ch2 = refChangeOf(y);
+      return ch2 ? cellsOverChange(x, ch2) : ok([x]);
+    }
+    const ch = refChangeOf(x);
+    if (!ch) return ok([x]);
+    const r = definedNameThrough(y, ch);
+    if (typeof r === "string") return barrier2(r);
+    return ok(r.changed ? [x, asDerived(r.op)] : [x]);
+  }
+  if (fx === "cell") {
+    const ch = refChangeOf(y);
+    return ch ? cellsOverChange(x, ch) : null;
+  }
+  if (fy === "cell") {
+    const ch = refChangeOf(x);
+    if (!ch) return null;
+    const lost = [];
+    forEachCell(cellsOf(y), (r, c) => {
+      if (!cellThrough(sheetOf(y), ch, r, c)) lost.push(cellRef(sheetOf(y), r, c));
+    });
+    const add = rewritesOf(y, ch);
+    if (typeof add === "string") return barrier2(add);
+    return ok(add ? [x, add] : [x], lost);
+  }
+  return null;
+}
+var withPrevious = (m, definedNames) => m.id === ID.setName && !("previousName" in m.params) ? { id: m.id, params: { ...m.params, previousName: definedNames[String(m.params.id)] ?? null } } : m;
+function annotateFormulas(group, sheets, definedNames) {
+  let changed = false;
+  return group.map((m0) => {
+    const m = changed && (m0.id === ID.values || m0.id === ID.setName) ? asDerived(m0) : m0;
+    if (!changed && refChangeOf(withPrevious(m0, definedNames))) changed = true;
+    if (m.id === ID.values) {
+      const texts = [];
+      forEachCell(cellsOf(m), (_r, _c, v) => {
+        if (v && isFormulaText(v.f)) texts.push(v.f);
+        if (v && typeof v.ref === "string") texts.push(v.ref);
+      });
+      return { id: m.id, params: withRefSheets(m.params, refSheetsFor(texts, sheets)) };
+    }
+    if (m.id === ID.setName) {
+      const texts = NAME_TEXT_KEYS.map((k) => m.params[k]).filter((t) => typeof t === "string");
+      return { id: m.id, params: { ...withRefSheets(m.params, refSheetsFor(texts, sheets)), previousName: withPrevious(m, definedNames).params.previousName } };
+    }
+    return m;
   });
-  return ok(isEmptyMatrix(out) ? [] : [cellsMutation(x, out)], [], dropped);
 }
 function sizeOf(m) {
   const p = m.params;
@@ -593,6 +1017,8 @@ function transformMutation(x, y, side) {
   }
   const pb = PAIR_BARRIERS[pairKey(x.id, y.id)];
   if (pb) return barrier2(`${x.id} \xD7 ${y.id}: ${pb.reason}${pb.seed === null ? "" : ` (fuzz seed ${pb.seed})`}`);
+  const fp = formulaPair(x, y, side);
+  if (fp) return fp;
   if (sheetOf(x) !== sheetOf(y)) return ok([x]);
   const fx = familyOf(x.id);
   const fy = familyOf(y.id);
@@ -606,7 +1032,6 @@ function transformMutation(x, y, side) {
     return ok(out.map((o) => buildStructural(x, sx.axis, o)), [], dropped);
   }
   if (sy) {
-    if (fx === "cell") return transformCellsOverStructural(x, sy);
     if (fx === "merge") {
       const kept = [];
       const dropped = [];
@@ -631,13 +1056,6 @@ function transformMutation(x, y, side) {
     return ok([x]);
   }
   if (sx) {
-    if (fy === "cell") {
-      const lost = [];
-      forEachCell(cellsOf(y), (r, c) => {
-        if ((sx.axis === "row" ? mapIndex(sx.op, r) : mapIndex(sx.op, c)) === null) lost.push(cellRef(sheetOf(y), r, c));
-      });
-      return ok([x], lost);
-    }
     if (fy !== "merge" || y.id !== ID.addMerge) return ok([x]);
     const remove = [];
     const add = [];
@@ -749,15 +1167,24 @@ var sheetTransformer = {
 export {
   CONTENT_KEYS,
   PAIR_BARRIERS,
+  REF_ERROR,
   SHEET_MUTATIONS,
   SHEET_TRANSFORMER_VERSION,
+  SIDE_CAR_PARAMS,
   allowParams,
+  annotateFormulas,
   cellRef,
   completeCellContent,
   exactMergeRemovals,
+  forApply,
+  formulaBarrier,
   isBarrier,
+  isFormulaText,
   mapIndex,
   mergeThrough,
+  refSheetsAfter,
+  refSheetsFor,
+  rewriteFormula,
   sheetTransformer,
   transformAxis,
   transformGroup,