@ai-matrx/office 0.8.26 → 0.8.28

package/dist/univer-collab.cjs

@@ -39,6 +39,7 @@ __export(collab_exports, {
   SENDER_VIEW_PARAMS: () => SENDER_VIEW_PARAMS,
   SHEETS_COLLAB_PROTO: () => SHEETS_COLLAB_PROTO,
   SHEETS_EDIT_GROUP: () => SHEETS_EDIT_GROUP,
+  SHEETS_READABLE_PROTOS: () => SHEETS_READABLE_PROTOS,
   WorkbookCollabSession: () => WorkbookCollabSession,
   applyDocsOp: () => applyDocsOp,
   asLoadedDocsSnapshot: () => asLoadedDocsSnapshot,
@@ -1166,6 +1167,38 @@ function stampDeterministicIds(snapshot) {
 
 // src/univer/collab/docs-ot/room.ts
 var import_collab2 = require("@ai-matrx/data/realtime/collab");
+
+// src/docs/comment-anchors.ts
+var import_core5 = require("@univerjs/core");
+var COMMENT_ANCHOR_RANGE_TYPE = import_core5.CustomRangeType.COMMENT;
+var RETAIN_KEYS = /* @__PURE__ */ new Set(["t", "len", "body", "coverType"]);
+var RANGE_KEYS = /* @__PURE__ */ new Set(["rangeId", "rangeType", "startIndex", "endIndex", "properties"]);
+var isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var keysOf = (o) => Object.keys(o).filter((k) => o[k] !== void 0);
+function isDocsAnchorOnlyOp(op) {
+  if (!Array.isArray(op) || op.length !== 2 || op[0] !== "body") return false;
+  const x = op[1];
+  if (!isObj(x) || x.et !== "text-x" || !Array.isArray(x.e) || x.e.length === 0) return false;
+  if (keysOf(x).some((k) => k !== "et" && k !== "e")) return false;
+  for (const c of x.e) {
+    if (!isObj(c) || c.t !== "r" || typeof c.len !== "number") return false;
+    if (keysOf(c).some((k) => !RETAIN_KEYS.has(k))) return false;
+    if ("coverType" in c && typeof c.coverType !== "number") return false;
+    if ("body" in c) {
+      const b = c.body;
+      if (!isObj(b) || keysOf(b).some((k) => k !== "dataStream" && k !== "customRanges")) return false;
+      if (b.dataStream !== void 0 && b.dataStream !== "") return false;
+      if (!Array.isArray(b.customRanges) || b.customRanges.length === 0) return false;
+      for (const r of b.customRanges) {
+        if (!isObj(r) || r.rangeType !== COMMENT_ANCHOR_RANGE_TYPE) return false;
+        if (keysOf(r).some((k) => !RANGE_KEYS.has(k))) return false;
+      }
+    }
+  }
+  return true;
+}
+
+// src/univer/collab/docs-ot/room.ts
 var RICH_TEXT_EDITING = "doc.mutation.rich-text-editing";
 var DOCS_COLLAB_PROTO = 1;
 function canonicalKeys(v) {
@@ -1266,6 +1299,7 @@ function openDocsOtRoom(o) {
       return { op: isNoopDocsOp(r.op) ? null : r.op, lost: r.lost };
     },
     compose: (a, b) => composeDocsOps(a, b),
+    isAnchorOnly: (op) => isDocsAnchorOnlyOp(op),
     isNoop: (op) => isNoopDocsOp(op),
     encode: (op) => [{ cmd: "docs.edit", mutations: [{ id: RICH_TEXT_EDITING, params: { segmentId: "", actions: canonicalKeys(op) } }] }],
     decode(groups) {
@@ -1412,7 +1446,7 @@ var import_awareness2 = require("y-protocols/awareness");
 var import_collab3 = require("@ai-matrx/data/realtime/collab");
 
 // src/docs/remote-carets.ts
-var import_core5 = require("@univerjs/core");
+var import_core6 = require("@univerjs/core");
 var CARET_HEARTBEAT_MS = 2e3;
 var CARET_STALE_MS = 12e3;
 var CARET_MAX_RANGES = 4;
@@ -1430,8 +1464,8 @@ function movePeerRangesThroughBodyEdit(ranges, actions) {
   const e = sub.e;
   return ranges.map((r) => {
     const collapsed = r.start === r.end;
-    const start = import_core5.TextX.transformPosition(e, r.start, false);
-    return { start, end: collapsed ? start : import_core5.TextX.transformPosition(e, r.end, true) };
+    const start = import_core6.TextX.transformPosition(e, r.start, false);
+    return { start, end: collapsed ? start : import_core6.TextX.transformPosition(e, r.end, true) };
   });
 }
 var sameRanges = (a, b) => a.length === b.length && a.every((r, i) => r.start === b[i].start && r.end === b[i].end);
@@ -1558,10 +1592,23 @@ async function loadSnapshotRow(documentId, ref) {
   if (!data) throw new Error(`The saved version ${ref} of this document is missing.`);
   return data.snapshot ?? null;
 }
-async function documentUsesOrderedRoom(documentId, knob, isNewDocument) {
+async function deviceHoldsBuffer(key) {
+  if (!key || typeof indexedDB === "undefined") return false;
+  try {
+    const store = (0, import_collab3.createIndexedDbOfflineStore)();
+    return await store.load(key) != null || await store.load((0, import_collab3.refusedKey)(key)) != null;
+  } catch {
+    return false;
+  }
+}
+async function documentUsesOrderedRoom(documentId, knob, isNewDocument, offlineKey) {
   try {
     if (await (0, import_collab3.collabRoomExists)(db2(), documentId)) return true;
   } catch (err) {
+    if (await deviceHoldsBuffer(offlineKey)) {
+      console.warn("[document] could not ask whether this document has a co-editing room; unsent edits on this device say it does", err);
+      return true;
+    }
     console.warn("[document] could not ask whether this document has a co-editing room; opening the relay room", err);
     return false;
   }
@@ -1840,16 +1887,17 @@ var SHEET_MUTATIONS = {
   "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),
+  // ── covered (C5d): ranged resources, transformed by ranged-resources.ts ──
+  "sheet.mutation.add-conditional-rule": covered("cf", "rule", "derived"),
+  "sheet.mutation.set-conditional-rule": covered("cf", "cfId", "rule", "derived"),
+  "sheet.mutation.delete-conditional-rule": covered("cf", "cfId", "derived"),
   "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),
+  "data-validation.mutation.addRule": covered("dv", "rule", "index", "source", "derived"),
+  "data-validation.mutation.updateRule": covered("dv", "ruleId", "payload", "source", "derived"),
+  "data-validation.mutation.removeRule": covered("dv", "ruleId", "source", "derived"),
+  "sheet.mutation.set-filter-range": covered("filter", "range", "derived"),
+  "sheet.mutation.set-filter-criteria": covered("filter", "col", "criteria", "reCalc", "derived"),
+  "sheet.mutation.remove-filter": covered("filter", "derived"),
   "sheet.mutation.add-table": barrier("C5c", RESOURCE),
   "sheet.mutation.delete-table": barrier("C5c", RESOURCE),
   "sheet.mutation.set-sheet-table": barrier("C5c", RESOURCE),
@@ -1996,7 +2044,7 @@ function transformAxis(x, y, side) {
 }
 
 // src/collab/sheets/transform/formula.ts
-var import_core6 = require("@univerjs/core");
+var import_core7 = require("@univerjs/core");
 var import_engine_formula = require("@univerjs/engine-formula");
 var import_sheets = require("@univerjs/sheets");
 var REF_ERROR = "#REF!";
@@ -2048,8 +2096,8 @@ function referencedSheetNames(text) {
   }
   return [...out];
 }
-var fullRowsRange = (start, count) => ({ startRow: start, endRow: start + count - 1, startColumn: 0, endColumn: FULL, rangeType: import_core6.RANGE_TYPE.ROW });
-var fullColsRange = (start, count) => ({ startRow: 0, endRow: FULL, startColumn: start, endColumn: start + count - 1, rangeType: import_core6.RANGE_TYPE.COLUMN });
+var fullRowsRange = (start, count) => ({ startRow: start, endRow: start + count - 1, startColumn: 0, endColumn: FULL, rangeType: import_core7.RANGE_TYPE.ROW });
+var fullColsRange = (start, count) => ({ startRow: 0, endRow: FULL, startColumn: start, endColumn: start + count - 1, rangeType: import_core7.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) {
@@ -2058,9 +2106,9 @@ function startEnd(r) {
 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 === import_core6.RANGE_TYPE.COLUMN && from.rangeType === import_core6.RANGE_TYPE.COLUMN || startRow >= fromStartRow && endRow <= fromEndRow;
-  const columnsCover = () => origin.rangeType === import_core6.RANGE_TYPE.ROW && from.rangeType === import_core6.RANGE_TYPE.ROW || startColumn >= fromStartColumn && endColumn <= fromEndColumn;
-  const allCover = () => origin.rangeType === import_core6.RANGE_TYPE.ALL && from.rangeType === import_core6.RANGE_TYPE.ALL;
+  const rowsCover = () => origin.rangeType === import_core7.RANGE_TYPE.COLUMN && from.rangeType === import_core7.RANGE_TYPE.COLUMN || startRow >= fromStartRow && endRow <= fromEndRow;
+  const columnsCover = () => origin.rangeType === import_core7.RANGE_TYPE.ROW && from.rangeType === import_core7.RANGE_TYPE.ROW || startColumn >= fromStartColumn && endColumn <= fromEndColumn;
+  const allCover = () => origin.rangeType === import_core7.RANGE_TYPE.ALL && from.rangeType === import_core7.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;
@@ -2071,14 +2119,14 @@ function checkMoveEdge(origin, from) {
 function getMoveNewRange(moveEdge, result, from, to, origin, remain) {
   const { startRow, endRow, startColumn, endColumn, rangeType } = startEnd(result);
   const f = startEnd(from);
-  const fromRangeType = from.rangeType ?? import_core6.RANGE_TYPE.NORMAL;
+  const fromRangeType = from.rangeType ?? import_core7.RANGE_TYPE.NORMAL;
   const t = startEnd(to);
   const rm = startEnd(remain);
   const o = startEnd(origin);
-  const originRangeType = origin.rangeType ?? import_core6.RANGE_TYPE.NORMAL;
+  const originRangeType = origin.rangeType ?? import_core7.RANGE_TYPE.NORMAL;
   const newRange = { ...origin };
-  const rowsCover = () => rangeType === import_core6.RANGE_TYPE.COLUMN && originRangeType === import_core6.RANGE_TYPE.COLUMN || startColumn >= o.startColumn && endColumn <= o.endColumn;
-  const columnsCover = () => rangeType === import_core6.RANGE_TYPE.ROW && originRangeType === import_core6.RANGE_TYPE.ROW || startRow >= o.startRow && endRow <= o.endRow;
+  const rowsCover = () => rangeType === import_core7.RANGE_TYPE.COLUMN && originRangeType === import_core7.RANGE_TYPE.COLUMN || startColumn >= o.startColumn && endColumn <= o.endColumn;
+  const columnsCover = () => rangeType === import_core7.RANGE_TYPE.ROW && originRangeType === import_core7.RANGE_TYPE.ROW || startRow >= o.startRow && endRow <= o.endRow;
   if (moveEdge === 0) {
     if (!rowsCover()) return void 0;
     if (startRow < o.startRow) newRange.startRow = startRow;
@@ -2101,7 +2149,7 @@ function getMoveNewRange(moveEdge, result, from, to, origin, remain) {
     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 === import_core6.RANGE_TYPE.ROW && originRangeType === import_core6.RANGE_TYPE.ROW) {
+  } else if (f.startColumn <= o.startColumn && f.endColumn >= o.endColumn || fromRangeType === import_core7.RANGE_TYPE.ROW && originRangeType === import_core7.RANGE_TYPE.ROW) {
     const n = f.endRow - f.startRow + 1;
     if (from.endRow < o.startRow) {
       if (t.startRow >= o.startRow) newRange.startRow -= n;
@@ -2113,7 +2161,7 @@ function getMoveNewRange(moveEdge, result, from, to, origin, remain) {
       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 === import_core6.RANGE_TYPE.COLUMN && originRangeType === import_core6.RANGE_TYPE.COLUMN) {
+  } else if (f.startRow <= o.startRow && f.endRow >= o.endRow || fromRangeType === import_core7.RANGE_TYPE.COLUMN && originRangeType === import_core7.RANGE_TYPE.COLUMN) {
     const n = f.endColumn - f.startColumn + 1;
     if (from.endColumn < o.startColumn) {
       if (t.startColumn >= o.startColumn) newRange.startColumn -= n;
@@ -2135,7 +2183,7 @@ 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 ? (0, import_sheets.handleInsertRow)({ id: import_sheets.EffectRefRangId.InsertRowCommandId, params: { range: r, unitId: "", subUnitId: "", direction: import_core6.Direction.DOWN } }, range) : (0, import_sheets.handleInsertCol)({ id: import_sheets.EffectRefRangId.InsertColCommandId, params: { range: r, unitId: "", subUnitId: "", direction: import_core6.Direction.RIGHT } }, range);
+    const ops2 = isRow ? (0, import_sheets.handleInsertRow)({ id: import_sheets.EffectRefRangId.InsertRowCommandId, params: { range: r, unitId: "", subUnitId: "", direction: import_core7.Direction.DOWN } }, range) : (0, import_sheets.handleInsertCol)({ id: import_sheets.EffectRefRangId.InsertColCommandId, params: { range: r, unitId: "", subUnitId: "", direction: import_core7.Direction.RIGHT } }, range);
     const res2 = (0, import_sheets.runRefRangeMutations)(ops2, range);
     return res2 == null ? void 0 : { ...range, ...res2 };
   }
@@ -2148,11 +2196,11 @@ function moveRange(range, axis, op) {
   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 = (0, import_core6.getIntersectRange)(range, from);
+  let remain = (0, import_core7.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: import_core6.RANGE_TYPE.NORMAL };
+  remain ??= { startRow: range.startRow, endRow: range.endRow, startColumn: range.startColumn, endColumn: range.endColumn, rangeType: import_core7.RANGE_TYPE.NORMAL };
   const ops = isRow ? (0, import_sheets.handleMoveRows)({ id: import_sheets.EffectRefRangId.MoveRowsCommandId, params: { toRange: to, fromRange: from } }, remain) : (0, import_sheets.handleMoveCols)({ id: import_sheets.EffectRefRangId.MoveColsCommandId, params: { toRange: to, fromRange: from } }, remain);
   const res = (0, import_sheets.runRefRangeMutations)(ops, remain);
   if (res == null) return REF_ERROR;
@@ -2182,8 +2230,11 @@ function rewriteFormula(text, ctx, change) {
     if (change.kind === "rename") {
       if (!sheetName) continue;
       token = (0, import_engine_formula.serializeRangeToRefString)({ range, sheetName: change.name, unitId });
+    } else if (change.kind === "remove-sheet") {
+      if (!sheetName) continue;
+      token = REF_ERROR;
     } else {
-      const moved = moveRange(import_core6.Rectangle.moveOffset(range, 0, 0), change.axis, change.op);
+      const moved = moveRange(import_core7.Rectangle.moveOffset(range, 0, 0), change.axis, change.op);
       if (moved === void 0) continue;
       token = moved === REF_ERROR ? REF_ERROR : (0, import_engine_formula.serializeRangeToRefString)({ range: moved, sheetName: target === ctx.ownSheet && !ctx.keepQualifier ? "" : sheetName, unitId });
     }
@@ -2200,6 +2251,10 @@ function rewriteFormula(text, ctx, change) {
   return { text: out, changed: out !== text };
 }
 function refSheetsAfter(refSheets, change) {
+  if (change.kind === "remove-sheet" && refSheets) {
+    if (!Object.values(refSheets).includes(change.sheet)) return refSheets;
+    return Object.fromEntries(Object.entries(refSheets).map(([n, id]) => [n, id === change.sheet ? null : id]));
+  }
   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;
@@ -2217,6 +2272,9 @@ function refSheetsFor(texts, sheets) {
 
 // src/collab/sheets/comment-anchor-transform.ts
 var SET_SHEET_COMMENT_ANCHOR = "matrx.mutation.set-comment-anchor";
+function isSheetsAnchorOnlyOp(op) {
+  return !!op && op.length > 0 && op.every((m) => m.id === SET_SHEET_COMMENT_ANCHOR);
+}
 var REMOVE_SHEET = "sheet.mutation.remove-sheet";
 function structuralAxisOp(id, params) {
   const p = params;
@@ -2283,8 +2341,111 @@ function transformCommentAnchor(x, y, side) {
   return ok([moved === cell ? x : { id: x.id, params: { ...x.params, cell: moved } }]);
 }
 
+// src/collab/sheets/transform/ranged-resources.ts
+var specs = /* @__PURE__ */ new Map();
+var byId = /* @__PURE__ */ new Map();
+function registerRangedResource(spec) {
+  specs.set(spec.family, spec);
+  for (const id of Object.keys(spec.ids)) byId.set(id, spec);
+}
+var rangedSpecOf = (id) => byId.get(id);
+var cfRule = (m) => m.params.rule ?? {};
+var CF_FORMULA = (r) => {
+  const rule = r.rule ?? {};
+  if (rule.type === "highlightCell" && rule.subType === "formula") return true;
+  return JSON.stringify(rule).includes('"type":"formula"');
+};
+registerRangedResource({
+  family: "cf",
+  ids: { "sheet.mutation.add-conditional-rule": "add", "sheet.mutation.set-conditional-rule": "set", "sheet.mutation.delete-conditional-rule": "remove" },
+  keys: (m) => [String(m.id === "sheet.mutation.add-conditional-rule" ? cfRule(m).cfId : m.params.cfId)],
+  rects: (m) => cfRule(m).ranges ?? null,
+  withRects: (m, rects) => ({ id: m.id, params: { ...m.params, rule: { ...cfRule(m), ranges: rects } } }),
+  setFor: (m, rects) => ({
+    id: "sheet.mutation.set-conditional-rule",
+    params: { subUnitId: m.params.subUnitId, cfId: cfRule(m).cfId ?? m.params.cfId, rule: { ...cfRule(m), ranges: rects }, derived: true }
+  }),
+  removeOf: (sheet, key) => ({ id: "sheet.mutation.delete-conditional-rule", params: { subUnitId: sheet, cfId: key, derived: true } }),
+  hasFormula: (m) => CF_FORMULA(cfRule(m)),
+  orderedAdds: true
+});
+var DV = { add: "data-validation.mutation.addRule", update: "data-validation.mutation.updateRule", remove: "data-validation.mutation.removeRule" };
+var DV_RANGE = 1;
+var DV_FACETS = { 0: "setting", 1: "range", 2: "options", 3: "all" };
+var dvPayload = (m) => m.params.payload ?? {};
+var dvFormula = (o) => !!o && [o.formula1, o.formula2].some((f) => typeof f === "string" && f.trim().startsWith("="));
+registerRangedResource({
+  family: "dv",
+  ids: { [DV.add]: "add", [DV.update]: "set", [DV.remove]: "remove" },
+  keys: (m) => {
+    if (m.id === DV.add) return [String((m.params.rule ?? {}).uid)];
+    const id = m.params.ruleId;
+    return Array.isArray(id) ? id.map(String) : [String(id)];
+  },
+  facet: (m) => m.id === DV.update ? DV_FACETS[Number(dvPayload(m).type)] ?? "all" : "all",
+  rects: (m) => {
+    if (m.id === DV.add) return m.params.rule?.ranges ?? null;
+    if (m.id === DV.update && dvPayload(m).type === DV_RANGE) return dvPayload(m).payload ?? null;
+    if (m.id === DV.update && dvPayload(m).type === 3) return (dvPayload(m).payload ?? {}).ranges ?? null;
+    return null;
+  },
+  withRects: (m, rects) => {
+    if (m.id === DV.add) return { id: m.id, params: { ...m.params, rule: { ...m.params.rule, ranges: rects } } };
+    const p = dvPayload(m);
+    return { id: m.id, params: { ...m.params, payload: p.type === DV_RANGE ? { ...p, payload: rects } : { ...p, payload: { ...p.payload, ranges: rects } } } };
+  },
+  setFor: (m, rects) => ({
+    id: DV.update,
+    params: { subUnitId: m.params.subUnitId, ruleId: m.id === DV.add ? (m.params.rule ?? {}).uid : m.params.ruleId, payload: { type: DV_RANGE, payload: rects }, derived: true }
+  }),
+  removeOf: (sheet, key) => ({ id: DV.remove, params: { subUnitId: sheet, ruleId: key, derived: true } }),
+  withoutKeys: (m, keys) => {
+    const left = (Array.isArray(m.params.ruleId) ? m.params.ruleId : [m.params.ruleId]).filter((k) => !keys.includes(String(k)));
+    return left.length ? { id: m.id, params: { ...m.params, ruleId: Array.isArray(m.params.ruleId) ? left : left[0] } } : null;
+  },
+  hasFormula: (m) => {
+    if (m.id === DV.add) return dvFormula(m.params.rule);
+    const p = dvPayload(m);
+    return p.type === 0 || p.type === 3 ? dvFormula(p.payload) : false;
+  },
+  orderedAdds: true,
+  // an ALL update (the ref-range handler restates the whole rule) losing to a setting/options change keeps its ranges
+  narrow: (m, lost) => {
+    if (m.id !== DV.update || dvPayload(m).type !== 3 || lost === "range") return null;
+    const ranges = (dvPayload(m).payload ?? {}).ranges;
+    return Array.isArray(ranges) ? { id: m.id, params: { ...m.params, payload: { type: DV_RANGE, payload: ranges } } } : null;
+  }
+});
+var FILTER = { range: "sheet.mutation.set-filter-range", criteria: "sheet.mutation.set-filter-criteria", remove: "sheet.mutation.remove-filter" };
+var hull = (rects) => ({
+  startRow: Math.min(...rects.map((r) => r.startRow)),
+  endRow: Math.max(...rects.map((r) => r.endRow)),
+  startColumn: Math.min(...rects.map((r) => r.startColumn)),
+  endColumn: Math.max(...rects.map((r) => r.endColumn))
+});
+var filterWith = (m, rects) => m.id === FILTER.range ? { id: m.id, params: { ...m.params, range: hull(rects) } } : { id: m.id, params: { ...m.params, col: rects[0].startColumn } };
+var colRect = (col) => ({ startRow: 0, endRow: 1e9, startColumn: col, endColumn: col });
+registerRangedResource({
+  family: "filter",
+  ids: { [FILTER.range]: "set", [FILTER.criteria]: "set", [FILTER.remove]: "remove" },
+  keys: () => ["filter"],
+  facet: (m) => m.id === FILTER.criteria ? `col:${String(m.params.col)}` : "range",
+  rects: (m) => m.id === FILTER.range ? [m.params.range] : m.id === FILTER.criteria ? [colRect(Number(m.params.col))] : null,
+  withRects: (m, rects) => filterWith(m, rects),
+  setFor: (m, rects) => {
+    const f = filterWith(m, rects);
+    return { id: f.id, params: { ...f.params, derived: true } };
+  },
+  removeOf: (sheet) => ({ id: FILTER.remove, params: { subUnitId: sheet, derived: true } }),
+  /** a criteria column that was removed takes only its criteria with it, never the filter */
+  emptyDrops: (m) => m.id === FILTER.criteria,
+  // a column move can carry a criteria column out of the filter's range (the model refuses it): not yet
+  // where a criteria column lands depends on how the filter's own range moved (Univer's rule at its edges): not yet
+  barrierOver: (m, axis) => m.id === FILTER.criteria && axis === "col" ? "filter: a column's criteria against a column insert, remove or move" : null
+});
+
 // src/collab/sheets/transform/transform.ts
-var SHEET_TRANSFORMER_VERSION = "c5c-1";
+var SHEET_TRANSFORMER_VERSION = "c5d-1";
 var ID = {
   values: "sheet.mutation.set-range-values",
   insertRow: "sheet.mutation.insert-row",
@@ -3059,19 +3220,44 @@ function sheetPair(x, y, side) {
   if (ys) {
     if (y.id !== ID.removeSheet) return ok2([x]);
     const gone2 = sheetOf(y);
-    if (namesSheet(x, gone2)) return barrier2("a formula names a sheet removed at the same time");
     if (sheetOf(x) === gone2 && x.id !== ID.setName && x.id !== ID.removeName)
       return ok2([], [], isDerived(x) ? [] : [`${gone2}: the sheet was removed`]);
+    if (namesSheet(x, gone2)) {
+      const ch = { kind: "remove-sheet", sheet: gone2 };
+      if (x.id === ID.values) return cellsOverChange(x, ch);
+      const r = definedNameThrough(x, ch);
+      return typeof r === "string" ? barrier2(r) : ok2([r.op]);
+    }
     return ok2([x]);
   }
   if (x.id !== ID.removeSheet) return ok2([x]);
   const gone = sheetOf(x);
-  if (namesSheet(y, gone)) return barrier2("a formula names a sheet removed at the same time");
-  return ok2([x], sheetOf(y) === gone && !isDerived(y) && y.id !== ID.setName && y.id !== ID.removeName ? [`${gone}: the sheet was removed`] : []);
+  const ry = rangedSpecOf(y.id);
+  if (ry && sheetOf(y) === gone && ry.ids[y.id] !== "remove")
+    return ok2([...ry.keys(y).map((k) => ({ id: ry.removeOf(gone, k).id, params: { ...ry.removeOf(gone, k).params } })), x]);
+  const lost = sheetOf(y) === gone && !isDerived(y) && y.id !== ID.setName && y.id !== ID.removeName ? [`${gone}: the sheet was removed`] : [];
+  if (sheetOf(y) !== gone && namesSheet(y, gone)) {
+    const ch = { kind: "remove-sheet", sheet: gone };
+    if (y.id === ID.values) {
+      const add = rewritesOf(y, ch);
+      if (typeof add === "string") return barrier2(add);
+      return ok2(add ? [x, add] : [x], lost);
+    }
+    const r = definedNameThrough(y, ch);
+    if (typeof r === "string") return barrier2(r);
+    return ok2(r.changed ? [x, asDerived(r.op)] : [x], lost);
+  }
+  return ok2([x], lost);
 }
 function annotateSheetOps(group, sheetOrder) {
+  return cleanupsBeforeSheetRemoval(annotateSheetOpsInOrder(group, sheetOrder));
+}
+function annotateSheetOpsInOrder(group, sheetOrder) {
   const order = [...sheetOrder];
-  return group.map((m) => {
+  let structural = false;
+  return group.map((m0) => {
+    if (structuralOf(m0)) structural = true;
+    const m = structural && rangedSpecOf(m0.id) && !isDerived(m0) ? { id: m0.id, params: { ...m0.params, derived: true } } : m0;
     if (m.id === ID.insertSheet) {
       const index = typeof m.params.index === "number" ? Math.min(m.params.index, order.length) : order.length;
       order.splice(index, 0, sheetIdOf(m));
@@ -3090,6 +3276,16 @@ function annotateSheetOps(group, sheetOrder) {
     return m;
   });
 }
+function cleanupsBeforeSheetRemoval(group) {
+  const at = group.findIndex((m) => m.id === ID.removeSheet);
+  if (at < 0) return group;
+  const gone = sheetOf(group[at]);
+  const moved = group.filter((m, k2) => k2 > at && rangedSpecOf(m.id) && sheetOf(m) === gone);
+  if (!moved.length) return group;
+  const rest = group.filter((m) => !moved.includes(m));
+  const k = rest.indexOf(group[at]);
+  return [...rest.slice(0, k), ...moved, ...rest.slice(k)];
+}
 function inlineSheetStyles(sheet, styleOf) {
   const out = JSON.parse(JSON.stringify(sheet));
   const fix = (o) => {
@@ -3219,6 +3415,59 @@ function sortPair(x, y, sx, sy) {
   }
   return ok2([x]);
 }
+function rangedPair(x, y, side, sx, sy) {
+  const px = rangedSpecOf(x.id);
+  const py = rangedSpecOf(y.id);
+  if (!px && !py) return null;
+  const told = (m, what) => isDerived(m) ? [] : [`${sheetOf(m)}: ${what}`];
+  if (px && sy) {
+    const role = px.ids[x.id];
+    const rects = role === "remove" ? null : px.rects(x);
+    if (!rects) return ok2([x]);
+    const why = px.barrierOver?.(x, sy.axis, sy.op.kind);
+    if (why) return barrier2(why);
+    if (px.hasFormula?.(x)) return barrier2(`${px.family}: a rule with formula text against a row or column change (its formulas do not move yet)`);
+    const moved = rectsThrough(sy, rects);
+    if (moved.length) return ok2([px.withRects(x, moved)]);
+    if (role === "add" || px.emptyDrops?.(x)) return ok2([], [], told(x, `${px.family} ${px.keys(x).join(",")}: its cells were removed`));
+    return ok2(px.keys(x).map((k) => px.removeOf(sheetOf(x), k)), [], told(x, `${px.family} ${px.keys(x).join(",")}: its cells were removed`));
+  }
+  if (py && sx) {
+    const role = py.ids[y.id];
+    const rects = role === "remove" ? null : py.rects(y);
+    if (!rects) return ok2([x]);
+    const why = py.barrierOver?.(y, sx.axis, sx.op.kind);
+    if (why) return barrier2(why);
+    if (py.hasFormula?.(y)) return barrier2(`${py.family}: a rule with formula text against a row or column change (its formulas do not move yet)`);
+    const moved = rectsThrough(sx, rects);
+    if (!moved.length && py.emptyDrops?.(y)) return ok2([x], told(y, `${py.family} ${py.keys(y).join(",")}: its cells were removed`));
+    return ok2([x, ...moved.length ? [py.setFor(y, moved)] : py.keys(y).map((k) => py.removeOf(sheetOf(y), k))], moved.length ? [] : told(y, `${py.family} ${py.keys(y).join(",")}: its cells were removed`));
+  }
+  if (!px || !py || px !== py) return ok2([x]);
+  const rx = px.ids[x.id];
+  const ry = py.ids[y.id];
+  const ky = py.keys(y);
+  const common = px.keys(x).filter((k) => ky.includes(k));
+  if (!common.length) {
+    if (rx === "add" && ry === "add" && px.orderedAdds) return barrier2(`${px.family}: two added to one sheet at once (their order is state)`);
+    return ok2([x]);
+  }
+  if (rx === "remove") {
+    if (ry !== "remove") return ok2([x]);
+    const rest = px.withoutKeys ? px.withoutKeys(x, common) : null;
+    return ok2(rest ? [rest] : []);
+  }
+  if (ry === "remove") return ok2([], [], told(x, `${px.family} ${common.join(",")}: removed at the same time`));
+  const fx = px.facet?.(x) ?? "all";
+  const fy = py.facet?.(y) ?? "all";
+  if (fx !== fy && fx !== "all" && fy !== "all") return ok2([x]);
+  const dx = isDerived(x);
+  const dy = isDerived(y);
+  const xWins = dx !== dy ? !dx : side === "left";
+  if (xWins) return ok2([x], told(y, `${py.family} ${common.join(",")}`));
+  const narrowed = fx === "all" && fy !== "all" ? px.narrow?.(x, fy) : null;
+  return ok2(narrowed ? [narrowed] : [], [], told(x, `${px.family} ${common.join(",")}`));
+}
 function familyOf(id) {
   const e = SHEET_MUTATIONS[id];
   return e && e.kind === "covered" ? e.family : "";
@@ -3246,6 +3495,8 @@ function transformMutation(x, y, side) {
   const fy = familyOf(y.id);
   const sy = structuralOf(y);
   const sx = structuralOf(x);
+  const rp = rangedPair(x, y, side, sx, sy);
+  if (rp) return rp;
   const sortp = sortPair(x, y, sx, sy);
   if (sortp) return sortp;
   const cp = countPair(x, y, sy);
@@ -3428,6 +3679,12 @@ function parsedResource(data) {
     return data;
   }
 }
+function withoutComputed(name, data) {
+  if (name !== "SHEET_FILTER_PLUGIN" || !data || typeof data !== "object") return data;
+  const out = {};
+  for (const [sheet, f] of Object.entries(data)) out[sheet] = f && typeof f === "object" ? (({ cachedFilteredOut: _c, ...rest }) => rest)(f) : f;
+  return out;
+}
 function canonicalSheet(snapshot) {
   const s = structuredClone(snapshot ?? {});
   for (const k of SHEET_LOCAL_KEYS) delete s[k];
@@ -3455,7 +3712,7 @@ function canonicalSheet(snapshot) {
       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)));
+    s.resources = s.resources.map((r) => ({ name: r.name, data: sortDeep2(withoutComputed(r.name, 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);
 }
@@ -3467,7 +3724,8 @@ async function sheetsStateHash(snapshot) {
 }
 
 // src/univer/collab/sheets-ot/room.ts
-var SHEETS_COLLAB_PROTO = 2;
+var SHEETS_COLLAB_PROTO = 3;
+var SHEETS_READABLE_PROTOS = [2, SHEETS_COLLAB_PROTO];
 var SHEETS_EDIT_GROUP = "sheets.edit";
 var flip2 = (side) => side === "left" ? "right" : "left";
 var isNoopSheetOp = (op) => op == null || op.length === 0;
@@ -3630,6 +3888,7 @@ function createSheetsOtAdapter(port, hooks = {}) {
     version: SHEET_TRANSFORMER_VERSION,
     transform: (x, y, side) => transformSheetOp(x, y, side),
     compose: (a, b) => [...a ?? [], ...b ?? []],
+    isAnchorOnly: (op) => isSheetsAnchorOnlyOp(op),
     isNoop: isNoopSheetOp,
     encode: encodeSheetOp,
     decode: decodeSheetOp,
@@ -4149,6 +4408,12 @@ function univerSheetsOtPort(o) {
       try {
         const ok3 = cs.syncExecuteCommand(a.id, { ...json(a.params), unitId: u }, { fromCollab: true });
         if (ok3 === false) throw new Error(`"${m.id}" was refused by the editor`);
+        if (a.id.startsWith("sheet.mutation.set-filter") || isStructuralMutation(a)) {
+          try {
+            cs.syncExecuteCommand("sheet.mutation.re-calc-filter", { unitId: u, subUnitId: a.params.subUnitId }, { onlyLocal: true });
+          } catch {
+          }
+        }
       } finally {
         applying = false;
       }
@@ -4364,10 +4629,23 @@ async function loadSnapshotRow2(workbookId, ref) {
   if (!data) throw new Error(`The saved version ${ref} of this workbook is missing.`);
   return data.snapshot ?? null;
 }
-async function workbookUsesOrderedRoom(workbookId, knob, isNewWorkbook) {
+async function deviceHoldsBuffer2(key) {
+  if (!key || typeof indexedDB === "undefined") return false;
+  try {
+    const store = (0, import_collab6.createIndexedDbOfflineStore)();
+    return await store.load(key) != null || await store.load((0, import_collab6.refusedKey)(key)) != null;
+  } catch {
+    return false;
+  }
+}
+async function workbookUsesOrderedRoom(workbookId, knob, isNewWorkbook, offlineKey) {
   try {
     if (await (0, import_collab6.collabRoomExists)(db4(), workbookId)) return true;
   } catch (err) {
+    if (await deviceHoldsBuffer2(offlineKey)) {
+      console.warn("[workbook] could not ask whether this workbook has a co-editing room; unsent edits on this device say it does", err);
+      return true;
+    }
     console.warn("[workbook] could not ask whether this workbook has a co-editing room; opening the relay room", err);
     return false;
   }