@ai-matrx/office 0.8.13 → 0.8.15

package/dist/univer-collab.js

@@ -7,8 +7,8 @@ import { electCollabHost, remoteOriginOf, REMOTE_PARAM_TAG } from "@ai-matrx/dat
 
 // src/univer/collab/covered.ts
 var COLLAB_COVERED_KEY = "__matrxCollabCovered";
-function stampCovered(snapshot, covered) {
-  return { ...snapshot, [COLLAB_COVERED_KEY]: [...covered] };
+function stampCovered(snapshot, covered2) {
+  return { ...snapshot, [COLLAB_COVERED_KEY]: [...covered2] };
 }
 function takeCovered(snapshot) {
   if (!snapshot || typeof snapshot !== "object" || !(COLLAB_COVERED_KEY in snapshot)) {
@@ -148,10 +148,10 @@ var WorkbookCollabSession = class {
    */
   coveredNow() {
     if (!this.doc) return [];
-    const covered = this.options.base?.covered();
+    const covered2 = this.options.base?.covered();
     const out = [];
     for (const op of this.doc.getArray(MUTATIONS_ARRAY_KEY).toArray()) {
-      if (op.eid && (this.applied.has(op.eid) || covered?.has(op.eid))) out.push(op.eid);
+      if (op.eid && (this.applied.has(op.eid) || covered2?.has(op.eid))) out.push(op.eid);
     }
     return out;
   }
@@ -161,11 +161,11 @@ var WorkbookCollabSession = class {
    * by position — an entry that arrived while the save was in flight is not in the snapshot and stays.
    * Only the elected saver calls this; peers receive it as a delete (never replayed).
    */
-  checkpoint(snapshotId, covered) {
+  checkpoint(snapshotId, covered2) {
     if (!this.doc) return;
     const yArray = this.doc.getArray(MUTATIONS_ARRAY_KEY);
     const control = this.doc.getMap(CONTROL_MAP_KEY);
-    const drop = new Set(covered);
+    const drop = new Set(covered2);
     const signal = { snapshotId, by: this.options.clientId };
     this.doc.transact(() => {
       const entries = yArray.toArray();
@@ -289,10 +289,10 @@ var WorkbookCollabSession = class {
         return;
       }
     }
-    const covered = base?.covered();
+    const covered2 = base?.covered();
     for (const op of entries) {
       if (op.eid) {
-        if (this.applied.has(op.eid) || covered?.has(op.eid)) continue;
+        if (this.applied.has(op.eid) || covered2?.has(op.eid)) continue;
         this.applied.add(op.eid);
       } else {
         if (this.appliedRefs.has(op)) continue;
@@ -431,13 +431,13 @@ function dropEmptyStyleRetains(op) {
         e: v.e.map((a) => {
           const b = a.body;
           if (a.t !== "r" || !b || a.coverType === 1) return a;
-          const runs = (b.textRuns ?? []).filter((r) => r.ts && Object.keys(r.ts).length);
+          const runs2 = (b.textRuns ?? []).filter((r) => r.ts && Object.keys(r.ts).length);
           const other = Object.keys(b).filter(
             (k) => k !== "textRuns" && k !== "dataStream" && !(Array.isArray(b[k]) && b[k].length === 0)
           );
-          if (!runs.length && !other.length && !b.dataStream && !a.rangeUpdates?.length) return { t: "r", len: a.len };
-          if (b.textRuns === void 0 || runs.length === b.textRuns.length) return a;
-          return { ...a, body: { ...b, textRuns: runs } };
+          if (!runs2.length && !other.length && !b.dataStream && !a.rangeUpdates?.length) return { t: "r", len: a.len };
+          if (b.textRuns === void 0 || runs2.length === b.textRuns.length) return a;
+          return { ...a, body: { ...b, textRuns: runs2 } };
         })
       };
     }
@@ -761,23 +761,23 @@ function transformTextX(xIn, yIn, side, lost = []) {
   const yIds = valueIds(y);
   const conflicts = new Set([...valueIds(x)].filter((id) => yIds.has(id)));
   const X = new It(conflicts.size && !xLeft ? withoutValueRangeMetadata(x, conflicts) : x);
-  const Y3 = new It(conflicts.size && xLeft ? withoutValueRangeMetadata(y, conflicts) : y);
+  const Y4 = new It(conflicts.size && xLeft ? withoutValueRangeMetadata(y, conflicts) : y);
   const decos = addedDecorations(y).map((d) => ({ ...d, pieces: [] }));
   const out = [];
   let inPos = 0;
   let outPos = 0;
-  while (X.hasNext() || Y3.hasNext()) {
-    if (X.peekType() === "i" && (xLeft || Y3.peekType() !== "i")) {
+  while (X.hasNext() || Y4.hasNext()) {
+    if (X.peekType() === "i" && (xLeft || Y4.peekType() !== "i")) {
       const a = X.next();
-      if (Y3.inZone()) {
+      if (Y4.inZone()) {
         lost.push({ rule: "R1", side: "insert", len: a.len, ...a.body?.dataStream !== void 0 ? { text: a.body.dataStream } : {} });
         continue;
       }
       if (a.valueRangeId && conflicts.has(a.valueRangeId) && !xLeft) continue;
       push(out, a);
       outPos += a.len;
-    } else if (Y3.peekType() === "i") {
-      const b = Y3.next();
+    } else if (Y4.peekType() === "i") {
+      const b = Y4.next();
       if (X.inZone()) {
         push(out, { t: "d", len: b.len, tz: [[0, b.len - 1]] });
         lost.push({ rule: "R1", side: "delete", len: b.len, ...b.body?.dataStream !== void 0 ? { text: b.body.dataStream } : {} });
@@ -791,9 +791,9 @@ function transformTextX(xIn, yIn, side, lost = []) {
       }
       inPos += b.len;
     } else {
-      const len = Math.min(X.peekLength(), Y3.peekLength());
+      const len = Math.min(X.peekLength(), Y4.peekLength());
       const a = X.next(len);
-      const b = Y3.next(len);
+      const b = Y4.next(len);
       if (b.t === "d") continue;
       if (a.t === "d") {
         push(out, a);
@@ -888,9 +888,9 @@ function sortDeep(v) {
   return v;
 }
 var sameTs = (a, b) => JSON.stringify(sortDeep(a ?? {})) === JSON.stringify(sortDeep(b ?? {}));
-function canonicalRuns(runs) {
+function canonicalRuns(runs2) {
   const out = [];
-  for (const r of [...runs ?? []].sort((x, y) => x.st - y.st)) {
+  for (const r of [...runs2 ?? []].sort((x, y) => x.st - y.st)) {
     if (r.ed <= r.st) continue;
     const ts = sortDeep(r.ts ?? {});
     if (Object.keys(ts).length === 0) continue;
@@ -1002,25 +1002,25 @@ function rebaseUndoStack(items, remote) {
   let dropped = 0;
   for (let i = items.length - 1; i >= 0; i--) {
     const item = items[i];
-    let ok = true;
+    let ok2 = true;
     for (const list of [item.undoMutations, item.redoMutations]) {
       for (const m of list ?? []) {
         if (m.id !== RICH_TEXT_EDITING) continue;
         try {
           if (touchesPageSetup(m.params.actions) && touchesPageSetup(remote)) throw new Error("page setup");
           const r = transformDocsOp(m.params.actions, remote, "left");
-          if (isNoopDocsOp(r.op)) ok = false;
+          if (isNoopDocsOp(r.op)) ok2 = false;
           else {
             m.params = { ...m.params, actions: r.op };
             delete m.params.textRanges;
             delete m.params.layoutState;
           }
         } catch {
-          ok = false;
+          ok2 = false;
         }
       }
     }
-    if (!ok) {
+    if (!ok2) {
       items.splice(i, 1);
       dropped++;
     }
@@ -1550,6 +1550,1902 @@ async function restoreDocumentSnapshot(args, deps = {}) {
   const row = await d.saveRow(args);
   return { via: "saved", snapshotId: row.id };
 }
+
+// src/univer/collab/sheets-ot/room.ts
+import { openOpSession as openOpSession2 } from "@ai-matrx/data/realtime/collab";
+
+// src/collab/sheets/transform/types.ts
+var isBarrier = (r) => r.barrier === true;
+
+// src/collab/sheets/transform/registry.ts
+var covered = (family, ...allow) => ({ kind: "covered", family, allow: ["subUnitId", ...allow] });
+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 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", "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"),
+  "sheet.mutation.remove-col": covered("structure", "range"),
+  "sheet.mutation.move-rows": covered("structure", "sourceRange", "targetRange"),
+  "sheet.mutation.move-columns": covered("structure", "sourceRange", "targetRange"),
+  "sheet.mutation.add-worksheet-merge": covered("merge", "ranges"),
+  "sheet.mutation.remove-worksheet-merge": covered("merge", "ranges"),
+  "sheet.mutation.set-worksheet-row-height": covered("size", "ranges", "rowHeight"),
+  "sheet.mutation.set-worksheet-row-is-auto-height": covered("size", "ranges", "autoHeightInfo"),
+  "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"),
+  // ── never travels ────────────────────────────────────────────────────────────────────────────────
+  "formula.mutation.set-formula-calculation-start": never(FORMULA_RESULT),
+  "formula.mutation.set-trigger-formula-calculation-start": never(FORMULA_RESULT),
+  "formula.mutation.set-formula-calculation-stop": never(FORMULA_RESULT),
+  "formula.mutation.set-formula-calculation-notification": never(FORMULA_RESULT),
+  "formula.mutation.set-formula-calculation-result": never(FORMULA_RESULT),
+  "formula.mutation.set-array-formula-data": never(FORMULA_RESULT),
+  "formula.mutation.set-formula-data": never(FORMULA_RESULT),
+  "formula.mutation.set-image-formula-data": never(FORMULA_RESULT),
+  "formula.mutation.set-formula-string-batch-calculation": never(FORMULA_RESULT),
+  "formula.mutation.set-formula-string-batch-calculation-result": never(FORMULA_RESULT),
+  "formula.mutation.set-formula-dependency-calculation": never(FORMULA_RESULT),
+  "formula.mutation.set-formula-dependency-calculation-result": never(FORMULA_RESULT),
+  "formula.mutation.set-cell-formula-dependency-calculation": never(FORMULA_RESULT),
+  "formula.mutation.set-cell-formula-dependency-calculation-result": never(FORMULA_RESULT),
+  "formula.mutation.set-query-formula-dependency": never(FORMULA_RESULT),
+  "formula.mutation.set-query-formula-dependency-result": never(FORMULA_RESULT),
+  "formula.mutation.set-query-formula-dependency-all": never(FORMULA_RESULT),
+  "formula.mutation.set-query-formula-dependency-all-result": never(FORMULA_RESULT),
+  "formula.mutation.register-function": never("registers a function body on this seat's engine"),
+  "sheet.mutation.data-validation-formula-mark-dirty": never("dirty mark"),
+  "sheet.mutation.mark-dirty-filter-change": never("dirty mark"),
+  "sheet.mutation.re-calc-filter": never("filter recalculation result"),
+  "sheet.mutation.toggle-note-popup": never("popup state"),
+  "sheet.operation.clear-drawing-transformer": never("drawing selection handles (declared as a mutation)"),
+  "sheet.mutation.copy-worksheet-end": never("end marker of a copy; the copy travels as insert-sheet"),
+  "sheet.mutation.empty": never("no content"),
+  "thread-comment.mutation.add-comment": never(UNIVER_COMMENTS),
+  "thread-comment.mutation.update-comment": never(UNIVER_COMMENTS),
+  "thread-comment.mutation.update-comment-ref": never(UNIVER_COMMENTS),
+  "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"),
+  "sheet.mutation.set-worksheet-right-to-left": barrier("X", "sheet-level setting: not in C5a"),
+  "sheet.mutation.toggle-gridlines": barrier("X", "sheet-level setting: not in C5a"),
+  "sheet.mutation.set-gridlines-color": barrier("X", "sheet-level setting: not in C5a"),
+  "sheet.mutation.set-worksheet-default-style": barrier("X", "sheet-level setting: not in C5a"),
+  "sheet.mutation.set-frozen": barrier("X", "absolute frozen indices: not in C5a"),
+  "sheet.mutation.set-row-data": barrier("X", "row properties by index: not in C5a"),
+  "sheet.mutation.set-col-data": barrier("X", "column properties by index: not in C5a"),
+  "sheet.mutation.set-row-hidden": barrier("X", "row visibility: not in C5a"),
+  "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"),
+  "sheet.mutation.add-worksheet-protection": barrier("X", "permissions: not in C5a"),
+  "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"),
+  // ── 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),
+  "sheet.mutation.delete-conditional-rule": barrier("C5c", RESOURCE),
+  "sheet.mutation.move-conditional-rule": barrier("C5c", "conditional-format priority (ordered list)"),
+  "data-validation.mutation.addRule": barrier("C5c", RESOURCE),
+  "data-validation.mutation.updateRule": barrier("C5c", RESOURCE),
+  "data-validation.mutation.removeRule": barrier("C5c", RESOURCE),
+  "sheet.mutation.set-filter-range": barrier("C5c", RESOURCE),
+  "sheet.mutation.set-filter-criteria": barrier("C5c", RESOURCE),
+  "sheet.mutation.remove-filter": barrier("C5c", RESOURCE),
+  "sheet.mutation.add-table": barrier("C5c", RESOURCE),
+  "sheet.mutation.delete-table": barrier("C5c", RESOURCE),
+  "sheet.mutation.set-sheet-table": barrier("C5c", RESOURCE),
+  "sheet.mutation.set-table-filter": barrier("C5c", RESOURCE),
+  "sheet.mutation.move-table": barrier("C5c", RESOURCE),
+  "sheets.mutation.add-hyper-link": barrier("C5c", RESOURCE),
+  "sheets.mutation.remove-hyper-link": barrier("C5c", RESOURCE),
+  "sheets.mutation.update-hyper-link": barrier("C5c", RESOURCE),
+  "sheets.mutation.update-hyper-link-ref": barrier("C5c", RESOURCE),
+  "sheets.mutation.update-rich-hyper-link": barrier("C5c", RESOURCE),
+  "sheet.mutation.update-note": barrier("C5c", RESOURCE),
+  "sheet.mutation.remove-note": barrier("C5c", RESOURCE),
+  "sheet.mutation.update-note-position": barrier("C5c", RESOURCE),
+  "sheet.mutation.set-drawing-apply": barrier("C5c", RESOURCE),
+  "sheet.mutation.set-worksheet-background-image": barrier("C5c", RESOURCE),
+  "sheet.mutation.add-range-theme": barrier("C5c", RESOURCE),
+  "sheet.mutation.set-range-theme": barrier("C5c", RESOURCE),
+  "sheet.mutation.remove-range-theme": barrier("C5c", RESOURCE),
+  "sheet.mutation.set-worksheet-range-theme-style": barrier("C5c", RESOURCE),
+  "sheet.mutation.remove-worksheet-range-theme-style": barrier("C5c", RESOURCE),
+  "sheet.mutation.register-worksheet-range-theme-style": barrier("C5c", RESOURCE),
+  "sheet.mutation.unregister-worksheet-range-theme-style": barrier("C5c", RESOURCE)
+};
+function allowParams(id, params) {
+  const entry = SHEET_MUTATIONS[id];
+  if (!entry || entry.kind !== "covered") return null;
+  const out = {};
+  for (const f of entry.allow) if (params[f] !== void 0) out[f] = params[f];
+  return out;
+}
+
+// src/collab/sheets/transform/transform.ts
+import { adjustRangeOnMutation } from "@univerjs/sheets";
+
+// src/collab/sheets/transform/axis.ts
+function isNoopMove(op) {
+  return op.count <= 0 || op.to >= op.from && op.to <= op.from + op.count;
+}
+function movedBlockStart(op) {
+  return op.to > op.from ? op.to - op.count : op.to;
+}
+function mapIndex(op, i) {
+  switch (op.kind) {
+    case "insert":
+      return i >= op.at ? i + op.count : i;
+    case "remove":
+      if (i < op.start) return i;
+      if (i < op.start + op.count) return null;
+      return i - op.count;
+    case "move": {
+      if (isNoopMove(op)) return i;
+      const { from, count, to } = op;
+      if (i >= from && i < from + count) return movedBlockStart(op) + (i - from);
+      if (to > from) return i >= from + count && i < to ? i - count : i;
+      return i >= to && i < from ? i + count : i;
+    }
+  }
+}
+function runs(indices) {
+  const sorted = [...new Set(indices)].sort((a, b) => a - b);
+  const out = [];
+  for (const i of sorted) {
+    const last = out[out.length - 1];
+    if (last && last.start + last.count === i) last.count++;
+    else out.push({ start: i, count: 1 });
+  }
+  return out;
+}
+function mapGapThroughMove(p, mv) {
+  const { from, count, to } = mv;
+  if (p > from && p < from + count) return movedBlockStart(mv) + (p - from);
+  const g = p <= from ? p : p - count;
+  const tg = to <= from ? to : to - count;
+  return g <= tg ? g : g + count;
+}
+function transformAxis(x, y, side) {
+  if (y.kind === "move" && isNoopMove(y)) return [x];
+  if (x.kind === "move" && isNoopMove(x)) return [];
+  switch (x.kind) {
+    case "insert": {
+      if (y.kind === "insert") {
+        if (x.at < y.at || x.at === y.at && side === "left") return [x];
+        return [{ ...x, at: x.at + y.count }];
+      }
+      if (y.kind === "remove") {
+        if (x.at <= y.start) return [x];
+        if (x.at >= y.start + y.count) return [{ ...x, at: x.at - y.count }];
+        return [{ ...x, at: y.start }];
+      }
+      return [{ ...x, at: mapGapThroughMove(x.at, y) }];
+    }
+    case "remove": {
+      const kept = [];
+      for (let i = x.start; i < x.start + x.count; i++) {
+        const m = mapIndex(y, i);
+        if (m !== null) kept.push(m);
+      }
+      if (y.kind === "insert" || y.kind === "remove" || y.kind === "move") {
+        return runs(kept).reverse().map((r) => ({ kind: "remove", start: r.start, count: r.count }));
+      }
+      return null;
+    }
+    case "move": {
+      if (y.kind === "insert") {
+        const inside = y.at > x.from && y.at < x.from + x.count;
+        const from = inside || y.at > x.from ? x.from : x.from + y.count;
+        const count = inside ? x.count + y.count : x.count;
+        const to2 = x.to >= y.at ? x.to + y.count : x.to;
+        const out2 = { kind: "move", from, count, to: to2 };
+        return isNoopMove(out2) ? [] : [out2];
+      }
+      if (y.kind === "remove") {
+        const kept = [];
+        for (let i = x.from; i < x.from + x.count; i++) {
+          const m = mapIndex(y, i);
+          if (m !== null) kept.push(m);
+        }
+        if (kept.length === 0) return [];
+        const r2 = runs(kept);
+        if (r2.length !== 1) return null;
+        const to2 = x.to <= y.start ? x.to : x.to >= y.start + y.count ? x.to - y.count : y.start;
+        const out2 = { kind: "move", from: r2[0].start, count: r2[0].count, to: to2 };
+        return isNoopMove(out2) ? [] : [out2];
+      }
+      const overlap = Math.min(x.from + x.count, y.from + y.count) - Math.max(x.from, y.from);
+      if (overlap > 0) {
+        if (x.from !== y.from || x.count !== y.count) return null;
+        if (side === "right") return [];
+        const out2 = { kind: "move", from: movedBlockStart(y), count: x.count, to: mapGapThroughMove(x.to, y) };
+        return isNoopMove(out2) ? [] : [out2];
+      }
+      const mapped = [];
+      for (let i = x.from; i < x.from + x.count; i++) mapped.push(mapIndex(y, i));
+      const r = runs(mapped);
+      if (r.length !== 1) return null;
+      let to;
+      if (x.to > y.from && x.to < y.from + y.count) to = movedBlockStart(y) + (x.to - y.from);
+      else to = mapGapThroughMove(x.to, y) + (x.to === y.to && side === "right" ? y.count : 0);
+      const out = { kind: "move", from: r[0].start, count: r[0].count, to };
+      if (to > out.from && to < out.from + out.count) return null;
+      return isNoopMove(out) ? [] : [out];
+    }
+  }
+}
+
+// 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 = "c5b-1";
+var ID = {
+  values: "sheet.mutation.set-range-values",
+  insertRow: "sheet.mutation.insert-row",
+  removeRows: "sheet.mutation.remove-rows",
+  insertCol: "sheet.mutation.insert-col",
+  removeCol: "sheet.mutation.remove-col",
+  moveRows: "sheet.mutation.move-rows",
+  moveCols: "sheet.mutation.move-columns",
+  addMerge: "sheet.mutation.add-worksheet-merge",
+  removeMerge: "sheet.mutation.remove-worksheet-merge",
+  rowHeight: "sheet.mutation.set-worksheet-row-height",
+  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",
+  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}`;
+var barrier2 = (reason) => ({ barrier: true, reason });
+var ok = (op, lost = [], dropped = []) => ({ op, lost, dropped });
+var flip = (side) => side === "left" ? "right" : "left";
+var sheetOf = (m) => String(m.params.subUnitId ?? "");
+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 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}`;
+function structuralOf(m) {
+  const p = m.params;
+  switch (m.id) {
+    case ID.insertRow:
+      return { axis: "row", op: { kind: "insert", at: p.range.startRow, count: p.range.endRow - p.range.startRow + 1 } };
+    case ID.removeRows:
+      return { axis: "row", op: { kind: "remove", start: p.range.startRow, count: p.range.endRow - p.range.startRow + 1 } };
+    case ID.insertCol:
+      return { axis: "col", op: { kind: "insert", at: p.range.startColumn, count: p.range.endColumn - p.range.startColumn + 1 } };
+    case ID.removeCol:
+      return { axis: "col", op: { kind: "remove", start: p.range.startColumn, count: p.range.endColumn - p.range.startColumn + 1 } };
+    case ID.moveRows:
+      return {
+        axis: "row",
+        op: { kind: "move", from: p.sourceRange.startRow, count: p.sourceRange.endRow - p.sourceRange.startRow + 1, to: p.targetRange.startRow }
+      };
+    case ID.moveCols:
+      return {
+        axis: "col",
+        op: {
+          kind: "move",
+          from: p.sourceRange.startColumn,
+          count: p.sourceRange.endColumn - p.sourceRange.startColumn + 1,
+          to: p.targetRange.startColumn
+        }
+      };
+    default:
+      return null;
+  }
+}
+var S = (axis) => axis === "row" ? ["startRow", "endRow"] : ["startColumn", "endColumn"];
+function buildStructural(template, axis, op) {
+  const [a0, a1] = S(axis);
+  const p = template.params;
+  if (op.kind === "move") {
+    const src = p.sourceRange;
+    const tgt = p.targetRange;
+    return {
+      id: template.id,
+      params: {
+        ...p,
+        sourceRange: { ...src, [a0]: op.from, [a1]: op.from + op.count - 1 },
+        targetRange: { ...tgt, [a0]: op.to, [a1]: op.to + op.count - 1 }
+      }
+    };
+  }
+  const start = op.kind === "insert" ? op.at : op.start;
+  return { id: template.id, params: { ...p, range: { ...p.range, [a0]: start, [a1]: start + op.count - 1 } } };
+}
+function univerMutationInfo(axis, op) {
+  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" ? { ...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 } };
+}
+var intersects = (a, b) => a.startRow <= b.endRow && b.startRow <= a.endRow && a.startColumn <= b.endColumn && b.startColumn <= a.endColumn;
+var isSingleCell = (r) => r.startRow === r.endRow && r.startColumn === r.endColumn;
+function mergeThrough(s, m) {
+  const [a0, a1] = S(s.axis);
+  const lo = m[a0];
+  const hi = m[a1];
+  const op = s.op;
+  if (op.kind === "insert") {
+    const fixup = lo < op.at && op.at <= hi;
+    return { range: adjustRangeOnMutation(m, univerMutationInfo(s.axis, op)), fixup };
+  }
+  if (op.kind === "remove") {
+    const e = op.start + op.count - 1;
+    if (e < lo || op.start > hi) return { range: adjustRangeOnMutation(m, univerMutationInfo(s.axis, op)), fixup: false };
+    if (op.start <= lo && e >= hi) return { range: null, fixup: true };
+    const r = { ...m };
+    if (op.start >= lo && e <= hi) r[a1] = hi - op.count;
+    else if (op.start < lo) {
+      r[a0] = op.start;
+      r[a1] = hi - op.count;
+    } else r[a1] = op.start - 1;
+    return { range: isSingleCell(r) ? null : r, fixup: true };
+  }
+  const fe = op.from + op.count - 1;
+  if (hi < op.from || lo > fe) {
+    const r = { ...m };
+    if (op.from < lo && op.to > hi) {
+      r[a0] = lo - op.count;
+      r[a1] = hi - op.count;
+    } else if (op.from > hi && op.to <= lo) {
+      r[a0] = lo + op.count;
+      r[a1] = hi + op.count;
+    }
+    return { range: r, fixup: false };
+  }
+  if (lo >= op.from && hi <= fe) {
+    const r = { ...m, [a0]: mapIndex(op, lo), [a1]: mapIndex(op, hi) };
+    return { range: r, fixup: true };
+  }
+  return { range: m, fixup: false };
+}
+function exactMergeRemovals(group, merges) {
+  const sim = new Map(Object.entries(merges).map(([k, v]) => [k, v.map((r) => ({ ...r }))]));
+  const out = [];
+  for (const m of group) {
+    const sheet = sheetOf(m);
+    const cur = sim.get(sheet) ?? [];
+    if (m.id === ID.removeMerge) {
+      const hit = cur.filter((q) => mergeRanges(m).some((r) => intersects(r, q)));
+      sim.set(sheet, cur.filter((q) => !hit.includes(q)));
+      if (hit.length) out.push(withRanges(m, hit.map((r) => ({ ...r }))));
+      continue;
+    }
+    if (m.id === ID.addMerge) sim.set(sheet, [...cur, ...mergeRanges(m).map((r) => ({ ...r }))]);
+    const st = structuralOf(m);
+    if (st) sim.set(sheet, cur.map((q) => mergeThrough(st, q).range).filter((q) => q !== null));
+    out.push(m);
+  }
+  return out;
+}
+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", "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;
+  if (!CONTENT_TOUCH.some((k) => k in entry)) return entry;
+  const out = {};
+  for (const k of CONTENT_KEYS) out[k] = post && post[k] !== void 0 ? post[k] : null;
+  if (out.v === null) delete out.t;
+  if ("s" in entry) out.s = entry.s;
+  return out;
+}
+function cellsOf(m) {
+  return m.params.cellValue ?? {};
+}
+function forEachCell(cells, fn) {
+  for (const r of Object.keys(cells)) for (const c of Object.keys(cells[r] ?? {})) fn(Number(r), Number(c), cells[r][c] ?? null);
+}
+function cellsMutation(template, cells) {
+  return { id: template.id, params: { ...template.params, cellValue: cells } };
+}
+function putCell(cells, r, c, v) {
+  (cells[r] ??= {})[c] = v;
+}
+var isEmptyMatrix = (cells) => Object.values(cells).every((row) => Object.keys(row).length === 0);
+function cellBarrier(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) => {
+    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 === "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))
+      why = "cell content is not completed (capture must call completeCellContent)";
+  });
+  return why;
+}
+var hasContent = (v) => CONTENT_TOUCH.some((k) => k in v);
+var contentOf = (v) => {
+  const out = {};
+  for (const k of Object.keys(v)) if (k !== "s") out[k] = v[k];
+  return out;
+};
+var richText = (v) => v.p != null;
+function styleKeys(s) {
+  const out = [];
+  for (const k of Object.keys(s)) {
+    if (k === "bd" && s.bd && typeof s.bd === "object") for (const side of Object.keys(s.bd)) out.push(`bd.${side}`);
+    else out.push(k);
+  }
+  return out;
+}
+function withoutStyleKeys(s, drop) {
+  const out = {};
+  for (const k of Object.keys(s)) {
+    if (k === "bd" && s.bd && typeof s.bd === "object") {
+      const bd = {};
+      for (const side of Object.keys(s.bd)) if (!drop.has(`bd.${side}`)) bd[side] = s.bd[side];
+      if (Object.keys(bd).length) out.bd = bd;
+    } else if (!drop.has(k)) out[k] = s[k];
+  }
+  return Object.keys(out).length ? out : null;
+}
+function transformCell(X, Y4, side) {
+  if (X === null || Y4 === null) {
+    if (side === "left") return { entries: [X], xLost: false, yLost: true };
+    return X === null ? { entries: [null, Y4], xLost: true, yLost: false } : { entries: [], xLost: true, yLost: false };
+  }
+  if (hasContent(X) && richText(X) && "s" in Y4 || hasContent(Y4) && richText(Y4) && "s" in X)
+    return "rich-text content concurrent with a style change on the same cell is not covered";
+  const out = {};
+  let xLost = false;
+  let yLost = false;
+  if (hasContent(X)) {
+    if (!hasContent(Y4) || side === "left") Object.assign(out, contentOf(X));
+    else xLost = true;
+    if (hasContent(Y4) && side === "left") yLost = true;
+  }
+  const tail = [];
+  if ("s" in X) {
+    const xs = X.s;
+    const ys = "s" in Y4 ? Y4.s : void 0;
+    if (ys === void 0 || side === "left") {
+      if (xs !== void 0) out.s = xs;
+      if (ys !== void 0) yLost = true;
+    } else if (ys === null) {
+      xLost = true;
+    } else if (xs === null) {
+      out.s = null;
+      tail.push({ s: ys });
+      xLost = true;
+    } else {
+      const kept = withoutStyleKeys(xs, new Set(styleKeys(ys)));
+      if (kept) out.s = kept;
+      if (styleKeys(xs).length !== styleKeys(kept ?? {}).length) xLost = true;
+    }
+  }
+  return { entries: Object.keys(out).length ? [out, ...tail] : tail, xLost, yLost };
+}
+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 = [];
+  let why = null;
+  forEachCell(cellsOf(x), (r, c, X) => {
+    if (why) return;
+    const yRow = ycells[r];
+    if (!yRow || !(String(c) in yRow)) {
+      putCell(passes[0], r, c, X);
+      return;
+    }
+    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 && !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);
+}
+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) => {
+    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;
+  });
+}
+function sizeOf(m) {
+  const p = m.params;
+  const values = /* @__PURE__ */ new Map();
+  if (m.id === ID.rowAutoHeight) {
+    for (const { row, autoHeight } of p.rowsAutoHeightInfo ?? []) values.set(row, autoHeight);
+    return { axis: "row", attr: "ah", values };
+  }
+  const axis = m.id === ID.colWidth ? "col" : "row";
+  const field = m.id === ID.colWidth ? "colWidth" : m.id === ID.rowHeight ? "rowHeight" : "autoHeightInfo";
+  const value = p[field];
+  const [a0, a1] = S(axis);
+  for (const r of p.ranges ?? [])
+    for (let i = r[a0]; i <= r[a1]; i++) {
+      if (typeof value === "number") values.set(i, value);
+      else if (m.id === ID.rowIsAuto) values.set(i, value?.[i]);
+      else if (value?.[i] != null) values.set(i, value[i]);
+    }
+  return { axis, attr: m.id === ID.colWidth ? "w" : m.id === ID.rowHeight ? "h" : "ia", values };
+}
+function buildSize(template, values) {
+  if (values.size === 0) return null;
+  const p = template.params;
+  if (template.id === ID.rowAutoHeight)
+    return { id: template.id, params: { ...p, rowsAutoHeightInfo: [...values].sort((a, b) => a[0] - b[0]).map(([row, autoHeight]) => ({ row, autoHeight })) } };
+  const axis = template.id === ID.colWidth ? "col" : "row";
+  const field = template.id === ID.colWidth ? "colWidth" : template.id === ID.rowHeight ? "rowHeight" : "autoHeightInfo";
+  const [a0, a1] = S(axis);
+  const first = (p.ranges ?? [])[0] ?? { startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 };
+  const ranges = runs(values.keys()).map((r) => ({ ...first, [a0]: r.start, [a1]: r.start + r.count - 1 }));
+  const uniform = typeof p[field] === "number" ? p[field] : void 0;
+  const value = uniform !== void 0 && [...values.values()].every((v) => v === uniform) ? uniform : Object.fromEntries(values);
+  return { id: template.id, params: { ...p, ranges, [field]: value } };
+}
+function familyOf(id) {
+  const e = SHEET_MUTATIONS[id];
+  return e && e.kind === "covered" ? e.family : "";
+}
+function transformMutation(x, y, side) {
+  for (const m of [x, y]) {
+    const e = SHEET_MUTATIONS[m.id];
+    if (!e) return barrier2(`${m.id} is not in the registry`);
+    if (e.kind !== "covered") return barrier2(`${m.id}: ${e.kind === "barrier" ? `barrier until ${e.until} (${e.reason})` : "never travels"}`);
+    if (m.id === ID.values) {
+      const why = cellBarrier(m);
+      if (why) return barrier2(why);
+    }
+  }
+  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);
+  const sy = structuralOf(y);
+  const sx = structuralOf(x);
+  if (sx && sy) {
+    if (sx.axis !== sy.axis) return ok([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);
+  }
+  if (sy) {
+    if (fx === "merge") {
+      const kept = [];
+      const dropped = [];
+      for (const r of mergeRanges(x)) {
+        const t = mergeThrough(sy, r).range;
+        if (t) kept.push(t);
+        else dropped.push(rangeRef(sheetOf(x), r));
+      }
+      return ok(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]);
+      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 ok([x]);
+  }
+  if (sx) {
+    if (fy !== "merge" || y.id !== ID.addMerge) return ok([x]);
+    const remove = [];
+    const add = [];
+    for (const r of mergeRanges(y)) {
+      const t = mergeThrough(sx, r);
+      if (!t.fixup) continue;
+      remove.push(r);
+      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);
+    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);
+  }
+  if (fx === "cell" && fy === "cell") return transformCellsOverCells(x, y, side);
+  if (fx === "merge" && fy === "merge") {
+    const xr = mergeRanges(x);
+    const yr = mergeRanges(y);
+    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 (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);
+      }
+      const kept = xr.filter((r) => !hit(r));
+      return ok(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)) : []);
+      const kept = xr.filter((r) => !hit(r));
+      return ok(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)));
+    }
+    return ok([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 (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);
+    }
+    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);
+  }
+  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)}"`]);
+  }
+  return ok([x]);
+}
+var blocked = (p) => !Array.isArray(p);
+function tSeq(xs, ys, side, acc) {
+  if (xs.length === 0 || ys.length === 0) return [xs, ys];
+  if (xs.length === 1 && ys.length === 1) {
+    const a = transformMutation(xs[0], ys[0], side);
+    if (isBarrier(a)) return a;
+    const b = transformMutation(ys[0], xs[0], flip(side));
+    if (isBarrier(b)) return b;
+    acc.lost.push(...a.lost);
+    acc.dropped.push(...a.dropped);
+    return [a.op, b.op];
+  }
+  if (xs.length > 1) {
+    const first2 = tSeq([xs[0]], ys, side, acc);
+    if (blocked(first2)) return first2;
+    const rest2 = tSeq(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);
+  if (blocked(first)) return first;
+  const rest = tSeq(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);
+  if (blocked(r)) return r;
+  return { op: r[0], lost: [...new Set(acc.lost)], dropped: [...new Set(acc.dropped)] };
+}
+
+// src/univer/collab/sheets-ot/state-hash.ts
+var SHEET_LOCAL_SHEET_KEYS = ["zoomRatio", "scrollTop", "scrollLeft", "selections", "__collab"];
+var SHEET_LOCAL_KEYS = ["id", "rev", "__matrxCollabCovered", "__collab"];
+function sortDeep2(v) {
+  if (Array.isArray(v)) return v.map(sortDeep2);
+  if (v && typeof v === "object") {
+    const out = {};
+    for (const k of Object.keys(v).sort()) {
+      const x = v[k];
+      if (x === void 0 || x === null) continue;
+      if (Array.isArray(x) && x.length === 0) continue;
+      if (x && typeof x === "object" && !Array.isArray(x) && Object.keys(x).length === 0) continue;
+      out[k] = sortDeep2(x);
+    }
+    return out;
+  }
+  return v;
+}
+function parsedResource(data) {
+  if (typeof data !== "string") return data;
+  try {
+    return JSON.parse(data);
+  } catch {
+    return data;
+  }
+}
+function canonicalSheet(snapshot) {
+  const s = structuredClone(snapshot ?? {});
+  for (const k of SHEET_LOCAL_KEYS) delete s[k];
+  const styles = s.styles ?? {};
+  const deref = (v) => typeof v === "string" && styles[v] ? sortDeep2(styles[v]) : v;
+  delete s.styles;
+  for (const sheet of Object.values(s.sheets ?? {})) {
+    for (const k of SHEET_LOCAL_SHEET_KEYS) delete sheet[k];
+    if (sheet.defaultStyle) sheet.defaultStyle = deref(sheet.defaultStyle);
+    for (const key of ["rowData", "columnData"]) for (const v of Object.values(sheet[key] ?? {})) if (v?.s) v.s = deref(v.s);
+    const cd = sheet.cellData ?? {};
+    for (const row of Object.keys(cd)) {
+      for (const col of Object.keys(cd[row] ?? {})) {
+        const c = cd[row][col];
+        if (c?.s) c.s = deref(c.s);
+        if (c && (c.f || c.si)) {
+          delete c.v;
+          delete c.t;
+        }
+        if (!c || Object.keys(sortDeep2(c)).length === 0) delete cd[row][col];
+      }
+      if (Object.keys(cd[row] ?? {}).length === 0) delete cd[row];
+    }
+    if (Array.isArray(sheet.mergeData))
+      sheet.mergeData = sheet.mergeData.map((m) => JSON.stringify(sortDeep2(m))).sort().map((j) => JSON.parse(j));
+  }
+  if (Array.isArray(s.resources))
+    s.resources = s.resources.map((r) => ({ name: r.name, data: sortDeep2(parsedResource(r.data)) })).filter((r) => r.data != null && r.data !== "" && !(typeof r.data === "object" && Object.keys(r.data).length === 0)).sort((a, b) => String(a.name).localeCompare(String(b.name)));
+  if (Array.isArray(s.definedNames)) s.definedNames = [...s.definedNames].sort((x, y) => String(x.id).localeCompare(String(y.id)));
+  return sortDeep2(s);
+}
+var canonicalSheetString = (snapshot) => JSON.stringify(canonicalSheet(snapshot));
+async function sheetsStateHash(snapshot) {
+  const bytes = new TextEncoder().encode(canonicalSheetString(snapshot));
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+  return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/univer/collab/sheets-ot/room.ts
+var SHEETS_COLLAB_PROTO = 1;
+var SHEETS_EDIT_GROUP = "sheets.edit";
+var flip2 = (side) => side === "left" ? "right" : "left";
+var isNoopSheetOp = (op) => op == null || op.length === 0;
+function transformSheetOp(x, y, side) {
+  if (isNoopSheetOp(x) || isNoopSheetOp(y)) return { op: isNoopSheetOp(x) ? null : x, lost: [], dropped: [] };
+  const r = transformGroup(x, y, side);
+  if (isBarrier(r)) return r;
+  const back = transformGroup(y, x, flip2(side));
+  const lost = [.../* @__PURE__ */ new Set([...r.lost, ...isBarrier(back) ? [] : back.dropped])];
+  return { op: r.op.length ? r.op : null, lost, dropped: r.dropped };
+}
+function encodeSheetOp(op) {
+  return canonicalKeys([{ cmd: SHEETS_EDIT_GROUP, mutations: (op ?? []).map((m) => ({ id: m.id, params: m.params })) }]);
+}
+function decodeSheetOp(groups) {
+  const out = [];
+  for (const g of groups) for (const m of g.mutations) out.push({ id: m.id, params: m.params ?? {} });
+  return out.length ? out : null;
+}
+function undoStacksOf2(service) {
+  const s = service;
+  if (!s || !(s._undoStacks instanceof Map) || !(s._redoStacks instanceof Map)) return null;
+  return { undo: s._undoStacks, redo: s._redoStacks };
+}
+var CONTENT_TOUCH2 = CONTENT_KEYS.filter((k) => k !== "t");
+function travelingShape(m) {
+  const params = allowParams(m.id, m.params);
+  if (!params) return null;
+  if (m.params.isOverrideStyle) return null;
+  if (m.id === "sheet.mutation.set-range-values") {
+    const cells = structuredClone(params.cellValue ?? {});
+    for (const row of Object.values(cells))
+      for (const [c, v] of Object.entries(row)) {
+        if (!v) continue;
+        if (typeof v.s === "string") return null;
+        if (!CONTENT_TOUCH2.some((k) => k in v)) continue;
+        const full = {};
+        for (const k of CONTENT_KEYS) full[k] = v[k] !== void 0 ? v[k] : null;
+        if (full.v === null) delete full.t;
+        if ("s" in v) full.s = v.s;
+        row[c] = full;
+      }
+    return { id: m.id, params: { ...params, cellValue: cells } };
+  }
+  return { id: m.id, params };
+}
+function rebaseSheetUndoStack(items, remote, unitId) {
+  if (isNoopSheetOp(remote)) return 0;
+  let dropped = 0;
+  for (let i = items.length - 1; i >= 0; i--) {
+    const item = items[i];
+    let ok2 = true;
+    for (const key of ["undoMutations", "redoMutations"]) {
+      const list = item[key];
+      if (!ok2 || !list?.length) continue;
+      const isOperation = (id) => !SHEET_MUTATIONS[id] && id.includes(".operation.");
+      const operations = list.filter((m) => isOperation(m.id));
+      const shaped = list.filter((m) => !isOperation(m.id)).map(travelingShape);
+      if (shaped.some((m) => m === null)) {
+        ok2 = false;
+        continue;
+      }
+      if (!shaped.length) continue;
+      try {
+        const r = transformGroup(shaped, remote, "left");
+        if (isBarrier(r) || r.op.length === 0) {
+          ok2 = false;
+          continue;
+        }
+        if (JSON.stringify(r.op) === JSON.stringify(shaped)) continue;
+        item[key] = [...r.op.map((m) => ({ id: m.id, params: { ...forApply(m).params, unitId } })), ...operations];
+      } catch {
+        ok2 = false;
+      }
+    }
+    if (!ok2) {
+      items.splice(i, 1);
+      dropped++;
+    }
+  }
+  return dropped;
+}
+function createSheetsOtAdapter(port, hooks = {}) {
+  let queue = [];
+  let draining = false;
+  const applyNow = (op) => {
+    for (const m of op) port.applyRemote(m);
+    let dropped = 0;
+    for (const t of port.undoTargets()) {
+      const stacks = undoStacksOf2(t.service);
+      if (!stacks) continue;
+      for (const map of [stacks.undo, stacks.redo]) {
+        const items = map.get(t.unitId);
+        if (items?.length) dropped += rebaseSheetUndoStack(items, op, t.unitId);
+      }
+    }
+    hooks.onUndoRebased?.(dropped);
+    port.markDirty();
+  };
+  const adapter = {
+    version: SHEET_TRANSFORMER_VERSION,
+    transform: (x, y, side) => transformSheetOp(x, y, side),
+    compose: (a, b) => [...a ?? [], ...b ?? []],
+    isNoop: isNoopSheetOp,
+    encode: encodeSheetOp,
+    decode: decodeSheetOp,
+    apply(op) {
+      if (isNoopSheetOp(op)) return true;
+      if (port.busy() || queue.length) {
+        queue.push(op);
+        if (!draining) {
+          draining = true;
+          port.whenIdle(() => {
+            draining = false;
+            const held = queue;
+            queue = [];
+            for (const q of held) applyNow(q);
+          });
+        }
+        return true;
+      }
+      applyNow(op);
+      return true;
+    },
+    async load(snapshot) {
+      queue = [];
+      const current = port.snapshot();
+      if (!(current && snapshot && canonicalSheetString(current) === canonicalSheetString(snapshot))) port.load(snapshot);
+      for (const t of port.undoTargets()) {
+        const stacks = undoStacksOf2(t.service);
+        stacks?.undo.delete(t.unitId);
+        stacks?.redo.delete(t.unitId);
+      }
+    },
+    snapshot: () => port.snapshot(),
+    async hash() {
+      if (port.busy() || queue.length) {
+        await new Promise((resolve) => {
+          const done = setTimeout(resolve, 5e3);
+          port.whenIdle(() => {
+            clearTimeout(done);
+            setTimeout(resolve, 0);
+          });
+        });
+      }
+      return sheetsStateHash(port.snapshot());
+    },
+    held: () => queue.length,
+    rebaseLocalOverHeld(local) {
+      let op = local;
+      const next = [];
+      for (const q of queue) {
+        const l2 = transformSheetOp(op, q, "left");
+        const q2 = transformSheetOp(q, op, "right");
+        if ("barrier" in l2 || "barrier" in q2) return "barrier";
+        op = l2.op ?? [];
+        if (q2.op?.length) next.push(q2.op);
+      }
+      queue = next;
+      return op;
+    },
+    clearHeld() {
+      queue = [];
+    }
+  };
+  return adapter;
+}
+function openSheetsOtRoom(o) {
+  const { port } = o;
+  let session = null;
+  const adapter = createSheetsOtAdapter(port);
+  const notice = (n) => {
+    try {
+      o.onNotice?.(n);
+    } catch (err) {
+      console.warn("[sheets-ot] notice handler failed", err);
+    }
+  };
+  const onLocal = (e) => {
+    if (!session) return;
+    if (e.kind === "not_shared") {
+      notice({ kind: "not_shared", mutationId: e.mutationId });
+      adapter.clearHeld();
+      session.rebuild(`not_shared:${e.mutationId}`);
+      return;
+    }
+    if (!e.mutations.length) return;
+    for (const m of e.mutations) {
+      if (SHEET_MUTATIONS[m.id]?.kind !== "covered") {
+        notice({ kind: "not_shared", mutationId: m.id });
+        adapter.clearHeld();
+        session.rebuild(`not_shared:${m.id}`);
+        return;
+      }
+    }
+    let op = e.mutations;
+    let inverse = e.inverse;
+    if (adapter.held()) {
+      inverse = void 0;
+      const r = adapter.rebaseLocalOverHeld(op);
+      if (r === "barrier") {
+        adapter.clearHeld();
+        session.rebuild("held_barrier");
+        return;
+      }
+      op = r;
+      if (!op.length) return;
+    }
+    if (!session.local(op, { ...inverse !== void 0 ? { inverse } : {}, label: e.label ?? SHEETS_EDIT_GROUP })) notice({ kind: "not_live" });
+  };
+  const unsubLocal = port.onLocal(onLocal);
+  session = openOpSession2({
+    transport: o.transport,
+    adapter,
+    proto: SHEETS_COLLAB_PROTO,
+    clientId: o.clientId,
+    ...o.presence ? { presence: o.presence } : {},
+    onNotice: (n) => notice(n),
+    ...o.onIncident ? { onIncident: o.onIncident } : {},
+    ...o.onStatus ? { onStatus: o.onStatus } : {}
+  });
+  const isSaver = () => {
+    if (!o.presence) return true;
+    return o.presence.peers().every((p) => p.clientId === o.clientId || p.clientId > o.clientId);
+  };
+  return {
+    session,
+    isSaver,
+    async write(reason) {
+      if (!session) return false;
+      if (reason !== "manual" && !isSaver()) return false;
+      const out = await session.save();
+      if (out.saved) return true;
+      if (out.reason === "not_quiet" || out.reason === "changed") setTimeout(() => port.markDirty(), 1500);
+      return false;
+    },
+    async replace(snapshot) {
+      port.load(snapshot);
+      const loaded = port.snapshot();
+      if (!loaded) throw new Error("The workbook is not open in this tab.");
+      const stateHash = await sheetsStateHash(loaded);
+      await o.replace({ snapshot: loaded, stateHash, clientId: o.clientId });
+    },
+    stop() {
+      unsubLocal();
+      session?.close();
+    }
+  };
+}
+
+// src/univer/collab/sheets-ot/univer-port.ts
+var COMMAND = 0;
+var MUTATION = 2;
+var VALUES = "sheet.mutation.set-range-values";
+var ADD_MERGE = "sheet.mutation.add-worksheet-merge";
+var REMOVE_MERGE = "sheet.mutation.remove-worksheet-merge";
+var SHEET_NAME = "sheet.mutation.set-worksheet-name";
+var DEPTH_GUARD = /* @__PURE__ */ Symbol.for("ai-matrx.office.sheets.command-depth-guard");
+var json = (v) => v === void 0 ? v : JSON.parse(JSON.stringify(v));
+var flagged = (options) => {
+  const o = options;
+  return !!(o?.onlyLocal || o?.fromCollab);
+};
+function univerSheetsOtPort(o) {
+  const cs = o.commandService;
+  const listeners = /* @__PURE__ */ new Set();
+  const idle = [];
+  const pre = /* @__PURE__ */ new WeakMap();
+  const tracker = { stack: [], settle: () => settle() };
+  let group = null;
+  let applying = false;
+  const unitId = () => o.workbook()?.getUnitId() ?? null;
+  const mine = (params) => {
+    const u = unitId();
+    return !!u && !!params && typeof params === "object" && params.unitId === u;
+  };
+  const styleObject = (s) => {
+    if (typeof s !== "string") return s;
+    const found = o.workbook()?.getStyles().get(s);
+    return found ? json(found) : s;
+  };
+  const sheetNames = () => {
+    const out = {};
+    for (const ws of o.workbook()?.getSheets() ?? []) out[ws.getSheetId()] = ws.getName();
+    return out;
+  };
+  const definedNames = () => {
+    const u = unitId();
+    const map = u && o.definedNames?.(u) || {};
+    const out = {};
+    for (const [id, d] of Object.entries(map)) out[id] = String(d?.name ?? "");
+    return out;
+  };
+  const openGroup = (label) => ({ label, sheets: sheetNames(), names: definedNames(), mutations: [], inverses: [], notShared: null });
+  const emit = (e) => {
+    for (const l of [...listeners]) {
+      try {
+        l(e);
+      } catch (err) {
+        console.warn("[sheets-ot] local change handler failed", err);
+      }
+    }
+  };
+  const flush = () => {
+    const g = group;
+    group = null;
+    if (!g) return;
+    if (g.notShared) emit({ kind: "not_shared", mutationId: g.notShared, label: g.label });
+    else if (g.mutations.length) {
+      const mutations = annotateFormulas(g.mutations, g.sheets, g.names);
+      const known = g.inverses.every((i) => i !== void 0);
+      const inverse = known ? annotateFormulas(g.inverses.slice().reverse().flat(), g.sheets, g.names) : void 0;
+      emit({ kind: "group", mutations, ...inverse !== void 0 ? { inverse } : {}, label: g.label });
+    }
+  };
+  function settle() {
+    if (tracker.stack.length === 0) flush();
+    if (tracker.stack.length === 0 && !group) for (const fn of idle.splice(0)) fn();
+  }
+  const before = cs.beforeCommandExecuted((info, options) => {
+    if (info.type === COMMAND) {
+      if (tracker.stack.length === 0 && !group) group = openGroup(info.id);
+      tracker.stack.push(info.id);
+      return;
+    }
+    if (info.type !== MUTATION || applying || flagged(options) || !mine(info.params)) return;
+    const p = info.params;
+    const ws = o.workbook()?.getSheetBySheetId(String(p.subUnitId ?? ""));
+    if (!ws) return;
+    const record = { merges: json(ws.getMergeData() ?? []) };
+    if (info.id === VALUES) {
+      record.cells = /* @__PURE__ */ new Map();
+      const cells = p.cellValue ?? {};
+      for (const r of Object.keys(cells))
+        for (const c of Object.keys(cells[r] ?? {})) {
+          const raw = ws.getCellRaw(Number(r), Number(c));
+          const copy = raw ? json(raw) : null;
+          if (copy && "s" in copy) copy.s = styleObject(copy.s);
+          record.cells.set(`${r}:${c}`, copy);
+        }
+    }
+    if (info.id === SHEET_NAME) record.name = ws.getName();
+    pre.set(p, record);
+  });
+  const after = cs.onCommandExecuted((info) => {
+    if (info.type !== COMMAND) return;
+    const at = tracker.stack.lastIndexOf(info.id);
+    if (at >= 0) tracker.stack.splice(at, 1);
+    settle();
+  });
+  const guarded = cs;
+  if (!guarded[DEPTH_GUARD] && typeof cs.executeCommand === "function") {
+    const trackers = /* @__PURE__ */ new Set();
+    guarded[DEPTH_GUARD] = trackers;
+    const original = cs.executeCommand.bind(cs);
+    cs.executeCommand = async (id, params, options) => {
+      const depths = new Map([...trackers].map((t) => [t, t.stack.length]));
+      try {
+        return await original(id, params, options);
+      } finally {
+        for (const [t, d] of depths) {
+          if (t.stack.length > d) {
+            t.stack.length = d;
+            t.settle();
+          }
+        }
+      }
+    };
+  }
+  guarded[DEPTH_GUARD]?.add(tracker);
+  const capture = (info) => {
+    const entry = SHEET_MUTATIONS[info.id];
+    if (!entry) {
+      console.warn(`[sheets-ot] ${info.id} is not in the sheet mutation registry; it cannot be shared`);
+      return { m: null, inverse: void 0, notShared: info.id };
+    }
+    if (entry.kind === "never-travels") return { m: null, inverse: void 0 };
+    if (entry.kind === "barrier") return { m: null, inverse: void 0, notShared: info.id };
+    const raw = json(info.params);
+    const before2 = pre.get(info.params) ?? {};
+    const params = allowParams(info.id, raw);
+    if (!params) return { m: null, inverse: void 0, notShared: info.id };
+    const sheet = String(params.subUnitId ?? "");
+    const ws = o.workbook()?.getSheetBySheetId(sheet);
+    if (info.id === VALUES) {
+      const cells = params.cellValue ?? {};
+      const invCells = {};
+      let invKnown = !!before2.cells;
+      for (const r of Object.keys(cells))
+        for (const c of Object.keys(cells[r] ?? {})) {
+          let e = cells[r][c] ?? null;
+          const p = before2.cells?.get(`${r}:${c}`) ?? null;
+          if (e && "s" in e) {
+            e = { ...e, s: styleObject(e.s) };
+            if (raw.isOverrideStyle) {
+              const next = e.s && typeof e.s === "object" ? e.s : {};
+              const prev = p?.s && typeof p.s === "object" ? p.s : {};
+              const merged = { ...next };
+              for (const k of Object.keys(prev)) if (!(k in next)) merged[k] = null;
+              e.s = Object.keys(merged).length ? merged : null;
+            }
+          }
+          const post = ws?.getCellRaw(Number(r), Number(c)) ?? null;
+          const done = completeCellContent(e, post ? json(post) : null);
+          cells[r][c] = done;
+          if (!invKnown) continue;
+          let inv;
+          if (done === null) inv = p ? { ...fullContent(p), ...p.s !== void 0 ? { s: p.s } : {} } : null;
+          else {
+            inv = {};
+            if (CONTENT_KEYS.some((k) => k !== "t" && k in done)) Object.assign(inv, fullContent(p));
+            if ("s" in done) inv.s = p?.s ?? null;
+          }
+          (invCells[r] ??= {})[c] = inv;
+        }
+      return {
+        m: { id: info.id, params: { ...params, cellValue: cells } },
+        inverse: invKnown ? [{ id: VALUES, params: { subUnitId: sheet, cellValue: invCells } }] : void 0
+      };
+    }
+    if (info.id === REMOVE_MERGE) {
+      const exact = exactMergeRemovals([{ id: info.id, params }], { [sheet]: before2.merges ?? ws?.getMergeData() ?? [] });
+      const m2 = exact[0] ?? null;
+      if (!m2) return { m: null, inverse: void 0 };
+      return { m: m2, inverse: [{ id: ADD_MERGE, params: { subUnitId: sheet, ranges: json(m2.params.ranges) } }] };
+    }
+    const m = { id: info.id, params };
+    switch (info.id) {
+      case "sheet.mutation.insert-row":
+        return { m, inverse: [{ id: "sheet.mutation.remove-rows", params: { subUnitId: sheet, range: json(params.range) } }] };
+      case "sheet.mutation.insert-col":
+        return { m, inverse: [{ id: "sheet.mutation.remove-col", params: { subUnitId: sheet, range: json(params.range) } }] };
+      case ADD_MERGE:
+        return { m, inverse: [{ id: REMOVE_MERGE, params: { subUnitId: sheet, ranges: json(params.ranges) } }] };
+      case SHEET_NAME:
+        return { m, inverse: before2.name !== void 0 ? [{ id: SHEET_NAME, params: { subUnitId: sheet, name: before2.name } }] : void 0 };
+      default:
+        return { m, inverse: void 0 };
+    }
+  };
+  const collab = cs.onMutationExecutedForCollab((info, options) => {
+    if (applying || flagged(options) || !mine(info.params)) return;
+    const lone = !group;
+    if (lone) group = openGroup(null);
+    const g = group;
+    if (!g.notShared) {
+      const r = capture(info);
+      if (r.notShared) g.notShared = r.notShared;
+      else if (r.m) {
+        g.mutations.push(r.m);
+        g.inverses.push(r.inverse);
+      }
+    }
+    if (lone && tracker.stack.length === 0) settle();
+  });
+  return {
+    onLocal(listener) {
+      listeners.add(listener);
+      return () => void listeners.delete(listener);
+    },
+    busy: () => tracker.stack.length > 0 || group !== null,
+    whenIdle(fn) {
+      if (tracker.stack.length === 0 && !group) fn();
+      else idle.push(fn);
+    },
+    applyRemote(m) {
+      const u = unitId();
+      if (!u) throw new Error("no workbook is mounted");
+      const a = forApply(m);
+      applying = true;
+      try {
+        const ok2 = cs.syncExecuteCommand(a.id, { ...json(a.params), unitId: u }, { onlyLocal: true, fromCollab: true });
+        if (ok2 === false) throw new Error(`"${m.id}" was refused by the editor`);
+      } finally {
+        applying = false;
+      }
+    },
+    snapshot() {
+      const wb = o.workbook();
+      if (!wb) return null;
+      const saved = o.saveUnit?.(wb.getUnitId()) ?? wb.getSnapshot();
+      return saved ? json(saved) : null;
+    },
+    load(snapshot) {
+      group = null;
+      applying = true;
+      try {
+        o.load(snapshot);
+      } finally {
+        applying = false;
+      }
+    },
+    undoTargets() {
+      const u = unitId();
+      const service = o.undoRedo?.();
+      return u && service ? [{ service, unitId: u }] : [];
+    },
+    markDirty: () => o.markDirty(),
+    dispose() {
+      before.dispose();
+      after.dispose();
+      collab.dispose();
+      guarded[DEPTH_GUARD]?.delete(tracker);
+      listeners.clear();
+    }
+  };
+}
+function fullContent(cell) {
+  const out = {};
+  for (const k of CONTENT_KEYS) out[k] = cell && cell[k] !== void 0 ? cell[k] : null;
+  if (out.v === null) delete out.t;
+  return out;
+}
+
+// src/sheets/workbook-ot-room.ts
+import * as Y3 from "yjs";
+import { Awareness as Awareness3 } from "y-protocols/awareness";
+import {
+  awarenessOpPresence as awarenessOpPresence2,
+  collabReplace as collabReplace3,
+  collabRoomExists as collabRoomExists3,
+  SupabaseYjsProvider as SupabaseYjsProvider2,
+  supabaseOpTransport as supabaseOpTransport2
+} from "@ai-matrx/data/realtime/collab";
+
+// src/sheets/ports.ts
+var SLOT2 = /* @__PURE__ */ Symbol.for("ai-matrx.office.sheets-host");
+var slot2 = () => {
+  const g = globalThis;
+  return g[SLOT2] ??= {};
+};
+function getSheetsHost() {
+  const ports = slot2().ports;
+  if (!ports) throw new Error("@ai-matrx/office/sheets: configureSheetsHost(ports) was not called before the workbook service ran.");
+  return ports;
+}
+
+// src/sheets/workbook-service.ts
+import { requireOrganizationContext as requireOrganizationContext2 } from "@ai-matrx/api";
+import { getClaimsUser as getClaimsUser2 } from "@ai-matrx/auth";
+import { tryWriteOne as tryWriteOne2, writeOneRow as writeOneRow2 } from "@ai-matrx/data/db";
+var db3 = () => getSheetsHost().getSupabase();
+async function getLatestSnapshot(workbookId) {
+  const { data, error } = await db3().schema("workbench").from("udt_workbook_snapshots").select("*").eq("workbook_id", workbookId).order("created_at", { ascending: false }).limit(1).maybeSingle();
+  if (error) return { success: false, error: error.message };
+  return { success: true, data: data ?? null };
+}
+async function saveSnapshot(args) {
+  const { data: userData } = await getClaimsUser2(db3());
+  const { data: workbook, error: workbookError } = await db3().schema("workbench").from("udt_workbooks").select("organization_id").eq("id", args.workbookId).single();
+  if (workbookError) return { success: false, error: workbookError.message };
+  const { data, error } = await db3().schema("workbench").from("udt_workbook_snapshots").insert({
+    organization_id: workbook.organization_id,
+    workbook_id: args.workbookId,
+    snapshot: args.snapshot,
+    label: args.label ?? null,
+    origin: args.origin ?? "autosave",
+    created_by: userData?.user?.id ?? null
+  }).select("*").single();
+  if (error) return { success: false, error: error.message };
+  await db3().schema("workbench").from("udt_workbooks").update({ updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", args.workbookId);
+  return { success: true, data };
+}
+
+// src/sheets/workbook-ot-room.ts
+var db4 = () => getSheetsHost().getSupabase();
+async function loadSnapshotRow2(workbookId, ref) {
+  if (ref === "none") {
+    const res = await getLatestSnapshot(workbookId);
+    if (!res.success) throw new Error(res.error);
+    return res.data?.snapshot ?? null;
+  }
+  const { data, error } = await getSheetsHost().getSupabase().schema("workbench").from("udt_workbook_snapshots").select("snapshot").eq("id", ref).maybeSingle();
+  if (error) throw new Error(error.message);
+  if (!data) throw new Error(`The saved version ${ref} of this workbook is missing.`);
+  return data.snapshot ?? null;
+}
+async function workbookUsesOrderedRoom(workbookId, knob, isNewWorkbook) {
+  try {
+    if (await collabRoomExists3(db4(), workbookId)) return true;
+  } catch (err) {
+    console.warn("[workbook] could not ask whether this workbook has a co-editing room; opening the relay room", err);
+    return false;
+  }
+  if (knob === "all") return true;
+  if (knob === "new") return isNewWorkbook();
+  return false;
+}
+function pickColor3(uid) {
+  const palette = ["#ef4444", "#f59e0b", "#10b981", "#3b82f6", "#8b5cf6", "#ec4899", "#14b8a6", "#f97316"];
+  let h = 2166136261;
+  for (let i = 0; i < uid.length; i++) {
+    h ^= uid.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return palette[Math.abs(h) % palette.length] ?? "#ec4899";
+}
+async function startWorkbookOtRoom(port, o) {
+  const latest = await getLatestSnapshot(o.workbookId);
+  if (!latest.success) throw new Error(latest.error);
+  if (!latest.data) {
+    const mounted = port.snapshot();
+    if (mounted) {
+      const saved = await saveSnapshot({ workbookId: o.workbookId, snapshot: mounted, origin: "autosave" });
+      if (!saved.success) throw new Error(saved.error);
+    }
+  }
+  const doc = new Y3.Doc();
+  const awareness = new Awareness3(doc);
+  awareness.setLocalState({
+    uid: o.uid,
+    clientId: o.clientId,
+    name: o.displayName ?? o.uid.slice(0, 8),
+    color: pickColor3(o.uid),
+    sheetId: null,
+    row: null,
+    col: null,
+    ts: Date.now()
+  });
+  const publishAwareness = () => o.onAwareness?.(new Map(awareness.getStates()));
+  awareness.on("change", publishAwareness);
+  const provider = new SupabaseYjsProvider2({
+    workbookId: o.workbookId,
+    clientId: o.clientId,
+    doc,
+    awareness,
+    ...o.readAntiEntropyIntervalMs ? { readAntiEntropyIntervalMs: o.readAntiEntropyIntervalMs } : {}
+  });
+  await provider.connect();
+  publishAwareness();
+  const client = db4();
+  const room = openSheetsOtRoom({
+    port,
+    clientId: o.clientId,
+    presence: awarenessOpPresence2(awareness),
+    transport: supabaseOpTransport2({
+      client,
+      roomId: o.workbookId,
+      kind: "univer_sheet",
+      store: {
+        loadSnapshot: (ref) => loadSnapshotRow2(o.workbookId, ref),
+        async writeSnapshot(snapshot) {
+          const res = await saveSnapshot({ workbookId: o.workbookId, snapshot, origin: "autosave" });
+          if (!res.success) throw new Error(res.error);
+          return res.data.id;
+        }
+      }
+    }),
+    replace: ({ snapshot, stateHash, clientId }) => collabReplace3(client, { roomId: o.workbookId, snapshot, stateHash, origin: "restore", clientId }),
+    ...o.onNotice ? { onNotice: o.onNotice } : {},
+    ...o.onIncident ? { onIncident: o.onIncident } : {},
+    ...o.onStatus ? { onStatus: o.onStatus } : {}
+  });
+  await room.session.ready;
+  return {
+    session: room.session,
+    isSaver: () => room.isSaver(),
+    write: (reason) => room.write(reason),
+    replace: (snapshot) => room.replace(snapshot),
+    setCursor(c) {
+      const current = awareness.getLocalState() ?? {};
+      awareness.setLocalState({ ...current, sheetId: c.sheetId, row: c.row, col: c.col, ts: Date.now() });
+    },
+    stop() {
+      room.stop();
+      port.dispose?.();
+      awareness.off("change", publishAwareness);
+      provider.disconnect();
+      awareness.destroy();
+      doc.destroy();
+    }
+  };
+}
 export {
   COLLAB_COVERED_KEY,
   DOCS_COLLAB_PROTO,
@@ -1557,29 +3453,43 @@ export {
   DOC_LOCAL_KEYS,
   RICH_TEXT_EDITING,
   SENDER_VIEW_PARAMS,
+  SHEETS_COLLAB_PROTO,
+  SHEETS_EDIT_GROUP,
   WorkbookCollabSession,
   applyDocsOp,
   canonicalDocsSnapshot,
   canonicalDocsString,
   canonicalKeys,
+  canonicalSheet,
+  canonicalSheetString,
   composeDocsOps,
+  createSheetsOtAdapter,
+  decodeSheetOp,
   docsStateHash,
   documentOtFactory,
   documentUsesOrderedRoom,
   dropEmptyStyleRetains,
+  encodeSheetOp,
   invertDocsOp,
   isCellEditorScratch,
   isNoopDocsOp,
   normalizeDocsOp,
   openDocsOtRoom,
+  openSheetsOtRoom,
+  rebaseSheetUndoStack,
   rebaseUndoStack,
   restoreDocumentSnapshot,
+  sheetsStateHash,
   stampCovered,
   stampDeterministicIds,
+  startWorkbookOtRoom,
   stripSenderView,
   takeCovered,
   transformDocsOp,
+  transformSheetOp,
   transformTextX,
-  undoStacksOf
+  undoStacksOf,
+  univerSheetsOtPort,
+  workbookUsesOrderedRoom
 };
 //# sourceMappingURL=univer-collab.js.map