@ai-matrx/office 0.8.20 → 0.8.22

package/dist/collab-sheets-transform.js

@@ -24,6 +24,15 @@ var SHEET_MUTATIONS = {
   "sheet.mutation.set-worksheet-row-auto-height": covered("size", "rowsAutoHeightInfo"),
   "sheet.mutation.set-worksheet-col-width": covered("size", "ranges", "colWidth"),
   "sheet.mutation.set-worksheet-name": covered("name", "name"),
+  // ── covered (C5c) ────────────────────────────────────────────────────────────────────────────────
+  "sheet.mutation.set.numfmt": covered("numfmt", "values", "refMap"),
+  "sheet.mutation.remove.numfmt": covered("numfmt", "ranges"),
+  "sheet.mutation.set-worksheet-row-count": covered("count", "rowCount"),
+  "sheet.mutation.set-worksheet-column-count": covered("count", "columnCount"),
+  "sheet.mutation.insert-sheet": covered("sheet", "index", "sheet"),
+  "sheet.mutation.remove-sheet": covered("sheet", "sheetIndex", "sheetsLeft"),
+  "sheet.mutation.set-worksheet-order": covered("sheet", "fromOrder", "toOrder"),
+  "sheet.mutation.reorder-range": covered("sort", "range", "order"),
   // ── never travels ────────────────────────────────────────────────────────────────────────────────
   "formula.mutation.set-formula-calculation-start": never(FORMULA_RESULT),
   "formula.mutation.set-trigger-formula-calculation-start": never(FORMULA_RESULT),
@@ -57,13 +66,7 @@ var SHEET_MUTATIONS = {
   "thread-comment.mutation.resolve-comment": never(UNIVER_COMMENTS),
   "thread-comment.mutation.delete-comment": never(UNIVER_COMMENTS),
   // ── barriers: X (no transform yet, design §10) ───────────────────────────────────────────────────
-  "sheet.mutation.reorder-range": barrier("X", "sort: a permutation, not transformed yet"),
-  "sheet.mutation.set-worksheet-row-count": barrier("X", "absolute row count; needs delta semantics"),
-  "sheet.mutation.set-worksheet-column-count": barrier("X", "absolute column count; needs delta semantics"),
-  "sheet.mutation.set-worksheet-order": barrier("X", "absolute sheet order; needs move semantics"),
   "sheet.mutation.move-range": barrier("X", "cut-paste carries the sender's cell matrices"),
-  "sheet.mutation.insert-sheet": barrier("X", "sheet add: not in C5a"),
-  "sheet.mutation.remove-sheet": barrier("X", "sheet remove: not in C5a"),
   "sheet.mutation.set-worksheet-hidden": barrier("X", "sheet-level setting: not in C5a"),
   "sheet.mutation.set-tab-color": barrier("X", "sheet-level setting: not in C5a"),
   "sheet.mutation.set-workbook-name": barrier("X", "workbook-level setting: not in C5a"),
@@ -78,8 +81,6 @@ var SHEET_MUTATIONS = {
   "sheet.mutation.set-row-visible": barrier("X", "row visibility: not in C5a"),
   "sheet.mutation.set-col-hidden": barrier("X", "column visibility: not in C5a"),
   "sheet.mutation.set-col-visible": barrier("X", "column visibility: not in C5a"),
-  "sheet.mutation.set.numfmt": barrier("X", "number formats by range: not in C5a"),
-  "sheet.mutation.remove.numfmt": barrier("X", "number formats by range: not in C5a"),
   "sheet.mutation.add-range-protection": barrier("X", "permissions: not in C5a"),
   "sheet.mutation.set-range-protection": barrier("X", "permissions: not in C5a"),
   "sheet.mutation.delete-range-protection": barrier("X", "permissions: not in C5a"),
@@ -483,7 +484,7 @@ function refSheetsFor(texts, sheets) {
 }
 
 // src/collab/sheets/transform/transform.ts
-var SHEET_TRANSFORMER_VERSION = "c5b-1";
+var SHEET_TRANSFORMER_VERSION = "c5c-1";
 var ID = {
   values: "sheet.mutation.set-range-values",
   insertRow: "sheet.mutation.insert-row",
@@ -500,7 +501,15 @@ var ID = {
   colWidth: "sheet.mutation.set-worksheet-col-width",
   name: "sheet.mutation.set-worksheet-name",
   setName: "formula.mutation.set-defined-name",
-  removeName: "formula.mutation.remove-defined-name"
+  removeName: "formula.mutation.remove-defined-name",
+  setNumfmt: "sheet.mutation.set.numfmt",
+  removeNumfmt: "sheet.mutation.remove.numfmt",
+  rowCount: "sheet.mutation.set-worksheet-row-count",
+  colCount: "sheet.mutation.set-worksheet-column-count",
+  insertSheet: "sheet.mutation.insert-sheet",
+  removeSheet: "sheet.mutation.remove-sheet",
+  sheetOrder: "sheet.mutation.set-worksheet-order",
+  sort: "sheet.mutation.reorder-range"
 };
 var PAIR_BARRIERS = {};
 var pairKey = (a, b) => a < b ? `${a}|${b}` : `${b}|${a}`;
@@ -612,6 +621,20 @@ function mergeThrough(s, m) {
   }
   return { range: m, fixup: false };
 }
+function mergeFixupsOwed(m, mergesBefore) {
+  const st = structuralOf(m);
+  if (!st) return null;
+  const remove = [];
+  const add = [];
+  for (const q of mergesBefore) {
+    const t = mergeThrough(st, q);
+    if (!t.fixup) continue;
+    remove.push({ startRow: q.startRow, endRow: q.endRow, startColumn: q.startColumn, endColumn: q.endColumn, ...q.rangeType !== void 0 ? { rangeType: q.rangeType } : {} });
+    if (t.range) add.push({ ...t.range });
+  }
+  return remove.length ? { remove, add } : null;
+}
+var isStructuralMutation = (m) => structuralOf(m) !== null;
 function exactMergeRemovals(group, merges) {
   const sim = new Map(Object.entries(merges).map(([k, v]) => [k, v.map((r) => ({ ...r }))]));
   const out = [];
@@ -658,8 +681,24 @@ function cellsMutation(template, cells) {
 function putCell(cells, r, c, v) {
   (cells[r] ??= {})[c] = v;
 }
+function cellsOverlap(a, b) {
+  for (const r of Object.keys(a)) {
+    const br = b[r];
+    if (!br) continue;
+    for (const c of Object.keys(a[r] ?? {})) if (c in br) return true;
+  }
+  return false;
+}
 var isEmptyMatrix = (cells) => Object.values(cells).every((row) => Object.keys(row).length === 0);
+var cellBarrierCache = /* @__PURE__ */ new WeakMap();
 function cellBarrier(m) {
+  const hit = cellBarrierCache.get(m);
+  if (hit !== void 0) return hit;
+  const why = cellBarrierOf(m);
+  cellBarrierCache.set(m, why);
+  return why;
+}
+function cellBarrierOf(m) {
   if (m.params.isOverrideStyle) return "set-range-values with isOverrideStyle (whole-style replace) is not covered";
   let why = null;
   forEachCell(cellsOf(m), (_r, _c, v) => {
@@ -741,6 +780,7 @@ function transformCell(X, Y, side) {
 function transformCellsOverCells(x, y, side) {
   if (sheetOf(x) !== sheetOf(y)) return ok([x]);
   const ycells = cellsOf(y);
+  if (!cellsOverlap(cellsOf(x), ycells)) return ok([x]);
   const xd = isDerived(x);
   const yd = isDerived(y);
   const eff = derivedSide(x, y, side);
@@ -768,7 +808,7 @@ function transformCellsOverCells(x, y, side) {
   const op = passes.filter((p) => !isEmptyMatrix(p)).map((p) => cellsMutation(x, p));
   return ok(op, lost, dropped);
 }
-var SIDE_CAR_PARAMS = ["refSheets", "previousName", "derived"];
+var SIDE_CAR_PARAMS = ["refSheets", "previousName", "derived", "sheetIndex", "sheetsLeft"];
 var isDerived = (m) => m.params.derived === true;
 function derivedSide(x, y, side) {
   const xd = isDerived(x);
@@ -790,7 +830,15 @@ function withRefSheets(params, rs) {
   return out;
 }
 var hasFormulaText = (v) => !!v && (isFormulaText(v.f) || typeof v.ref === "string");
+var hasFormulaCache = /* @__PURE__ */ new WeakMap();
 function hasFormula(m) {
+  const hit = hasFormulaCache.get(m);
+  if (hit !== void 0) return hit;
+  const any = hasFormulaOf(m);
+  hasFormulaCache.set(m, any);
+  return any;
+}
+function hasFormulaOf(m) {
   let any = false;
   forEachCell(cellsOf(m), (_r, _c, v) => {
     any ||= hasFormulaText(v);
@@ -829,15 +877,18 @@ function cellThrough(sheet, change, r, c) {
   return nr === null || nc === null ? null : [nr, nc];
 }
 function cellsOverChange(x, change) {
+  if (!hasFormula(x) && (change.kind !== "axis" || change.sheet !== sheetOf(x))) return ok([x]);
   const ctx = formulaCtx(x);
   const out = {};
   const dropped = [];
   let why = null;
+  let changed = false;
   forEachCell(cellsOf(x), (r, c, v) => {
     if (why) return;
     const at = cellThrough(sheetOf(x), change, r, c);
     if (!at) {
       dropped.push(cellRef(sheetOf(x), r, c));
+      changed = true;
       return;
     }
     let e = v;
@@ -848,14 +899,19 @@ function cellsOverChange(x, change) {
         return;
       }
       e = res.entry;
+      if (res.changed) changed = true;
     }
+    if (at[0] !== r || at[1] !== c) changed = true;
     putCell(out, at[0], at[1], e);
   });
   if (why) return barrier2(why);
-  const params = { ...withRefSheets(x.params, refSheetsAfter(ctx.refSheets, change)), cellValue: out };
+  const rsAfter = refSheetsAfter(ctx.refSheets, change);
+  if (!changed && JSON.stringify(rsAfter ?? null) === JSON.stringify(ctx.refSheets ?? null)) return ok([x]);
+  const params = { ...withRefSheets(x.params, rsAfter), cellValue: out };
   return ok(isEmptyMatrix(out) ? [] : [{ id: x.id, params }], [], dropped);
 }
 function rewritesOf(y, change) {
+  if (!hasFormula(y)) return null;
   const ctx = formulaCtx(y);
   const out = {};
   let why = null;
@@ -1001,6 +1057,368 @@ function buildSize(template, values) {
   const value = uniform !== void 0 && [...values.values()].every((v) => v === uniform) ? uniform : Object.fromEntries(values);
   return { id: template.id, params: { ...p, ranges, [field]: value } };
 }
+var isNumfmt = (m) => m.id === ID.setNumfmt || m.id === ID.removeNumfmt;
+function nfParts(m) {
+  if (m.id === ID.removeNumfmt) return [{ key: null, ranges: (m.params.ranges ?? []).map((r) => ({ ...r })) }];
+  const values = m.params.values ?? {};
+  return Object.keys(values).map((k) => ({ key: k, ranges: (values[k]?.ranges ?? []).map((r) => ({ ...r })) }));
+}
+function nfBuild(m, parts) {
+  const keep = parts.filter((p) => p.ranges.length);
+  if (!keep.length) return [];
+  if (m.id === ID.removeNumfmt) return [{ id: m.id, params: { ...m.params, ranges: keep[0].ranges } }];
+  const values = {};
+  const refMap = {};
+  const srcValues = m.params.values ?? {};
+  const srcRef = m.params.refMap ?? {};
+  for (const p of keep) {
+    values[p.key] = { ...srcValues[p.key], ranges: p.ranges };
+    refMap[p.key] = srcRef[p.key];
+  }
+  return [{ id: m.id, params: { ...m.params, values, refMap } }];
+}
+function nfValueAt(m, row, col) {
+  for (const p of nfParts(m))
+    if (p.ranges.some((r) => r.startRow <= row && row <= r.endRow && r.startColumn <= col && col <= r.endColumn)) {
+      if (p.key === null) return null;
+      const ref = (m.params.refMap ?? {})[p.key];
+      return { pattern: ref?.pattern };
+    }
+  return void 0;
+}
+function spanThrough(op, lo, hi) {
+  const pieces = [];
+  if (op.kind === "insert") pieces.push([0, op.at - 1, 0], [op.at, Infinity, op.count]);
+  else if (op.kind === "remove") pieces.push([0, op.start - 1, 0], [op.start + op.count, Infinity, -op.count]);
+  else if (op.count <= 0 || op.to >= op.from && op.to <= op.from + op.count) pieces.push([0, Infinity, 0]);
+  else if (op.to > op.from) {
+    const n = op.count;
+    pieces.push([0, op.from - 1, 0], [op.from, op.from + n - 1, op.to - n - op.from], [op.from + n, op.to - 1, -n], [op.to, Infinity, 0]);
+  } else {
+    const n = op.count;
+    pieces.push([0, op.to - 1, 0], [op.to, op.from - 1, n], [op.from, op.from + n - 1, op.to - op.from], [op.from + n, Infinity, 0]);
+  }
+  const out = [];
+  for (const [a, b, d] of pieces) {
+    const x0 = Math.max(a, lo);
+    const x1 = Math.min(b, hi);
+    if (x0 <= x1) out.push([x0 + d, x1 + d]);
+  }
+  out.sort((p, q) => p[0] - q[0]);
+  const merged = [];
+  for (const p of out) {
+    const last = merged[merged.length - 1];
+    if (last && last[1] + 1 >= p[0]) last[1] = Math.max(last[1], p[1]);
+    else merged.push([p[0], p[1]]);
+  }
+  return merged;
+}
+function rectsThrough(st, rects) {
+  const [a0, a1] = S(st.axis);
+  const out = [];
+  for (const r of rects) for (const [lo, hi] of spanThrough(st.op, r[a0], r[a1])) out.push({ ...r, [a0]: lo, [a1]: hi });
+  return out;
+}
+function rectMinus(a, b) {
+  if (a.startRow > b.endRow || b.startRow > a.endRow || a.startColumn > b.endColumn || b.startColumn > a.endColumn) return [a];
+  const out = [];
+  if (a.startRow < b.startRow) out.push({ ...a, endRow: b.startRow - 1 });
+  if (a.endRow > b.endRow) out.push({ ...a, startRow: b.endRow + 1 });
+  const r0 = Math.max(a.startRow, b.startRow);
+  const r1 = Math.min(a.endRow, b.endRow);
+  if (a.startColumn < b.startColumn) out.push({ ...a, startRow: r0, endRow: r1, endColumn: b.startColumn - 1 });
+  if (a.endColumn > b.endColumn) out.push({ ...a, startRow: r0, endRow: r1, startColumn: b.endColumn + 1 });
+  return out;
+}
+function rectsMinus(as, bs) {
+  let cur = as;
+  for (const b of bs) cur = cur.flatMap((a) => rectMinus(a, b));
+  return cur;
+}
+function nWrites(m) {
+  const out = [];
+  forEachCell(cellsOf(m), (r, c, v) => {
+    if (v === null || v.s === null || v.s && typeof v.s === "object" && "n" in v.s)
+      out.push({ startRow: r, endRow: r, startColumn: c, endColumn: c });
+  });
+  return out;
+}
+function numfmtPair(x, y, side, sx, sy) {
+  const nx = isNumfmt(x);
+  const ny = isNumfmt(y);
+  if (!nx && !ny) return null;
+  if (nx && sy) return ok(nfBuild(x, nfParts(x).map((p) => ({ ...p, ranges: rectsThrough(sy, p.ranges) }))));
+  if (ny && sx) return ok([x]);
+  if (nx && ny) {
+    if (side === "left") return ok([x]);
+    const ys = nfParts(y).flatMap((p) => p.ranges);
+    return ok(nfBuild(x, nfParts(x).map((p) => ({ ...p, ranges: rectsMinus(p.ranges, ys) }))));
+  }
+  if (nx && y.id === ID.values) {
+    if (side === "left") return ok([x]);
+    const ys = nWrites(y);
+    return ys.length ? ok(nfBuild(x, nfParts(x).map((p) => ({ ...p, ranges: rectsMinus(p.ranges, ys) })))) : ok([x]);
+  }
+  if (ny && x.id === ID.values) {
+    if (side === "left") return ok([x]);
+    const out = {};
+    const tail = {};
+    let touched = false;
+    forEachCell(cellsOf(x), (r, c, v) => {
+      const n = nfValueAt(y, r, c);
+      if (n === void 0) return putCell(out, r, c, v);
+      if (v === null || v.s === null) {
+        putCell(out, r, c, v);
+        if (n) {
+          putCell(tail, r, c, { s: { n } });
+          touched = true;
+        }
+        return;
+      }
+      if (v.s && typeof v.s === "object" && "n" in v.s) {
+        const { n: _drop, ...rest } = v.s;
+        const e = { ...v };
+        if (Object.keys(rest).length) e.s = rest;
+        else delete e.s;
+        touched = true;
+        if (Object.keys(e).length) putCell(out, r, c, e);
+        return;
+      }
+      putCell(out, r, c, v);
+    });
+    if (!touched) return ok([x]);
+    const ops = [];
+    if (!isEmptyMatrix(out)) ops.push(cellsMutation(x, out));
+    if (!isEmptyMatrix(tail)) ops.push({ id: ID.values, params: { subUnitId: sheetOf(x), cellValue: tail } });
+    return ok(ops);
+  }
+  return ok([x]);
+}
+var isCount = (m) => m.id === ID.rowCount || m.id === ID.colCount;
+var countAxis = (m) => m.id === ID.rowCount ? "row" : "col";
+var countKey = (m) => m.id === ID.rowCount ? "rowCount" : "columnCount";
+function countPair(x, y, sy) {
+  if (!isCount(x)) return isCount(y) ? ok([x]) : null;
+  const k = countKey(x);
+  const v = Number(x.params[k]);
+  if (sy) {
+    if (sy.axis !== countAxis(x) || sy.op.kind === "move") return ok([x]);
+    const d = sy.op.kind === "insert" ? sy.op.count : -sy.op.count;
+    return ok([{ id: x.id, params: { ...x.params, [k]: Math.max(1, v + d) } }]);
+  }
+  if (isCount(y) && y.id === x.id) {
+    const w = Number(y.params[k]);
+    return ok([w > v ? { id: x.id, params: { ...x.params, [k]: w } } : x]);
+  }
+  return ok([x]);
+}
+var isSheetOp = (m) => m.id === ID.insertSheet || m.id === ID.removeSheet || m.id === ID.sheetOrder;
+var sheetIdOf = (m) => m.id === ID.insertSheet ? String(m.params.sheet?.id ?? "") : sheetOf(m);
+function sheetAxisOf(m) {
+  const p = m.params;
+  if (m.id === ID.insertSheet) return typeof p.index === "number" ? { kind: "insert", at: p.index, count: 1 } : null;
+  if (m.id === ID.removeSheet) return typeof p.sheetIndex === "number" ? { kind: "remove", start: p.sheetIndex, count: 1 } : null;
+  if (m.id === ID.sheetOrder) {
+    const f = Number(p.fromOrder);
+    const t = Number(p.toOrder);
+    return { kind: "move", from: f, count: 1, to: t > f ? t + 1 : t };
+  }
+  return null;
+}
+function buildSheetOp(template, op) {
+  if (op.kind === "insert") return { id: template.id, params: { ...template.params, index: op.at } };
+  if (op.kind === "remove") return { id: template.id, params: { ...template.params, sheetIndex: op.start } };
+  return { id: template.id, params: { ...template.params, fromOrder: op.from, toOrder: op.to > op.from ? op.to - 1 : op.to } };
+}
+function namesSheet(m, id) {
+  const rs = refSheetsOf(m);
+  return !!rs && Object.values(rs).includes(id) && (m.id === ID.setName || hasFormula(m));
+}
+function sheetPair(x, y, side) {
+  const xs = isSheetOp(x);
+  const ys = isSheetOp(y);
+  if (!xs && !ys) return null;
+  if (xs && ys) {
+    const a = sheetAxisOf(x);
+    const b = sheetAxisOf(y);
+    if (!a || !b) return barrier2("a sheet add or remove without its index (capture must call annotateSheetOps)");
+    if (x.id === ID.insertSheet && y.id === ID.insertSheet && sheetIdOf(x) === sheetIdOf(y)) {
+      return JSON.stringify(x.params) === JSON.stringify(y.params) ? ok([]) : barrier2("the same sheet id added twice with different content");
+    }
+    if (x.id === ID.removeSheet && typeof x.params.sheetsLeft === "number" && sheetIdOf(x) !== sheetIdOf(y) && (y.id === ID.removeSheet || y.id === ID.insertSheet)) {
+      const left = x.params.sheetsLeft + (y.id === ID.insertSheet ? 1 : -1);
+      if (left < 1) return barrier2("concurrent sheet removes would leave the workbook without a sheet");
+      const out2 = transformAxis(a, b, side);
+      if (!out2) return barrier2("sheet order: no transform");
+      return ok(out2.map((o) => buildSheetOp({ id: x.id, params: { ...x.params, sheetsLeft: left } }, o)));
+    }
+    const out = transformAxis(a, b, side);
+    if (!out) return barrier2("sheet order: no transform");
+    return ok(out.map((o) => buildSheetOp(x, o)), [], out.length === 0 && x.id === ID.sheetOrder ? [`${sheetIdOf(x)}: sheet order`] : []);
+  }
+  if (ys) {
+    if (y.id !== ID.removeSheet) return ok([x]);
+    const gone2 = sheetOf(y);
+    if (namesSheet(x, gone2)) return barrier2("a formula names a sheet removed at the same time");
+    if (sheetOf(x) === gone2 && x.id !== ID.setName && x.id !== ID.removeName)
+      return ok([], [], isDerived(x) ? [] : [`${gone2}: the sheet was removed`]);
+    return ok([x]);
+  }
+  if (x.id !== ID.removeSheet) return ok([x]);
+  const gone = sheetOf(x);
+  if (namesSheet(y, gone)) return barrier2("a formula names a sheet removed at the same time");
+  return ok([x], sheetOf(y) === gone && !isDerived(y) && y.id !== ID.setName && y.id !== ID.removeName ? [`${gone}: the sheet was removed`] : []);
+}
+function annotateSheetOps(group, sheetOrder) {
+  const order = [...sheetOrder];
+  return group.map((m) => {
+    if (m.id === ID.insertSheet) {
+      const index = typeof m.params.index === "number" ? Math.min(m.params.index, order.length) : order.length;
+      order.splice(index, 0, sheetIdOf(m));
+      return index === m.params.index ? m : { id: m.id, params: { ...m.params, index } };
+    }
+    if (m.id === ID.removeSheet) {
+      const i = order.indexOf(sheetOf(m));
+      if (i >= 0) order.splice(i, 1);
+      return i >= 0 ? { id: m.id, params: { ...m.params, sheetIndex: i, sheetsLeft: order.length } } : m;
+    }
+    if (m.id === ID.sheetOrder) {
+      const f = Number(m.params.fromOrder);
+      const [id] = order.splice(f, 1);
+      order.splice(Number(m.params.toOrder), 0, id ?? sheetOf(m));
+    }
+    return m;
+  });
+}
+function inlineSheetStyles(sheet, styleOf) {
+  const out = JSON.parse(JSON.stringify(sheet));
+  const fix = (o) => {
+    if (o && typeof o.s === "string") {
+      const st = styleOf(o.s);
+      if (st) o.s = JSON.parse(JSON.stringify(st));
+    }
+  };
+  for (const row of Object.values(out.cellData ?? {})) for (const cell of Object.values(row ?? {})) fix(cell);
+  for (const key of ["rowData", "columnData"]) for (const v of Object.values(out[key] ?? {})) fix(v);
+  if (typeof out.defaultStyle === "string") {
+    const st = styleOf(out.defaultStyle);
+    if (st) out.defaultStyle = JSON.parse(JSON.stringify(st));
+  }
+  return out;
+}
+var isSort = (m) => m.id === ID.sort;
+function sortOf(m) {
+  const P = /* @__PURE__ */ new Map();
+  for (const [t, src] of Object.entries(m.params.order ?? {})) P.set(Number(t), Number(src));
+  return { range: { ...m.params.range }, P };
+}
+var sortQ = (o) => new Map([...o.P].map(([t, s0]) => [s0, t]));
+function buildSort(template, o) {
+  const order = {};
+  for (const [t, s0] of [...o.P].sort((a, b) => a[0] - b[0])) if (t !== s0) order[t] = s0;
+  if (!Object.keys(order).length || o.range.startRow > o.range.endRow || o.range.startColumn > o.range.endColumn) return [];
+  return [{ id: template.id, params: { ...template.params, range: o.range, order } }];
+}
+var inSortCols = (o, c) => c >= o.range.startColumn && c <= o.range.endColumn;
+function sortThrough(o, st) {
+  const r = o.range;
+  if (st.axis === "col") {
+    if (st.op.kind === "move") {
+      const { from, count, to } = st.op;
+      const touches = !(from + count - 1 < r.startColumn || from > r.endColumn) || to > r.startColumn && to <= r.endColumn;
+      if (touches) return null;
+      const spans3 = spanThrough(st.op, r.startColumn, r.endColumn);
+      return spans3.length === 1 ? { range: { ...r, startColumn: spans3[0][0], endColumn: spans3[0][1] }, P: o.P } : null;
+    }
+    const spans2 = spanThrough(st.op, r.startColumn, r.endColumn);
+    if (!spans2.length) return { range: { ...r, startColumn: 1, endColumn: 0 }, P: /* @__PURE__ */ new Map() };
+    return { range: { ...r, startColumn: spans2[0][0], endColumn: spans2[spans2.length - 1][1] }, P: o.P };
+  }
+  const op = st.op;
+  if (op.kind === "move") {
+    const touches = !(op.from + op.count - 1 < r.startRow || op.from > r.endRow) || op.to > r.startRow && op.to <= r.endRow;
+    if (touches) return null;
+  }
+  if (op.kind === "insert" || op.kind === "move") {
+    const P2 = /* @__PURE__ */ new Map();
+    for (const [t, s0] of o.P) P2.set(mapIndex(op, t), mapIndex(op, s0));
+    const spans2 = spanThrough(op, r.startRow, r.endRow);
+    return { range: { ...r, startRow: spans2[0][0], endRow: spans2[spans2.length - 1][1] }, P: P2 };
+  }
+  const removed = (i) => i >= op.start && i < op.start + op.count;
+  const Q = sortQ(o);
+  const goneTargets = [];
+  for (let i = op.start; i < op.start + op.count; i++) goneTargets.push(Q.get(i) ?? i);
+  goneTargets.sort((a, b) => a - b);
+  const compact = (t) => t - goneTargets.filter((g) => g < t).length;
+  const P = /* @__PURE__ */ new Map();
+  for (const [t, s0] of o.P) if (!removed(s0)) P.set(compact(t), mapIndex(op, s0));
+  const spans = spanThrough(op, r.startRow, r.endRow);
+  if (!spans.length) return { range: { ...r, startRow: 1, endRow: 0 }, P: /* @__PURE__ */ new Map() };
+  return { range: { ...r, startRow: spans[0][0], endRow: spans[spans.length - 1][1] }, P };
+}
+function sortPair(x, y, sx, sy) {
+  const xs = isSort(x);
+  const ys = isSort(y);
+  if (!xs && !ys) return null;
+  if (xs && ys) {
+    const a = sortOf(x).range;
+    const b = sortOf(y).range;
+    const overlap = a.startRow <= b.endRow && b.startRow <= a.endRow && a.startColumn <= b.endColumn && b.startColumn <= a.endColumn;
+    return overlap ? barrier2("two sorts of overlapping ranges at once") : ok([x]);
+  }
+  if (xs) {
+    if (sy) {
+      const t = sortThrough(sortOf(x), sy);
+      return t ? ok(buildSort(x, t)) : barrier2("a row or column move through a sorted range");
+    }
+    return ok([x]);
+  }
+  const o = sortOf(y);
+  const Q = sortQ(o);
+  const moved = (r) => r >= o.range.startRow && r <= o.range.endRow && Q.has(r);
+  if (sx) {
+    if (sx.axis === "col") return sx.op.kind === "move" && !sortThrough(o, sx) ? barrier2("a column move through a sorted range") : ok([x]);
+    if (sx.op.kind === "insert") return ok([x]);
+    if (sx.op.kind === "move") return sortThrough(o, sx) ? ok([x]) : barrier2("a row move through a sorted range");
+    const rows = [];
+    let partial = false;
+    for (let i = sx.op.start; i < sx.op.start + sx.op.count; i++) {
+      if (moved(i)) partial = true;
+      rows.push(Q.get(i) ?? i);
+    }
+    if (partial) return barrier2("a row remove against a concurrent sort of those rows");
+    return ok([x]);
+  }
+  if (x.id === ID.values) {
+    const out = {};
+    let changed = false;
+    forEachCell(cellsOf(x), (r, c, v) => {
+      if (inSortCols(o, c) && moved(r)) {
+        putCell(out, Q.get(r), c, v);
+        changed = true;
+      } else putCell(out, r, c, v);
+    });
+    return changed ? ok([cellsMutation(x, out)]) : ok([x]);
+  }
+  if (isNumfmt(x)) {
+    const parts = nfParts(x).map((p) => {
+      const ranges = [];
+      for (const rc of p.ranges) {
+        const inner = { ...rc, startRow: Math.max(rc.startRow, o.range.startRow), endRow: Math.min(rc.endRow, o.range.endRow), startColumn: Math.max(rc.startColumn, o.range.startColumn), endColumn: Math.min(rc.endColumn, o.range.endColumn) };
+        if (inner.startRow > inner.endRow || inner.startColumn > inner.endColumn) {
+          ranges.push(rc);
+          continue;
+        }
+        ranges.push(...rectMinus(rc, inner));
+        for (let r = inner.startRow; r <= inner.endRow; r++) ranges.push({ ...inner, startRow: Q.get(r) ?? r, endRow: Q.get(r) ?? r });
+      }
+      return { ...p, ranges };
+    });
+    return ok(nfBuild(x, parts));
+  }
+  return ok([x]);
+}
 function familyOf(id) {
   const e = SHEET_MUTATIONS[id];
   return e && e.kind === "covered" ? e.family : "";
@@ -1017,6 +1435,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 sp = sheetPair(x, y, side);
+  if (sp) return sp;
   const fp = formulaPair(x, y, side);
   if (fp) return fp;
   if (sheetOf(x) !== sheetOf(y)) return ok([x]);
@@ -1024,6 +1444,12 @@ function transformMutation(x, y, side) {
   const fy = familyOf(y.id);
   const sy = structuralOf(y);
   const sx = structuralOf(x);
+  const sortp = sortPair(x, y, sx, sy);
+  if (sortp) return sortp;
+  const cp = countPair(x, y, sy);
+  if (cp) return cp;
+  const np = numfmtPair(x, y, side, sx, sy);
+  if (np) return np;
   if (sx && sy) {
     if (sx.axis !== sy.axis) return ok([x]);
     const out = transformAxis(sx.op, sy.op, side);
@@ -1131,22 +1557,45 @@ function tSeq(xs, ys, side, acc) {
     acc.dropped.push(...a.dropped);
     return [a.op, b.op];
   }
+  const outX = [];
+  let curY = ys;
+  for (const x of xs) {
+    let curX = [x];
+    const nextY = [];
+    for (const y of curY) {
+      if (curX.length === 0) {
+        nextY.push(y);
+        continue;
+      }
+      const r = tSeq(curX, [y], side, acc);
+      if (blocked(r)) return r;
+      curX = r[0];
+      for (const m of r[1]) nextY.push(m);
+    }
+    for (const m of curX) outX.push(m);
+    curY = nextY;
+  }
+  return [outX, curY];
+}
+function tSeqOld(xs, ys, side, acc) {
+  if (xs.length === 0 || ys.length === 0) return [xs, ys];
+  if (xs.length === 1 && ys.length === 1) return tSeq(xs, ys, side, acc);
   if (xs.length > 1) {
-    const first2 = tSeq([xs[0]], ys, side, acc);
+    const first2 = tSeqOld([xs[0]], ys, side, acc);
     if (blocked(first2)) return first2;
-    const rest2 = tSeq(xs.slice(1), first2[1], side, acc);
+    const rest2 = tSeqOld(xs.slice(1), first2[1], side, acc);
     if (blocked(rest2)) return rest2;
     return [[...first2[0], ...rest2[0]], rest2[1]];
   }
-  const first = tSeq(xs, [ys[0]], side, acc);
+  const first = tSeqOld(xs, [ys[0]], side, acc);
   if (blocked(first)) return first;
-  const rest = tSeq(first[0], ys.slice(1), side, acc);
+  const rest = tSeqOld(first[0], ys.slice(1), side, acc);
   if (blocked(rest)) return rest;
   return [rest[0], [...first[1], ...rest[1]]];
 }
 function transformGroup(x, y, side) {
   const acc = { lost: [], dropped: [] };
-  const r = tSeq([...x], [...y], side, acc);
+  const r = (process.env.OLD_TSEQ ? tSeqOld : tSeq)([...x], [...y], side, acc);
   if (blocked(r)) return r;
   return { op: r[0], lost: [...new Set(acc.lost)], dropped: [...new Set(acc.dropped)] };
 }
@@ -1173,19 +1622,24 @@ export {
   SIDE_CAR_PARAMS,
   allowParams,
   annotateFormulas,
+  annotateSheetOps,
   cellRef,
   completeCellContent,
   exactMergeRemovals,
   forApply,
   formulaBarrier,
+  inlineSheetStyles,
   isBarrier,
   isFormulaText,
+  isStructuralMutation,
   mapIndex,
+  mergeFixupsOwed,
   mergeThrough,
   refSheetsAfter,
   refSheetsFor,
   rewriteFormula,
   sheetTransformer,
+  spanThrough,
   transformAxis,
   transformGroup,
   transformMutation