@ai-matrx/office 0.6.0 → 0.8.0

package/dist/univer-collab.js

@@ -90,7 +90,7 @@ var WorkbookCollabSession = class {
       this.awareness.on("change", this.awarenessObserver);
     }
     this.commandDisposer = this.options.commandService.onMutationExecutedForCollab(
-      (info) => this.handleLocalMutation(info)
+      (info, options) => this.handleLocalMutation(info, options)
     );
     await this.provider.connect();
     await this.provider.ready();
@@ -238,8 +238,9 @@ var WorkbookCollabSession = class {
     return electCollabHost(states, this.options.uid, this.options.clientId, leader, opts.tabTieBreak ?? false);
   }
   // ─── internals ────────────────────────────────────────────────────────
-  handleLocalMutation(info) {
+  handleLocalMutation(info, options) {
     if (this.muted > 0) return;
+    if (options?.onlyLocal) return;
     if (!this.options.forwardDocumentMutations && isCellEditorScratch(info)) return;
     if (info.params && typeof info.params === "object" && !Array.isArray(info.params) && remoteOriginOf(info.params) !== null) {
       return;
@@ -247,7 +248,7 @@ var WorkbookCollabSession = class {
     if (!this.doc) return;
     let safeParams;
     try {
-      safeParams = info.params === void 0 || info.params === null ? null : JSON.parse(JSON.stringify(info.params));
+      safeParams = info.params === void 0 || info.params === null ? null : stripSenderView(JSON.parse(JSON.stringify(info.params)));
     } catch (err) {
       console.warn(
         `[collab] skipping non-serializable mutation "${info.id}" \u2014 peers will not receive it`,
@@ -321,6 +322,13 @@ var WorkbookCollabSession = class {
     }
   }
 };
+var SENDER_VIEW_PARAMS = ["layoutState", "textRanges", "prevTextRanges"];
+function stripSenderView(params) {
+  if (!params || typeof params !== "object" || Array.isArray(params)) return params;
+  const out = { ...params };
+  for (const key of SENDER_VIEW_PARAMS) delete out[key];
+  return out;
+}
 function isCellEditorScratch(info) {
   return typeof info.id === "string" && info.id.startsWith("doc.mutation.");
 }
@@ -350,11 +358,1022 @@ function pickColor(uid) {
   }
   return CURSOR_PALETTE[Math.abs(h) % CURSOR_PALETTE.length] ?? "#ec4899";
 }
+
+// src/univer/collab/docs-ot/transform.ts
+import { JSONX, TextX, getBodySliceForSplitTextXAction, normalizeTextRuns, merge as univerMerge } from "@univerjs/core";
+import * as json1 from "ot-json1";
+var isTextX = (c) => !!c && typeof c === "object" && c.et === "text-x" && Array.isArray(c.e);
+var clone = (v) => v == null ? v : structuredClone(v);
+function tableZones(a) {
+  const out = [];
+  for (const t of a.body?.tables ?? []) {
+    if (t.startIndex >= 0 && t.endIndex <= a.len && t.endIndex > t.startIndex) out.push([t.startIndex, t.endIndex - 1]);
+  }
+  return out;
+}
+function unrewind(actions) {
+  if (!actions.some((a) => a.len < 0)) return actions;
+  const segs = [];
+  let cur = [];
+  let cursor = 0;
+  for (const a of actions) {
+    if (a.len < 0) {
+      if (a.t !== "r") return actions;
+      segs.push(cur);
+      cursor += a.len;
+      cur = cursor > 0 ? [{ t: "r", len: cursor }] : [];
+      continue;
+    }
+    cur.push(a);
+    if (a.t !== "d") cursor += a.len;
+  }
+  segs.push(cur);
+  const out = segs.reduce((acc, s) => TextX.compose(acc, s));
+  return out.some((a) => a.len < 0) ? actions : out;
+}
+function normText(actions) {
+  const out = [];
+  for (const a of unrewind(actions)) {
+    if (a.t === "d") {
+      if (!(a.len > 0)) continue;
+      const d = { t: "d", len: a.len };
+      if (a.valueRangeId !== void 0) d.valueRangeId = a.valueRangeId;
+      const tz = a.tz ?? tableZones(a);
+      if (tz.length) d.tz = tz;
+      out.push(d);
+      continue;
+    }
+    if (a.t === "r") {
+      const { oldBody: _oldBody, ...rest } = a;
+      out.push(rest);
+      continue;
+    }
+    out.push(a);
+  }
+  return out;
+}
+function normalizeDocsOp(op) {
+  if (op == null) return op;
+  const walk = (v) => {
+    if (Array.isArray(v)) return v.map(walk);
+    if (isTextX(v)) return { ...v, e: normText(v.e) };
+    return v;
+  };
+  return walk(op);
+}
+function dropEmptyStyleRetains(op) {
+  if (op == null) return op;
+  const walk = (v) => {
+    if (Array.isArray(v)) return v.map(walk);
+    if (isTextX(v)) {
+      return {
+        ...v,
+        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 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 } };
+        })
+      };
+    }
+    return v;
+  };
+  return walk(op);
+}
+var onlyDataStream = (body) => Object.keys(body).length === 1;
+var shiftZones = (tz, by) => tz.map(([s, e]) => [s + by, e + by]);
+function mergeZones(tz) {
+  const s = [...tz].sort((x, y) => x[0] - y[0]);
+  const out = [];
+  for (const z of s) {
+    const l = out[out.length - 1];
+    if (l && l[1] + 1 >= z[0]) l[1] = Math.max(l[1], z[1]);
+    else out.push([z[0], z[1]]);
+  }
+  return out;
+}
+function push(list, action) {
+  let index = list.length;
+  let last = list[index - 1];
+  const a = clone(action);
+  if (a.t === "r" && a.len === 0 && a.body == null && !a.rangeUpdates) return;
+  if (last) {
+    if (last.t === "d" && a.t === "d" && last.valueRangeId === a.valueRangeId) {
+      const tz = [...last.tz ?? [], ...shiftZones(a.tz ?? [], last.len)];
+      last.len += a.len;
+      if (tz.length) last.tz = mergeZones(tz);
+      return;
+    }
+    if (last.t === "d" && a.t === "i") {
+      index -= 1;
+      last = list[index - 1];
+      if (last == null) {
+        list.unshift(a);
+        return;
+      }
+    }
+    if (last.t === "r" && a.t === "r" && last.body == null && a.body == null && !last.rangeUpdates && !a.rangeUpdates) {
+      last.len += a.len;
+      return;
+    }
+    if (last.t === "i" && onlyDataStream(last.body) && a.t === "i" && onlyDataStream(a.body) && last.valueRangeId === a.valueRangeId) {
+      last.len += a.len;
+      last.body.dataStream += a.body.dataStream;
+      return;
+    }
+  }
+  if (index === list.length) list.push(a);
+  else list.splice(index, 0, a);
+}
+var BODY_FIELDS = [
+  "textRuns",
+  "paragraphs",
+  "customRanges",
+  "customBlocks",
+  "docxRawCustomBlocks",
+  "docxRawBlocks",
+  "docxExportExcludedRanges",
+  "customDecorations",
+  "tables",
+  "columnGroups",
+  "blockRanges"
+];
+var uselessRetain = (a) => !a.rangeUpdates?.length && (a.body == null || BODY_FIELDS.every((k) => a.body[k] == null));
+function trimEnd(list) {
+  while (list.length && list[list.length - 1].t === "r" && uselessRetain(list[list.length - 1])) list.pop();
+  return list;
+}
+var It = class {
+  constructor(a) {
+    this.a = a;
+  }
+  a;
+  i = 0;
+  off = 0;
+  peekType() {
+    return this.a[this.i]?.t ?? "r";
+  }
+  peekLength() {
+    const x = this.a[this.i];
+    return x ? x.len - this.off : Number.POSITIVE_INFINITY;
+  }
+  hasNext() {
+    return this.peekLength() < Number.POSITIVE_INFINITY;
+  }
+  /** An insert placed now would land strictly inside a table this delete removes whole. */
+  inZone() {
+    const x = this.a[this.i];
+    return x?.t === "d" && (x.tz ?? []).some(([s, e]) => s < this.off && this.off <= e);
+  }
+  next(length) {
+    let len = length || Number.POSITIVE_INFINITY;
+    const x = this.a[this.i];
+    if (!x) return { t: "r", len: Number.POSITIVE_INFINITY };
+    const offset = this.off;
+    if (len >= x.len - offset) {
+      len = x.len - offset;
+      this.i += 1;
+      this.off = 0;
+    } else this.off += len;
+    if (x.t === "d") {
+      const piece = { ...clone(x), len };
+      delete piece.tz;
+      const tz = (x.tz ?? []).map(([s, e]) => [Math.max(s, offset) - offset, Math.min(e, offset + len - 1) - offset]).filter(([s, e]) => s <= e);
+      if (tz.length) piece.tz = tz;
+      return piece;
+    }
+    if (x.t === "r" && x.body == null) return { ...clone(x), len };
+    return { ...clone(x), len, body: getBodySliceForSplitTextXAction(x.body, offset, offset + len, false) };
+  }
+};
+function transformTextRuns(originTextRuns, targetTextRuns, originCoverType, targetCoverType, transformType) {
+  if (originTextRuns == null || targetTextRuns == null) return targetTextRuns;
+  if (originTextRuns.length === 0 || targetTextRuns.length === 0) return [];
+  targetTextRuns = clone(targetTextRuns);
+  originTextRuns = clone(originTextRuns);
+  const out = [];
+  const updateLength = targetTextRuns.length;
+  const removeLength = originTextRuns.length;
+  let updateIndex = 0;
+  let removeIndex = 0;
+  let pending = null;
+  const flush = () => {
+    if (pending) {
+      out.push(pending);
+      pending = null;
+      return true;
+    }
+    return false;
+  };
+  while (updateIndex < updateLength && removeIndex < removeLength) {
+    const { st: updateSt, ed: updateEd, ts: targetStyle } = targetTextRuns[updateIndex];
+    const { st: removeSt, ed: removeEd, ts: originStyle, sId } = originTextRuns[removeIndex];
+    let newTs = {};
+    if (transformType === 0) {
+      newTs = { ...targetStyle };
+      if (originCoverType === 0 && targetCoverType === 1 && originStyle) newTs = Object.assign({}, originStyle, newTs);
+    } else {
+      newTs = { ...targetStyle };
+      if (originCoverType === 1) {
+        if (targetCoverType === 1) newTs = { ...originStyle };
+        else if (targetStyle && originStyle) {
+          for (const key of Object.keys(targetStyle)) if (originStyle[key] !== void 0) delete newTs[key];
+        }
+      } else if (targetCoverType === 1) {
+        if (originStyle) {
+          for (const key of Object.keys(originStyle)) if (originStyle[key] !== void 0) newTs[key] = originStyle[key];
+        }
+      } else if (originStyle) {
+        for (const key of Object.keys(originStyle)) if (newTs[key] !== void 0) delete newTs[key];
+      }
+    }
+    if (updateEd < removeSt) {
+      if (!flush()) out.push(targetTextRuns[updateIndex]);
+      updateIndex++;
+    } else if (removeEd < updateSt) {
+      if (!flush()) out.push(originTextRuns[removeIndex]);
+      removeIndex++;
+    } else {
+      out.push({ st: Math.max(updateSt, removeSt), ed: Math.min(updateEd, removeEd), ts: newTs, sId });
+      if (updateEd < removeEd) {
+        updateIndex++;
+        originTextRuns[removeIndex].st = updateEd;
+        if (originTextRuns[removeIndex].st === originTextRuns[removeIndex].ed) removeIndex++;
+      } else {
+        removeIndex++;
+        targetTextRuns[updateIndex].st = removeEd;
+        if (targetTextRuns[updateIndex].st === targetTextRuns[updateIndex].ed) updateIndex++;
+      }
+      const p = {
+        st: Math.min(updateEd, removeEd),
+        ed: Math.max(updateEd, removeEd),
+        ts: updateEd < removeEd ? { ...originStyle } : { ...targetStyle },
+        sId: updateEd < removeEd ? sId : void 0
+      };
+      pending = p.ed > p.st ? p : null;
+    }
+  }
+  flush();
+  const top = out[out.length - 1];
+  const updateLast = targetTextRuns[updateLength - 1];
+  const removeLast = originTextRuns[removeLength - 1];
+  if (top.ed !== Math.max(updateLast.ed, removeLast.ed)) out.push(updateLast.ed > removeLast.ed ? updateLast : removeLast);
+  return normalizeTextRuns(out, true);
+}
+function transformCustomRanges(o, t, originCoverType, _targetCoverType, transformType) {
+  if (o == null || t == null) return t;
+  if (o.length === 0 || t.length === 0) return [];
+  if (o.length > 1 || t.length > 1) throw new Error("CustomRanges is only supported transform for length one now.");
+  if (originCoverType === 1) return transformType === 1 ? [clone(o[0])] : [clone(t[0])];
+  const r = clone(t[0]);
+  if (transformType === 1) Object.assign(r, clone(o[0]));
+  return [r];
+}
+function transformParagraph(origin, target, originCoverType, targetCoverType, transformType) {
+  const paragraph = { startIndex: target.startIndex, paragraphId: target.paragraphId };
+  const oStyle = originCoverType === 1 ? origin.paragraphStyle ?? {} : origin.paragraphStyle;
+  const tStyle = targetCoverType === 1 ? target.paragraphStyle ?? {} : target.paragraphStyle;
+  if (tStyle) {
+    paragraph.paragraphStyle = clone(tStyle);
+    if (oStyle) {
+      const ps = paragraph.paragraphStyle;
+      if (originCoverType === 1) {
+        if (targetCoverType === 1) {
+          if (transformType === 1) paragraph.paragraphStyle = { ...oStyle };
+        } else if (transformType === 1) {
+          for (const k of Object.keys(oStyle)) if (oStyle[k] !== void 0) ps[k] = oStyle[k];
+        } else for (const k of Object.keys(oStyle)) if (ps[k] === void 0) ps[k] = oStyle[k];
+      } else if (targetCoverType === 1) {
+        if (transformType === 1) {
+          for (const k of Object.keys(oStyle)) if (oStyle[k] !== void 0) ps[k] = oStyle[k];
+        } else for (const k of Object.keys(oStyle)) if (ps[k] === void 0) ps[k] = oStyle[k];
+      } else if (transformType === 1) {
+        for (const k of Object.keys(oStyle)) if (ps[k] !== void 0) delete ps[k];
+      }
+    }
+    if (targetCoverType !== 1 && Object.keys(paragraph.paragraphStyle).length === 0) delete paragraph.paragraphStyle;
+  }
+  if (originCoverType === 1 && targetCoverType === 1) paragraph.bullet = transformType === 1 ? clone(origin.bullet) : clone(target.bullet);
+  else if (origin.bullet === void 0) paragraph.bullet = clone(target.bullet);
+  else if (originCoverType === 1 || targetCoverType === 1) paragraph.bullet = transformType === 0 && target.bullet ? clone(target.bullet) : clone(origin.bullet);
+  else if (transformType === 0 && target.bullet !== void 0) paragraph.bullet = clone(target.bullet);
+  if (paragraph.bullet === void 0) delete paragraph.bullet;
+  if (paragraph.paragraphId === void 0) delete paragraph.paragraphId;
+  return paragraph;
+}
+function transformCustomDecorations(origin, target) {
+  if (origin == null || target == null) return target;
+  if (origin.length === 0 || target.length === 0) return clone(target);
+  const out = [];
+  for (const d of target) {
+    let pushed = false;
+    for (const o of origin) {
+      if (o.id === d.id) {
+        if (o.type === 9999 || d.type === 9999) {
+          pushed = true;
+          out.push({ ...d, type: 9999 });
+        }
+        break;
+      }
+    }
+    if (!pushed) out.push(d);
+  }
+  return out;
+}
+function transformBlockRanges(thisBlockRanges, otherBlockRanges, priority) {
+  if (!thisBlockRanges.length) return otherBlockRanges;
+  if (!otherBlockRanges.length) return [];
+  return otherBlockRanges.map((o) => {
+    const t = thisBlockRanges.find((b) => b.blockId === o.blockId);
+    return t && priority ? univerMerge(o, t) : o;
+  });
+}
+function transformBody(thisAction, otherAction, priority) {
+  const { body: thisBody, coverType: thisCoverType = 0 } = thisAction;
+  const { body: otherBody, coverType: otherCoverType = 0 } = otherAction;
+  if (thisBody == null || thisBody.dataStream !== "" || otherBody == null || otherBody.dataStream !== "") {
+    throw new Error("Data stream is not supported in retain transform.");
+  }
+  const ret = { dataStream: "" };
+  const { textRuns: tr1, paragraphs: p1 = [], blockRanges: b1 = [], customRanges: c1, customDecorations: d1 } = thisBody;
+  const { textRuns: tr2, paragraphs: p2 = [], blockRanges: b2 = [], customRanges: c2, customDecorations: d2 } = otherBody;
+  const pt = priority ? 1 : 0;
+  const textRuns = transformTextRuns(tr1, tr2, thisCoverType, otherCoverType, pt);
+  if (textRuns) ret.textRuns = textRuns;
+  const customRanges = transformCustomRanges(c1, c2, thisCoverType, otherCoverType, pt);
+  if (customRanges) ret.customRanges = customRanges;
+  const customDecorations = transformCustomDecorations(d1, d2);
+  if (customDecorations) ret.customDecorations = customDecorations;
+  const paragraphs = [];
+  let i = 0;
+  let j = 0;
+  while (i < p1.length && j < p2.length) {
+    const a = p1[i];
+    const b = p2[j];
+    if (a.startIndex === b.startIndex) {
+      paragraphs.push(transformParagraph(a, b, thisCoverType, otherCoverType, pt));
+      i++;
+      j++;
+    } else if (a.startIndex < b.startIndex) i++;
+    else {
+      paragraphs.push(clone(b));
+      j++;
+    }
+  }
+  if (j < p2.length) paragraphs.push(...p2.slice(j));
+  if (paragraphs.length) ret.paragraphs = paragraphs;
+  const blockRanges = transformBlockRanges(b1, b2, priority);
+  if (blockRanges.length) ret.blockRanges = blockRanges;
+  return { coverType: otherCoverType, body: ret };
+}
+var valueIds = (acts) => new Set(acts.flatMap((a) => a.t !== "r" && a.valueRangeId ? [a.valueRangeId] : []));
+function withoutValueRangeMetadata(acts, suppressed) {
+  return acts.map((a) => {
+    if (!a.body?.customRanges?.some((r) => suppressed.has(r.rangeId))) return a;
+    const body = { ...a.body, customRanges: a.body.customRanges.filter((r) => !suppressed.has(r.rangeId)) };
+    if (!body.customRanges.length) delete body.customRanges;
+    return { ...a, body };
+  });
+}
+function addedDecorations(y) {
+  const out = [];
+  let pos = 0;
+  for (const a of y) {
+    if (a.t === "d") continue;
+    if (a.t === "r") {
+      for (const d of a.body?.customDecorations ?? []) if (d.type !== 9999) out.push({ id: d.id, type: d.type, ds: pos + d.startIndex, de: pos + d.endIndex });
+    }
+    pos += a.len;
+  }
+  return out;
+}
+var hasRangeUpdates = (acts) => acts.some((a) => a.t === "r" && a.rangeUpdates?.length);
+function transformTextX(xIn, yIn, side, lost = []) {
+  if (hasRangeUpdates(xIn) || hasRangeUpdates(yIn)) return TextX.transform(xIn, yIn, side);
+  const x = normText(xIn);
+  const y = normText(yIn);
+  const xLeft = side === "left";
+  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 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")) {
+      const a = X.next();
+      if (Y3.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();
+      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 } : {} });
+        inPos += b.len;
+        continue;
+      }
+      if (b.valueRangeId && conflicts.has(b.valueRangeId) && xLeft) push(out, { t: "d", len: b.len, valueRangeId: b.valueRangeId });
+      else {
+        push(out, { t: "r", len: b.len });
+        outPos += b.len;
+      }
+      inPos += b.len;
+    } else {
+      const len = Math.min(X.peekLength(), Y3.peekLength());
+      const a = X.next(len);
+      const b = Y3.next(len);
+      if (b.t === "d") continue;
+      if (a.t === "d") {
+        push(out, a);
+        inPos += len;
+        continue;
+      }
+      for (const d of decos) {
+        const s = Math.max(d.ds, inPos);
+        const e = Math.min(d.de, inPos + len - 1);
+        if (s <= e) d.pieces.push([outPos + s - inPos, outPos + e - inPos]);
+      }
+      let r = a;
+      if (a.body != null && b.body != null) {
+        const { coverType, body } = transformBody(b, a, !xLeft);
+        r = { ...a, t: "r", coverType, body };
+      }
+      if (r.coverType === 1 && r.body) {
+        const keep = [];
+        for (const d of decos) {
+          if (!(d.de >= inPos && d.ds < inPos + len)) continue;
+          const ahead = d.de >= inPos + len ? [[outPos + len + Math.max(d.ds, inPos + len) - (inPos + len), outPos + d.de - inPos]] : [];
+          for (const [s, e] of [...d.pieces, ...ahead]) keep.push({ id: d.id, type: d.type, startIndex: s - outPos, endIndex: e - outPos });
+        }
+        if (keep.length) r = { ...r, body: { ...r.body, customDecorations: [...r.body.customDecorations ?? [], ...keep] } };
+      }
+      push(out, r);
+      inPos += len;
+      outPos += len;
+    }
+  }
+  return trimEnd(out);
+}
+var sink = null;
+var ours = {
+  name: "text-x",
+  uri: TextX.uri,
+  apply: (doc, actions) => TextX.apply(doc, actions),
+  compose: (a, b) => TextX.compose(a, b),
+  isNoop: (a) => TextX.isNoop(a),
+  invert: (a) => TextX.invert(a),
+  makeInvertible: (a, doc) => TextX.makeInvertible(a, doc),
+  transform: (x, y, side) => transformTextX(x, y, side, sink ?? [])
+};
+function transformDocsOp(x, y, side) {
+  if (x == null) return { op: null, lost: [] };
+  if (y == null) return { op: x, lost: [] };
+  const lost = [];
+  sink = lost;
+  json1.type.registerSubtype(ours);
+  try {
+    const op = json1.type.transformNoConflict(normalizeDocsOp(x), normalizeDocsOp(y), side);
+    return { op: dropEmptyStyleRetains(op), lost };
+  } finally {
+    json1.type.registerSubtype(TextX);
+    sink = null;
+  }
+}
+function composeDocsOps(a, b) {
+  if (a == null) return b;
+  if (b == null) return a;
+  json1.type.registerSubtype(TextX);
+  return json1.type.compose(a, b);
+}
+function isNoopDocsOp(op) {
+  return op == null || Array.isArray(op) && op.length === 0 || json1.type.isNoop(op);
+}
+function applyDocsOp(doc, op) {
+  if (isNoopDocsOp(op)) return doc;
+  return JSONX.apply(structuredClone(doc), op);
+}
+function invertDocsOp(op, preDoc) {
+  if (isNoopDocsOp(op)) return null;
+  return JSONX.invertWithDoc(structuredClone(op), preDoc);
+}
+var DOCS_TRANSFORM_VERSION = "univer-1.0.4+docs-ot-r6";
+
+// src/univer/collab/docs-ot/state-hash.ts
+var DOC_LOCAL_KEYS = ["rev", "__matrxCollabCovered", "__collab", "disabled", "layoutState", "textRanges", "selections"];
+function sortDeep(v) {
+  if (Array.isArray(v)) return v.map(sortDeep);
+  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] = sortDeep(x);
+    }
+    return out;
+  }
+  return v;
+}
+var sameTs = (a, b) => JSON.stringify(sortDeep(a ?? {})) === JSON.stringify(sortDeep(b ?? {}));
+function canonicalRuns(runs) {
+  const out = [];
+  for (const r of [...runs ?? []].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;
+    const last = out[out.length - 1];
+    if (last && last.ed === r.st && sameTs(last.ts, ts)) last.ed = r.ed;
+    else out.push({ st: r.st, ed: r.ed, ts });
+  }
+  return out;
+}
+function foldPieces(items, keyOf) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const it of items ?? []) {
+    const k = keyOf(it);
+    const g = groups.get(k) ?? [];
+    g.push(it);
+    groups.set(k, g);
+  }
+  const out = [];
+  for (const list of groups.values()) {
+    list.sort((a, b) => a.startIndex - b.startIndex);
+    let cur = null;
+    for (const it of list) {
+      if (cur && cur.endIndex + 1 >= it.startIndex) cur.endIndex = Math.max(cur.endIndex, it.endIndex);
+      else {
+        if (cur) out.push(cur);
+        cur = { ...it };
+      }
+    }
+    if (cur) out.push(cur);
+  }
+  return out;
+}
+var rootId = (id) => String(id).split("$")[0];
+function canonicalBody(body) {
+  if (!body) return body;
+  const b = { ...body };
+  b.textRuns = canonicalRuns(b.textRuns);
+  if (Array.isArray(b.paragraphs)) b.paragraphs = b.paragraphs.map(({ paragraphId: _p, ...p }) => p);
+  b.customRanges = foldPieces(b.customRanges, (r) => JSON.stringify([rootId(r.rangeId), r.rangeType, sortDeep(r.properties ?? {})])).map((r) => ({
+    ...r,
+    rangeId: rootId(r.rangeId)
+  }));
+  b.customDecorations = foldPieces(b.customDecorations, (d) => JSON.stringify([d.id, d.type]));
+  for (const k of ["paragraphs", "customRanges", "customBlocks", "tables", "sectionBreaks", "customDecorations"]) {
+    if (Array.isArray(b[k])) {
+      b[k] = [...b[k]].sort(
+        (x, y) => (x.startIndex ?? 0) - (y.startIndex ?? 0) || String(x.rangeId ?? x.blockId ?? x.tableId ?? "").localeCompare(String(y.rangeId ?? y.blockId ?? y.tableId ?? ""))
+      );
+    }
+  }
+  return b;
+}
+function canonicalDocsSnapshot(snapshot) {
+  const s = structuredClone(snapshot ?? {});
+  delete s.id;
+  for (const k of DOC_LOCAL_KEYS) delete s[k];
+  s.body = canonicalBody(s.body);
+  for (const seg of ["headers", "footers", "notes"]) {
+    if (!s[seg]) continue;
+    for (const id of Object.keys(s[seg])) s[seg][id] = { ...s[seg][id], body: canonicalBody(s[seg][id].body) };
+  }
+  return sortDeep(s);
+}
+var canonicalDocsString = (snapshot) => JSON.stringify(canonicalDocsSnapshot(snapshot));
+async function docsStateHash(snapshot) {
+  const bytes = new TextEncoder().encode(canonicalDocsString(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("");
+}
+function stampDeterministicIds(snapshot) {
+  const s = structuredClone(snapshot);
+  const stamp = (body, scope) => {
+    if (!body) return;
+    for (const p of body.paragraphs ?? []) if (!p.paragraphId) p.paragraphId = `p_${scope}${p.startIndex}`;
+    for (const sb of body.sectionBreaks ?? []) if (!sb.sectionId) sb.sectionId = `s_${scope}${sb.startIndex}`;
+  };
+  stamp(s?.body, "");
+  for (const seg of ["headers", "footers", "notes"]) for (const id of Object.keys(s?.[seg] ?? {})) stamp(s[seg][id]?.body, `${id}_`);
+  return s;
+}
+
+// src/univer/collab/docs-ot/room.ts
+import { isOpBarrier, openOpSession } from "@ai-matrx/data/realtime/collab";
+var RICH_TEXT_EDITING = "doc.mutation.rich-text-editing";
+var DOCS_COLLAB_PROTO = 1;
+function branches(op) {
+  if (!Array.isArray(op) || op.length === 0) return [];
+  return Array.isArray(op[0]) ? op : [op];
+}
+var touchesPageSetup = (op) => branches(op).some((b) => b[0] === "documentStyle");
+function segmentOf(branch) {
+  return (branch[0] === "headers" || branch[0] === "footers") && typeof branch[1] === "string" ? branch[1] : "";
+}
+function undoStacksOf(service) {
+  const s = service;
+  if (!s || !(s._undoStacks instanceof Map) || !(s._redoStacks instanceof Map)) return null;
+  return { undo: s._undoStacks, redo: s._redoStacks };
+}
+function rebaseUndoStack(items, remote) {
+  let dropped = 0;
+  for (let i = items.length - 1; i >= 0; i--) {
+    const item = items[i];
+    let ok = 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;
+          else {
+            m.params = { ...m.params, actions: r.op };
+            delete m.params.textRanges;
+            delete m.params.layoutState;
+          }
+        } catch {
+          ok = false;
+        }
+      }
+    }
+    if (!ok) {
+      items.splice(i, 1);
+      dropped++;
+    }
+  }
+  return dropped;
+}
+function openDocsOtRoom(o) {
+  const { port } = o;
+  let session = null;
+  let composing = false;
+  let queue = [];
+  const drainWaiters = [];
+  const notice = (n) => {
+    try {
+      o.onNotice?.(n);
+    } catch (err) {
+      console.warn("[docs-ot] notice handler failed", err);
+    }
+  };
+  const applyNow = (op) => {
+    for (const b of branches(op)) {
+      const params = { segmentId: segmentOf(b), actions: b };
+      port.applyRemote(RICH_TEXT_EDITING, params);
+    }
+    for (const t of port.undoTargets()) {
+      const stacks = undoStacksOf(t.service);
+      if (!stacks) continue;
+      for (const m of [stacks.undo, stacks.redo]) {
+        const items = m.get(t.unitId);
+        if (items?.length) rebaseUndoStack(items, op);
+      }
+    }
+    port.markDirty();
+  };
+  const drain = () => {
+    const held = queue;
+    queue = [];
+    try {
+      for (const op of held) applyNow(op);
+    } catch (err) {
+      console.warn("[docs-ot] a held remote edit failed after composition; reloading this seat", err);
+      session?.rebuild("ime_drain_failed");
+    }
+    for (const w of drainWaiters.splice(0)) w();
+  };
+  const adapter = {
+    version: DOCS_TRANSFORM_VERSION,
+    transform(x, y, side) {
+      if (x != null && y != null && (touchesPageSetup(x) || touchesPageSetup(y))) return { barrier: true, reason: "page_setup" };
+      const r = transformDocsOp(x, y, side);
+      return { op: isNoopDocsOp(r.op) ? null : r.op, lost: r.lost };
+    },
+    compose: (a, b) => composeDocsOps(a, b),
+    isNoop: (op) => isNoopDocsOp(op),
+    encode: (op) => [{ cmd: "docs.edit", mutations: [{ id: RICH_TEXT_EDITING, params: { segmentId: "", actions: op } }] }],
+    decode(groups) {
+      let op = null;
+      for (const g of groups) {
+        for (const m of g.mutations) {
+          if (m.id !== RICH_TEXT_EDITING) throw new Error(`a Docs room cannot apply ${m.id}`);
+          op = composeDocsOps(op, m.params.actions ?? null);
+        }
+      }
+      return op;
+    },
+    apply(op) {
+      if (isNoopDocsOp(op)) return true;
+      if (composing) {
+        queue.push(op);
+        return true;
+      }
+      applyNow(op);
+      return true;
+    },
+    async load(snapshot) {
+      const next = stampDeterministicIds(snapshot ?? {});
+      queue = [];
+      const current = port.snapshot();
+      if (current && canonicalDocsString(current) === canonicalDocsString(next)) return;
+      port.load(next);
+      for (const t of port.undoTargets()) {
+        const stacks = undoStacksOf(t.service);
+        stacks?.undo.delete(t.unitId);
+        stacks?.redo.delete(t.unitId);
+      }
+    },
+    snapshot: () => port.snapshot(),
+    async hash() {
+      if (composing || queue.length) {
+        await new Promise((resolve) => {
+          drainWaiters.push(resolve);
+          setTimeout(resolve, 5e3);
+        });
+      }
+      return docsStateHash(port.snapshot());
+    }
+  };
+  const onLocal = (m) => {
+    if (!session) return;
+    if (m.id !== RICH_TEXT_EDITING) {
+      if (!m.content) return;
+      notice({ kind: "not_shared", mutationId: m.id });
+      session.rebuild(`not_shared:${m.id}`);
+      return;
+    }
+    const p = m.params ?? {};
+    const applied = p.actions ?? null;
+    if (isNoopDocsOp(applied)) return;
+    let op = normalizeDocsOp(structuredClone(applied));
+    let inverse;
+    try {
+      inverse = m.pre != null ? invertDocsOp(applied, m.pre) : void 0;
+    } catch {
+      inverse = void 0;
+    }
+    if (queue.length) {
+      inverse = void 0;
+      const next = [];
+      for (const q of queue) {
+        const l2 = adapter.transform(op, q, "left");
+        const q2 = adapter.transform(q, op, "right");
+        if (isOpBarrier(l2) || isOpBarrier(q2)) {
+          queue = [];
+          session.rebuild("ime_barrier");
+          return;
+        }
+        op = l2.op;
+        next.push(q2.op);
+      }
+      queue = next.filter((q) => !isNoopDocsOp(q));
+      if (isNoopDocsOp(op)) return;
+    }
+    if (!session.local(op, { ...inverse !== void 0 ? { inverse } : {}, label: m.cmd ?? RICH_TEXT_EDITING })) notice({ kind: "not_live" });
+  };
+  const unsubLocal = port.onLocal(onLocal);
+  const target = o.compositionTarget === void 0 ? typeof document !== "undefined" ? document : null : o.compositionTarget;
+  const onStart = () => {
+    composing = true;
+  };
+  const onEnd = () => {
+    composing = false;
+    setTimeout(() => {
+      if (!composing) drain();
+    }, 0);
+  };
+  target?.addEventListener("compositionstart", onStart, true);
+  target?.addEventListener("compositionend", onEnd, true);
+  session = openOpSession({
+    transport: o.transport,
+    adapter,
+    proto: DOCS_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(stampDeterministicIds(snapshot));
+      const loaded = port.snapshot();
+      if (!loaded) throw new Error("The document is not open in this tab.");
+      const stateHash = await docsStateHash(loaded);
+      await o.replace({ snapshot: loaded, stateHash, clientId: o.clientId });
+    },
+    stop() {
+      unsubLocal();
+      target?.removeEventListener("compositionstart", onStart, true);
+      target?.removeEventListener("compositionend", onEnd, true);
+      session?.close();
+    }
+  };
+}
+
+// src/docs/document-ot-room.ts
+import * as Y2 from "yjs";
+import { Awareness as Awareness2 } from "y-protocols/awareness";
+import {
+  awarenessOpPresence,
+  collabReplace,
+  collabRoomExists,
+  SupabaseYjsProvider,
+  supabaseOpTransport
+} from "@ai-matrx/data/realtime/collab";
+
+// src/docs/document-service.ts
+import { requireOrganizationContext } from "@ai-matrx/api";
+import { getClaimsUser } from "@ai-matrx/auth";
+import { readAllRows, tryWriteOne, writeOneRow } from "@ai-matrx/data/db";
+
+// src/docs/ports.ts
+var SLOT = /* @__PURE__ */ Symbol.for("ai-matrx.office.docs-host");
+var slot = () => {
+  const g = globalThis;
+  return g[SLOT] ??= {};
+};
+function getDocsHost() {
+  const ports = slot().ports;
+  if (!ports) throw new Error("@ai-matrx/office/docs: configureDocsHost(ports) was not called before the document service ran.");
+  return ports;
+}
+
+// src/docs/document-service.ts
+var db = () => getDocsHost().getSupabase();
+async function getLatestDocumentSnapshot(documentId) {
+  const { data, error } = await db().schema("workbench").from("udt_document_snapshots").select("*").eq("document_id", documentId).order("created_at", { ascending: false }).limit(1).maybeSingle();
+  if (error) return { success: false, error: error.message };
+  return { success: true, data: data ?? null };
+}
+async function saveDocumentSnapshot(args) {
+  const { data: userData } = await getClaimsUser(db());
+  const { data, error } = await db().schema("workbench").from("udt_document_snapshots").insert({
+    document_id: args.documentId,
+    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 db().schema("workbench").from("udt_documents").update({ updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", args.documentId);
+  return { success: true, data };
+}
+
+// src/docs/document-ot-room.ts
+var db2 = () => getDocsHost().getSupabase();
+async function loadSnapshotRow(documentId, ref) {
+  if (ref === "none") {
+    const res = await getLatestDocumentSnapshot(documentId);
+    if (!res.success) throw new Error(res.error);
+    return res.data?.snapshot ?? null;
+  }
+  const { data, error } = await getDocsHost().getSupabase().schema("workbench").from("udt_document_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 document is missing.`);
+  return data.snapshot ?? null;
+}
+async function documentUsesOrderedRoom(documentId, knob, isNewDocument) {
+  try {
+    if (await collabRoomExists(db2(), documentId)) return true;
+  } catch (err) {
+    console.warn("[document] could not ask whether this document has a co-editing room; opening the relay room", err);
+    return false;
+  }
+  if (knob === "all") return true;
+  if (knob === "new") return isNewDocument();
+  return false;
+}
+function pickColor2(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";
+}
+function documentOtFactory(o) {
+  return async (port, onAwareness) => {
+    const latest = await getLatestDocumentSnapshot(o.documentId);
+    if (!latest.success) throw new Error(latest.error);
+    if (!latest.data) {
+      const mounted = port.snapshot();
+      if (mounted) {
+        const saved = await saveDocumentSnapshot({ documentId: o.documentId, snapshot: mounted, origin: "autosave" });
+        if (!saved.success) throw new Error(saved.error);
+      }
+    }
+    const doc = new Y2.Doc();
+    const awareness = new Awareness2(doc);
+    awareness.setLocalState({ uid: o.uid, clientId: o.clientId, name: o.displayName ?? o.uid.slice(0, 8), color: pickColor2(o.uid), ts: Date.now() });
+    const publishAwareness = () => onAwareness({ states: new Map(awareness.getStates()), selfUid: o.uid });
+    awareness.on("change", publishAwareness);
+    const provider = new SupabaseYjsProvider({
+      workbookId: o.documentId,
+      channelPrefix: "document",
+      clientId: o.clientId,
+      doc,
+      awareness,
+      ...o.readAntiEntropyIntervalMs ? { readAntiEntropyIntervalMs: o.readAntiEntropyIntervalMs } : {}
+    });
+    await provider.connect();
+    publishAwareness();
+    const client = db2();
+    const room = openDocsOtRoom({
+      port,
+      clientId: o.clientId,
+      presence: awarenessOpPresence(awareness),
+      transport: supabaseOpTransport({
+        client,
+        roomId: o.documentId,
+        kind: "univer_doc",
+        store: {
+          loadSnapshot: (ref) => loadSnapshotRow(o.documentId, ref),
+          async writeSnapshot(snapshot) {
+            const res = await saveDocumentSnapshot({ documentId: o.documentId, snapshot, origin: "autosave" });
+            if (!res.success) throw new Error(res.error);
+            return res.data.id;
+          }
+        }
+      }),
+      replace: ({ snapshot, stateHash, clientId }) => collabReplace(client, { roomId: o.documentId, 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 {
+      isSaver: () => room.isSaver(),
+      write: (reason) => room.write(reason),
+      replace: (snapshot) => room.replace(snapshot),
+      stop: () => {
+        room.stop();
+        awareness.off("change", publishAwareness);
+        provider.disconnect();
+        awareness.destroy();
+        doc.destroy();
+      }
+    };
+  };
+}
 export {
   COLLAB_COVERED_KEY,
+  DOCS_COLLAB_PROTO,
+  DOCS_TRANSFORM_VERSION,
+  DOC_LOCAL_KEYS,
+  RICH_TEXT_EDITING,
+  SENDER_VIEW_PARAMS,
   WorkbookCollabSession,
+  applyDocsOp,
+  canonicalDocsSnapshot,
+  canonicalDocsString,
+  composeDocsOps,
+  docsStateHash,
+  documentOtFactory,
+  documentUsesOrderedRoom,
+  dropEmptyStyleRetains,
+  invertDocsOp,
   isCellEditorScratch,
+  isNoopDocsOp,
+  normalizeDocsOp,
+  openDocsOtRoom,
+  rebaseUndoStack,
   stampCovered,
-  takeCovered
+  stampDeterministicIds,
+  stripSenderView,
+  takeCovered,
+  transformDocsOp,
+  transformTextX,
+  undoStacksOf
 };
 //# sourceMappingURL=univer-collab.js.map