@ai-matrx/office 0.8.21 → 0.8.23

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.8.23
+### C9: comment anchors that follow concurrent edits
+
+- **Docs:** `addCommentAnchorActions(body, start, end, id)` anchors a passage with a `COMMENT` custom range (Univer's own builder, so the op has the link family's shape C0 proved); `commentAnchorsOf(body)` reads every anchor back (split pieces joined, Univer's inclusive end as `[start, end)`); `removeCommentAnchorActions` takes a cancelled draft's anchor out; `commentPartAnchor` / `anchorIdOfPartAnchor` are the thread's `part_anchor` (`anchor:<id>`, quote as `label`). Fuzz on the C0 corpora: anchor × every captured family and anchor × anchor, 0 divergences in 180,000 checks at 2,000 seeds; red check without a transform.
+- **Sheets:** `installSheetCommentAnchors(univer)` registers `matrx.mutation.set-comment-anchor`, the `SHEET_MATRX_COMMENT_ANCHORS_PLUGIN` resource and a listener that moves anchors through every applied row/column insert, remove and move (and drops them with their row, column or sheet). `transformCommentAnchor` (own file) is called first by `transformMutation`; the registry declares the id (family `anchor`), and the census exempts our own ids from the Univer scan. Fuzz: 40,000 checks, 0 divergences (it caught the same anchor id on two sheets being treated as one); two headless seats: B5 becomes B6 when a peer inserts a row above, survives save and reload, and is gone on both seats when its row is deleted. The fold installs the anchors too.
+- New export `./sheets/comment-anchors`. Consumer action: call `installSheetCommentAnchors(univer)` before creating a workbook unit that co-edits comments.
+
+## 0.8.22
+### C5c: Sheets co-editing — merge divergence fixed, number formats, counts and sheets travel
+
+- **Merge divergence across chained row/column deletes, fixed at its cause.** Univer 1.0.4's structural commands only fix the merges that intersect the COMMAND's range on the other axis (any `-by-range` call with a partial range, an API call) and only while its ref-range registration is current (never refreshed after a content load or a remove-merge). A cut merge it skipped stayed put on the sender while every transform moved it, so seats ended a column apart (the session fuzz's merge at column -1 vs 0). Capture now completes the command (`mergeFixupsOwed`): the cut merges still on the sheet are removed right before the structural mutation and re-added at their model position right after it, in the traveling group and on the sender alike. Multi-seat session fuzz: 0 hash mismatches (was 2–18 per run).
+- **Number formats travel** (`sheet.mutation.set.numfmt` / `remove.numfmt`, family `numfmt`): typing a date or a currency no longer rolls back. Ranges follow row/column inserts, removes and moves cell by cell; against another write of the style key `n` (a numfmt, a style with `n`, a style clear, a cell delete) the later-committed op wins.
+- **Row/column counts travel** (`set-worksheet-row-count` / `-column-count`, family `count`): a concurrent insert/remove on that axis shifts the count; two counts at once, the larger wins. "Refresh from table" growing a sheet is no longer rolled back.
+- **Sheets: add, remove, order travel** (family `sheet`): the sheet order is transformed as one more axis. Capture records a removed sheet's index and how many sheets are left (`annotateSheetOps`, side-car `sheetIndex`, `sheetsLeft`); an insert-sheet's styles are inlined (`inlineSheetStyles`). An edit to a sheet removed at the same time is dropped and its author told; a formula naming a removed sheet, and two removes that would leave no sheet, are barriers.
+- **Sort travels** (`reorder-range`, family `sort`): it is a row permutation inside its range, so concurrent edits follow their rows (a cell op inside the sorted columns lands where the sort moved its row; number formats likewise), a row insert keeps the new rows in place, column inserts/removes widen or clip the range. Barriers: two overlapping sorts, a row/column move through the sorted range, a row remove of rows the sort moved. The inverse is the inverted permutation.
+- **Selections: a seat's own row/column/count/sheet change keeps its selection inside the sheet** (API calls set no selection; the editor crashed with "Range is out of bounds"); a remote count/sheet change clamps it too.
+- **Transform speed:** the group transform walks the OT grid iteratively; untouched cell ops pass through by identity (no overlap, no formula, change elsewhere); barrier checks are cached per op; undo-stack rebase reuses each list's traveling shape and compares by identity.
+- **Tests:** new chained TP1 fuzz (`sheet-transform-chain-fuzz.test.ts`, 3–5 real commands per side, plus capture fidelity); the multi-seat session fuzz is seed-repeatable (`createSheetsOtAdapter` hook `stateHash`, a synchronous hash in tests) and asserts zero incidents. `SHEET_TRANSFORMER_VERSION` = `c5c-1`.
+- `SHEETS_COLLAB_PROTO` = 2: a room opened by this build is raised to proto 2 (when its checkpoint is at head) and older tabs open it read-only, so seats with and without merge completion never share a room.
+- Consumer action: none.
+
 ## 0.8.21
 ### C5c: Sheets co-editing — merge divergence fixed, number formats, counts and sheets travel
 

package/dist/collab-sheets-transform.cjs

@@ -86,6 +86,9 @@ var SHEET_MUTATIONS = {
   "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"),
+  // ── covered (C9): our own cell comment anchors (comment-anchor-transform.ts; not emitted by Univer) ──────
+  "matrx.mutation.set-comment-anchor": covered("anchor", "anchorId", "cell"),
+  "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),
@@ -119,7 +122,6 @@ 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.move-range": barrier("X", "cut-paste carries the sender's cell matrices"),
   "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"),
@@ -528,6 +530,74 @@ function refSheetsFor(texts, sheets) {
   return Object.keys(out).length ? out : void 0;
 }
 
+// src/collab/sheets/comment-anchor-transform.ts
+var SET_SHEET_COMMENT_ANCHOR = "matrx.mutation.set-comment-anchor";
+var REMOVE_SHEET = "sheet.mutation.remove-sheet";
+function structuralAxisOp(id, params) {
+  const p = params;
+  switch (id) {
+    case "sheet.mutation.insert-row":
+      return p.range ? { axis: "row", op: { kind: "insert", at: p.range.startRow, count: p.range.endRow - p.range.startRow + 1 } } : null;
+    case "sheet.mutation.remove-rows":
+      return p.range ? { axis: "row", op: { kind: "remove", start: p.range.startRow, count: p.range.endRow - p.range.startRow + 1 } } : null;
+    case "sheet.mutation.insert-col":
+      return p.range ? { axis: "col", op: { kind: "insert", at: p.range.startColumn, count: p.range.endColumn - p.range.startColumn + 1 } } : null;
+    case "sheet.mutation.remove-col":
+      return p.range ? { axis: "col", op: { kind: "remove", start: p.range.startColumn, count: p.range.endColumn - p.range.startColumn + 1 } } : null;
+    case "sheet.mutation.move-rows":
+      return p.sourceRange && p.targetRange ? { axis: "row", op: { kind: "move", from: p.sourceRange.startRow, count: p.sourceRange.endRow - p.sourceRange.startRow + 1, to: p.targetRange.startRow } } : null;
+    case "sheet.mutation.move-columns":
+      return p.sourceRange && p.targetRange ? {
+        axis: "col",
+        op: { kind: "move", from: p.sourceRange.startColumn, count: p.sourceRange.endColumn - p.sourceRange.startColumn + 1, to: p.targetRange.startColumn }
+      } : null;
+    default:
+      return null;
+  }
+}
+function moveSheetAnchorCell(cell, sheet, id, params) {
+  if (String(params.subUnitId ?? "") !== sheet) return cell;
+  if (id === REMOVE_SHEET) return null;
+  const s = structuralAxisOp(id, params);
+  if (!s) return cell;
+  if (s.axis === "row") {
+    const row = mapIndex(s.op, cell.row);
+    return row === null ? null : row === cell.row ? cell : { row, col: cell.col };
+  }
+  const col = mapIndex(s.op, cell.col);
+  return col === null ? null : col === cell.col ? cell : { row: cell.row, col };
+}
+function colName(c) {
+  let s = "";
+  for (let n = c + 1; n > 0; n = Math.floor((n - 1) / 26)) s = String.fromCharCode(65 + (n - 1) % 26) + s;
+  return s;
+}
+var sheetCellName = (cell) => `${colName(cell.col)}${cell.row + 1}`;
+function cellOf(m) {
+  const c = m.params.cell;
+  return c && typeof c.row === "number" && typeof c.col === "number" ? c : null;
+}
+var ok = (op, lost = [], dropped = []) => ({ op, lost, dropped });
+var label = (m) => {
+  const c = cellOf(m);
+  return `${String(m.params.subUnitId ?? "")}!${c ? sheetCellName(c) : "?"} comment`;
+};
+function transformCommentAnchor(x, y, side) {
+  const xa = x.id === SET_SHEET_COMMENT_ANCHOR;
+  const ya = y.id === SET_SHEET_COMMENT_ANCHOR;
+  if (!xa && !ya) return null;
+  if (!xa) return ok([x]);
+  if (ya) {
+    if (x.params.anchorId !== y.params.anchorId || x.params.subUnitId !== y.params.subUnitId) return ok([x]);
+    return side === "left" ? ok([x], [label(y)]) : ok([], [], [label(x)]);
+  }
+  const cell = cellOf(x);
+  if (!cell) return ok([x]);
+  const moved = moveSheetAnchorCell(cell, String(x.params.subUnitId ?? ""), y.id, y.params);
+  if (!moved) return ok([], [], [label(x)]);
+  return ok([moved === cell ? x : { id: x.id, params: { ...x.params, cell: moved } }]);
+}
+
 // src/collab/sheets/transform/transform.ts
 var SHEET_TRANSFORMER_VERSION = "c5c-1";
 var ID = {
@@ -553,21 +623,22 @@ var ID = {
   colCount: "sheet.mutation.set-worksheet-column-count",
   insertSheet: "sheet.mutation.insert-sheet",
   removeSheet: "sheet.mutation.remove-sheet",
-  sheetOrder: "sheet.mutation.set-worksheet-order"
+  sheetOrder: "sheet.mutation.set-worksheet-order",
+  sort: "sheet.mutation.reorder-range"
 };
 var PAIR_BARRIERS = {};
 var pairKey = (a, b) => a < b ? `${a}|${b}` : `${b}|${a}`;
 var barrier2 = (reason) => ({ barrier: true, reason });
-var ok = (op, lost = [], dropped = []) => ({ op, lost, dropped });
+var ok2 = (op, lost = [], dropped = []) => ({ op, lost, dropped });
 var flip = (side) => side === "left" ? "right" : "left";
 var sheetOf = (m) => String(m.params.subUnitId ?? "");
-function colName(c) {
+function colName2(c) {
   let s = "";
   for (let n = c + 1; n > 0; n = Math.floor((n - 1) / 26)) s = String.fromCharCode(65 + (n - 1) % 26) + s;
   return s;
 }
-var cellRef = (sheet, row, col) => `${sheet}!${colName(col)}${row + 1}`;
-var rangeRef = (sheet, r) => `${sheet}!${colName(r.startColumn)}${r.startRow + 1}:${colName(r.endColumn)}${r.endRow + 1}`;
+var cellRef = (sheet, row, col) => `${sheet}!${colName2(col)}${row + 1}`;
+var rangeRef = (sheet, r) => `${sheet}!${colName2(r.startColumn)}${r.startRow + 1}:${colName2(r.endColumn)}${r.endRow + 1}`;
 function structuralOf(m) {
   const p = m.params;
   switch (m.id) {
@@ -822,9 +893,9 @@ function transformCell(X, Y, side) {
   return { entries: Object.keys(out).length ? [out, ...tail] : tail, xLost, yLost };
 }
 function transformCellsOverCells(x, y, side) {
-  if (sheetOf(x) !== sheetOf(y)) return ok([x]);
+  if (sheetOf(x) !== sheetOf(y)) return ok2([x]);
   const ycells = cellsOf(y);
-  if (!cellsOverlap(cellsOf(x), ycells)) return ok([x]);
+  if (!cellsOverlap(cellsOf(x), ycells)) return ok2([x]);
   const xd = isDerived(x);
   const yd = isDerived(y);
   const eff = derivedSide(x, y, side);
@@ -850,7 +921,7 @@ function transformCellsOverCells(x, y, side) {
   });
   if (why) return barrier2(why);
   const op = passes.filter((p) => !isEmptyMatrix(p)).map((p) => cellsMutation(x, p));
-  return ok(op, lost, dropped);
+  return ok2(op, lost, dropped);
 }
 var SIDE_CAR_PARAMS = ["refSheets", "previousName", "derived", "sheetIndex", "sheetsLeft"];
 var isDerived = (m) => m.params.derived === true;
@@ -921,7 +992,7 @@ 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]);
+  if (!hasFormula(x) && (change.kind !== "axis" || change.sheet !== sheetOf(x))) return ok2([x]);
   const ctx = formulaCtx(x);
   const out = {};
   const dropped = [];
@@ -950,9 +1021,9 @@ function cellsOverChange(x, change) {
   });
   if (why) return barrier2(why);
   const rsAfter = refSheetsAfter(ctx.refSheets, change);
-  if (!changed && JSON.stringify(rsAfter ?? null) === JSON.stringify(ctx.refSheets ?? null)) return ok([x]);
+  if (!changed && JSON.stringify(rsAfter ?? null) === JSON.stringify(ctx.refSheets ?? null)) return ok2([x]);
   const params = { ...withRefSheets(x.params, rsAfter), cellValue: out };
-  return ok(isEmptyMatrix(out) ? [] : [{ id: x.id, params }], [], dropped);
+  return ok2(isEmptyMatrix(out) ? [] : [{ id: x.id, params }], [], dropped);
 }
 function rewritesOf(y, change) {
   if (!hasFormula(y)) return null;
@@ -999,36 +1070,36 @@ function formulaPair(x, y, side) {
   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]);
+    if (String(x.params.id) !== String(y.params.id)) return ok2([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 (eff === "left") return ok2([x], isDerived(y) ? [] : [`defined name "${String(y.params.name)}"`]);
+    return ok2([], [], 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]);
+      if (!ch2) return ok2([x]);
       const add = rewritesOf(y, ch2);
       if (typeof add === "string") return barrier2(add);
-      return ok(add ? [x, add] : [x]);
+      return ok2(add ? [x, add] : [x]);
     }
     const ch = refChangeOf(y);
-    if (!ch) return ok([x]);
+    if (!ch) return ok2([x]);
     const r = definedNameThrough(x, ch);
-    return typeof r === "string" ? barrier2(r) : ok([r.op]);
+    return typeof r === "string" ? barrier2(r) : ok2([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]);
+      return ch2 ? cellsOverChange(x, ch2) : ok2([x]);
     }
     const ch = refChangeOf(x);
-    if (!ch) return ok([x]);
+    if (!ch) return ok2([x]);
     const r = definedNameThrough(y, ch);
     if (typeof r === "string") return barrier2(r);
-    return ok(r.changed ? [x, asDerived(r.op)] : [x]);
+    return ok2(r.changed ? [x, asDerived(r.op)] : [x]);
   }
   if (fx === "cell") {
     const ch = refChangeOf(y);
@@ -1043,7 +1114,7 @@ function formulaPair(x, y, side) {
     });
     const add = rewritesOf(y, ch);
     if (typeof add === "string") return barrier2(add);
-    return ok(add ? [x, add] : [x], lost);
+    return ok2(add ? [x, add] : [x], lost);
   }
   return null;
 }
@@ -1191,20 +1262,20 @@ 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 && sy) return ok2(nfBuild(x, nfParts(x).map((p) => ({ ...p, ranges: rectsThrough(sy, p.ranges) }))));
+  if (ny && sx) return ok2([x]);
   if (nx && ny) {
-    if (side === "left") return ok([x]);
+    if (side === "left") return ok2([x]);
     const ys = nfParts(y).flatMap((p) => p.ranges);
-    return ok(nfBuild(x, nfParts(x).map((p) => ({ ...p, ranges: rectsMinus(p.ranges, ys) }))));
+    return ok2(nfBuild(x, nfParts(x).map((p) => ({ ...p, ranges: rectsMinus(p.ranges, ys) }))));
   }
   if (nx && y.id === ID.values) {
-    if (side === "left") return ok([x]);
+    if (side === "left") return ok2([x]);
     const ys = nWrites(y);
-    return ys.length ? ok(nfBuild(x, nfParts(x).map((p) => ({ ...p, ranges: rectsMinus(p.ranges, ys) })))) : ok([x]);
+    return ys.length ? ok2(nfBuild(x, nfParts(x).map((p) => ({ ...p, ranges: rectsMinus(p.ranges, ys) })))) : ok2([x]);
   }
   if (ny && x.id === ID.values) {
-    if (side === "left") return ok([x]);
+    if (side === "left") return ok2([x]);
     const out = {};
     const tail = {};
     let touched = false;
@@ -1230,31 +1301,31 @@ function numfmtPair(x, y, side, sx, sy) {
       }
       putCell(out, r, c, v);
     });
-    if (!touched) return ok([x]);
+    if (!touched) return ok2([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 ok2(ops);
   }
-  return ok([x]);
+  return ok2([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;
+  if (!isCount(x)) return isCount(y) ? ok2([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]);
+    if (sy.axis !== countAxis(x) || sy.op.kind === "move") return ok2([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) } }]);
+    return ok2([{ 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 ok2([w > v ? { id: x.id, params: { ...x.params, [k]: w } } : x]);
   }
-  return ok([x]);
+  return ok2([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);
@@ -1287,31 +1358,31 @@ function sheetPair(x, y, side) {
     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");
+      return JSON.stringify(x.params) === JSON.stringify(y.params) ? ok2([]) : 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)));
+      return ok2(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`] : []);
+    return ok2(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]);
+    if (y.id !== ID.removeSheet) return ok2([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]);
+      return ok2([], [], isDerived(x) ? [] : [`${gone2}: the sheet was removed`]);
+    return ok2([x]);
   }
-  if (x.id !== ID.removeSheet) return ok([x]);
+  if (x.id !== ID.removeSheet) return ok2([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`] : []);
+  return ok2([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];
@@ -1350,6 +1421,119 @@ function inlineSheetStyles(sheet, styleOf) {
   }
   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") : ok2([x]);
+  }
+  if (xs) {
+    if (sy) {
+      const t = sortThrough(sortOf(x), sy);
+      return t ? ok2(buildSort(x, t)) : barrier2("a row or column move through a sorted range");
+    }
+    return ok2([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") : ok2([x]);
+    if (sx.op.kind === "insert") return ok2([x]);
+    if (sx.op.kind === "move") return sortThrough(o, sx) ? ok2([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 ok2([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 ? ok2([cellsMutation(x, out)]) : ok2([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 ok2(nfBuild(x, parts));
+  }
+  return ok2([x]);
+}
 function familyOf(id) {
   const e = SHEET_MUTATIONS[id];
   return e && e.kind === "covered" ? e.family : "";
@@ -1364,27 +1548,31 @@ function transformMutation(x, y, side) {
       if (why) return barrier2(why);
     }
   }
+  const ca = transformCommentAnchor(x, y, side);
+  if (ca) return ca;
   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]);
+  if (sheetOf(x) !== sheetOf(y)) return ok2([x]);
   const fx = familyOf(x.id);
   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]);
+    if (sx.axis !== sy.axis) return ok2([x]);
     const out = transformAxis(sx.op, sy.op, side);
     if (!out) return barrier2(`${x.id} over ${y.id}: moved blocks overlap in part, or the block would split`);
     const dropped = out.length === 0 && sx.op.kind === "move" ? [`${sheetOf(x)}: moved ${sx.axis}s`] : [];
-    return ok(out.map((o) => buildStructural(x, sx.axis, o)), [], dropped);
+    return ok2(out.map((o) => buildStructural(x, sx.axis, o)), [], dropped);
   }
   if (sy) {
     if (fx === "merge") {
@@ -1395,23 +1583,23 @@ function transformMutation(x, y, side) {
         if (t) kept.push(t);
         else dropped.push(rangeRef(sheetOf(x), r));
       }
-      return ok(kept.length ? [withRanges(x, kept)] : [], [], x.id === ID.addMerge ? dropped : []);
+      return ok2(kept.length ? [withRanges(x, kept)] : [], [], x.id === ID.addMerge ? dropped : []);
     }
     if (fx === "size") {
       const size = sizeOf(x);
-      if (size.axis !== sy.axis) return ok([x]);
+      if (size.axis !== sy.axis) return ok2([x]);
       const next = /* @__PURE__ */ new Map();
       for (const [i, v] of size.values) {
         const m = mapIndex(sy.op, i);
         if (m !== null) next.set(m, v);
       }
       const built = buildSize(x, next);
-      return ok(built ? [built] : []);
+      return ok2(built ? [built] : []);
     }
-    return ok([x]);
+    return ok2([x]);
   }
   if (sx) {
-    if (fy !== "merge" || y.id !== ID.addMerge) return ok([x]);
+    if (fy !== "merge" || y.id !== ID.addMerge) return ok2([x]);
     const remove = [];
     const add = [];
     for (const r of mergeRanges(y)) {
@@ -1421,11 +1609,11 @@ function transformMutation(x, y, side) {
       if (t.range) add.push(t.range);
     }
     const lostMerges = mergeRanges(y).filter((r) => mergeThrough(sx, r).range === null).map((r) => rangeRef(sheetOf(y), r));
-    if (!remove.length) return ok([x], lostMerges);
+    if (!remove.length) return ok2([x], lostMerges);
     const sheet = sheetOf(x);
     const pre = sx.op.kind === "insert" ? [] : [mergeMutation(ID.removeMerge, sheet, remove)];
     const mid = sx.op.kind === "insert" ? [mergeMutation(ID.removeMerge, sheet, remove)] : [];
-    return ok([...pre, x, ...mid, ...add.length ? [mergeMutation(ID.addMerge, sheet, add)] : []], lostMerges);
+    return ok2([...pre, x, ...mid, ...add.length ? [mergeMutation(ID.addMerge, sheet, add)] : []], lostMerges);
   }
   if (fx === "cell" && fy === "cell") return transformCellsOverCells(x, y, side);
   if (fx === "merge" && fy === "merge") {
@@ -1434,45 +1622,45 @@ function transformMutation(x, y, side) {
     const hit = (r) => yr.some((q) => intersects(r, q));
     const sheet = sheetOf(x);
     if (x.id === ID.addMerge && y.id === ID.addMerge) {
-      if (!xr.some(hit)) return ok([x]);
+      if (!xr.some(hit)) return ok2([x]);
       if (side === "left") {
         const lost = yr.filter((q) => xr.some((r) => intersects(r, q))).map((q) => rangeRef(sheet, q));
-        return ok([mergeMutation(ID.removeMerge, sheet, xr.filter(hit)), x], lost);
+        return ok2([mergeMutation(ID.removeMerge, sheet, xr.filter(hit)), x], lost);
       }
       const kept = xr.filter((r) => !hit(r));
-      return ok(kept.length ? [withRanges(x, kept)] : [], [], xr.filter(hit).map((r) => rangeRef(sheet, r)));
+      return ok2(kept.length ? [withRanges(x, kept)] : [], [], xr.filter(hit).map((r) => rangeRef(sheet, r)));
     }
     if (x.id === ID.addMerge && y.id === ID.removeMerge) {
-      if (side === "left" || !xr.some(hit)) return ok([x], side === "left" && xr.some(hit) ? yr.filter((q) => xr.some((r) => intersects(r, q))).map((q) => rangeRef(sheet, q)) : []);
+      if (side === "left" || !xr.some(hit)) return ok2([x], side === "left" && xr.some(hit) ? yr.filter((q) => xr.some((r) => intersects(r, q))).map((q) => rangeRef(sheet, q)) : []);
       const kept = xr.filter((r) => !hit(r));
-      return ok(kept.length ? [withRanges(x, kept)] : [], [], xr.filter(hit).map((r) => rangeRef(sheet, r)));
+      return ok2(kept.length ? [withRanges(x, kept)] : [], [], xr.filter(hit).map((r) => rangeRef(sheet, r)));
     }
     if (x.id === ID.removeMerge && y.id === ID.addMerge) {
       const touched = yr.filter((q) => xr.some((r) => intersects(r, q)));
-      if (!touched.length) return ok([x]);
-      if (side === "left") return ok([x], touched.map((q) => rangeRef(sheet, q)));
-      return ok([x, mergeMutation(ID.addMerge, sheet, touched)], [], xr.filter(hit).map((r) => rangeRef(sheet, r)));
+      if (!touched.length) return ok2([x]);
+      if (side === "left") return ok2([x], touched.map((q) => rangeRef(sheet, q)));
+      return ok2([x, mergeMutation(ID.addMerge, sheet, touched)], [], xr.filter(hit).map((r) => rangeRef(sheet, r)));
     }
-    return ok([x]);
+    return ok2([x]);
   }
   if (fx === "size" && fy === "size") {
     const a = sizeOf(x);
     const b = sizeOf(y);
-    if (a.axis !== b.axis || a.attr !== b.attr) return ok([x]);
+    if (a.axis !== b.axis || a.attr !== b.attr) return ok2([x]);
     if (side === "left") {
       const lost = [...a.values.keys()].filter((i) => b.values.has(i)).map((i) => `${sheetOf(x)}: ${a.axis} ${i + 1} ${a.attr}`);
-      return ok([x], lost);
+      return ok2([x], lost);
     }
     const next = new Map([...a.values].filter(([i]) => !b.values.has(i)));
     const built = buildSize(x, next);
     const dropped = [...a.values.keys()].filter((i) => b.values.has(i)).map((i) => `${sheetOf(x)}: ${a.axis} ${i + 1} ${a.attr}`);
-    return ok(built ? [built] : [], [], dropped);
+    return ok2(built ? [built] : [], [], dropped);
   }
   if (fx === "name" && fy === "name") {
-    if (side === "left") return ok([x], [`${sheetOf(x)}: name "${String(y.params.name)}"`]);
-    return ok([], [], [`${sheetOf(x)}: name "${String(x.params.name)}"`]);
+    if (side === "left") return ok2([x], [`${sheetOf(x)}: name "${String(y.params.name)}"`]);
+    return ok2([], [], [`${sheetOf(x)}: name "${String(x.params.name)}"`]);
   }
-  return ok([x]);
+  return ok2([x]);
 }
 var blocked = (p) => !Array.isArray(p);
 function tSeq(xs, ys, side, acc) {