@casualoffice/sheets 0.9.0 → 0.10.0

package/dist/collab.cjs

@@ -0,0 +1,770 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/collab/index.ts
+var collab_exports = {};
+__export(collab_exports, {
+  REVERTABLE_MUTATIONS: () => REVERTABLE_MUTATIONS,
+  SYNCED_MUTATIONS: () => SYNCED_MUTATIONS,
+  attachCollab: () => attachCollab,
+  classifyReplayError: () => classifyReplayError,
+  deepRewriteUnitId: () => deepRewriteUnitId,
+  rewriteJson1OpPathUnitId: () => rewriteJson1OpPathUnitId,
+  startBridge: () => startBridge
+});
+module.exports = __toCommonJS(collab_exports);
+
+// src/collab/attachCollab.ts
+var Y = __toESM(require("yjs"), 1);
+var import_provider = require("@hocuspocus/provider");
+
+// src/collab/bridge.ts
+var import_core = require("@univerjs/core");
+var import_sheets = require("@univerjs/sheets");
+
+// src/collab/bridge-helpers.ts
+function rewriteJson1OpPathUnitId(op, oldUnitId, newUnitId) {
+  if (oldUnitId === newUnitId) return op;
+  if (!Array.isArray(op)) return op;
+  const looksLikeOpList = op.length > 0 && Array.isArray(op[0]);
+  if (looksLikeOpList) {
+    let changed = false;
+    const next = op.map((entry) => {
+      const r = rewriteJson1OpPathUnitId(entry, oldUnitId, newUnitId);
+      if (r !== entry) changed = true;
+      return r;
+    });
+    return changed ? next : op;
+  }
+  if (op[0] === oldUnitId) {
+    const next = [...op];
+    next[0] = newUnitId;
+    return next;
+  }
+  return op;
+}
+function deepRewriteUnitId(value, localUnitId) {
+  if (Array.isArray(value)) {
+    let changed = false;
+    const next = value.map((item) => {
+      const r = deepRewriteUnitId(item, localUnitId);
+      if (r !== item) changed = true;
+      return r;
+    });
+    return changed ? next : value;
+  }
+  if (value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+    const obj = value;
+    let changed = false;
+    const out = {};
+    for (const key of Object.keys(obj)) {
+      const v = obj[key];
+      if (key === "unitId" && typeof v === "string" && v !== localUnitId) {
+        out[key] = localUnitId;
+        changed = true;
+      } else {
+        const r = deepRewriteUnitId(v, localUnitId);
+        if (r !== v) changed = true;
+        out[key] = r;
+      }
+    }
+    return changed ? out : value;
+  }
+  return value;
+}
+
+// src/univer/lazy-plugins.ts
+var LOADERS = {
+  cf: async () => {
+    const [base, ui] = await Promise.all([
+      import("@univerjs/sheets-conditional-formatting"),
+      import("@univerjs/sheets-conditional-formatting-ui")
+    ]);
+    return [
+      [base.UniverSheetsConditionalFormattingPlugin],
+      [ui.UniverSheetsConditionalFormattingUIPlugin]
+    ];
+  },
+  dv: async () => {
+    const [base, ui] = await Promise.all([
+      import("@univerjs/sheets-data-validation"),
+      import("@univerjs/sheets-data-validation-ui")
+    ]);
+    return [
+      [base.UniverSheetsDataValidationPlugin],
+      [ui.UniverSheetsDataValidationUIPlugin]
+    ];
+  },
+  hyperlink: async () => {
+    const [base, ui] = await Promise.all([
+      import("@univerjs/sheets-hyper-link"),
+      import("@univerjs/sheets-hyper-link-ui")
+    ]);
+    return [
+      [base.UniverSheetsHyperLinkPlugin],
+      [ui.UniverSheetsHyperLinkUIPlugin]
+    ];
+  },
+  note: async () => {
+    const [base, ui] = await Promise.all([
+      import("@univerjs/sheets-note"),
+      import("@univerjs/sheets-note-ui")
+    ]);
+    return [[base.UniverSheetsNotePlugin], [ui.UniverSheetsNoteUIPlugin]];
+  },
+  table: async () => {
+    const [base, ui] = await Promise.all([
+      import("@univerjs/sheets-table"),
+      import("@univerjs/sheets-table-ui")
+    ]);
+    return [[base.UniverSheetsTablePlugin], [ui.UniverSheetsTableUIPlugin]];
+  },
+  threadComment: async () => {
+    const [tc, tcUi, sheetsTc, sheetsTcUi] = await Promise.all([
+      import("@univerjs/thread-comment"),
+      import("@univerjs/thread-comment-ui"),
+      import("@univerjs/sheets-thread-comment"),
+      import("@univerjs/sheets-thread-comment-ui")
+    ]);
+    return [
+      [tc.UniverThreadCommentPlugin],
+      [tcUi.UniverThreadCommentUIPlugin],
+      [sheetsTc.UniverSheetsThreadCommentPlugin],
+      [sheetsTcUi.UniverSheetsThreadCommentUIPlugin]
+    ];
+  },
+  drawing: async () => {
+    const [d, dUi, sd, sdUi] = await Promise.all([
+      import("@univerjs/drawing"),
+      import("@univerjs/drawing-ui"),
+      import("@univerjs/sheets-drawing"),
+      import("@univerjs/sheets-drawing-ui"),
+      // Side-effect imports: install FWorksheet.insertImage / getImages /
+      // updateImages on the facade prototype. Without these, code that
+      // reaches in via the FUniver facade (e2e specs, future shell glue)
+      // sees an undefined method even though the plugin is registered.
+      import("@univerjs/sheets-drawing/facade"),
+      import("@univerjs/sheets-drawing-ui/facade")
+    ]);
+    return [
+      [d.UniverDrawingPlugin],
+      [dUi.UniverDrawingUIPlugin],
+      [sd.UniverSheetsDrawingPlugin],
+      [sdUi.UniverSheetsDrawingUIPlugin]
+    ];
+  },
+  sort: async () => {
+    const [base, ui] = await Promise.all([
+      import("@univerjs/sheets-sort"),
+      import("@univerjs/sheets-sort-ui")
+    ]);
+    return [[base.UniverSheetsSortPlugin], [ui.UniverSheetsSortUIPlugin]];
+  },
+  filter: async () => {
+    const [base, ui] = await Promise.all([
+      import("@univerjs/sheets-filter"),
+      import("@univerjs/sheets-filter-ui")
+    ]);
+    return [[base.UniverSheetsFilterPlugin], [ui.UniverSheetsFilterUIPlugin]];
+  },
+  findReplace: async () => {
+    const [base, sheets] = await Promise.all([
+      import("@univerjs/find-replace"),
+      import("@univerjs/sheets-find-replace")
+    ]);
+    return [[base.UniverFindReplacePlugin], [sheets.UniverSheetsFindReplacePlugin]];
+  }
+};
+var loaded = /* @__PURE__ */ new Set();
+var inflight = /* @__PURE__ */ new Map();
+var currentUniver = null;
+function ensurePlugin(univer, group) {
+  if (loaded.has(group)) return Promise.resolve();
+  const existing = inflight.get(group);
+  if (existing) return existing;
+  const loader = LOADERS[group];
+  if (!loader) return Promise.resolve();
+  const p = loader().then((plugins) => {
+    for (const [PluginCtor, config] of plugins) {
+      univer.registerPlugin(PluginCtor, config);
+    }
+    loaded.add(group);
+    inflight.delete(group);
+  });
+  inflight.set(group, p);
+  return p;
+}
+function ensurePluginByName(group) {
+  if (loaded.has(group)) return Promise.resolve();
+  if (!currentUniver) return Promise.resolve();
+  return ensurePlugin(currentUniver, group);
+}
+
+// src/collab/replay-retry.ts
+var TRANSIENT_RETRY_DELAYS_MS = [300, 900, 2700];
+var DEAD_LETTER_CAP = 20;
+function classifyReplayError(err) {
+  if (err == null) return "permanent";
+  const e = err;
+  const name = typeof e.name === "string" ? e.name : "";
+  const message = typeof e.message === "string" ? e.message : String(err);
+  if (name === "ChunkLoadError") return "transient";
+  const lower = message.toLowerCase();
+  if (lower.includes("loading chunk") && lower.includes("failed")) {
+    return "transient";
+  }
+  if (lower.includes("failed to fetch dynamically imported")) {
+    return "transient";
+  }
+  if (lower.includes("networkerror when attempting to fetch")) {
+    return "transient";
+  }
+  if (lower.includes("network request failed")) return "transient";
+  return "permanent";
+}
+async function withRetry(task, delays, shouldRetry = () => true, sleep = (ms) => new Promise((r) => setTimeout(r, ms))) {
+  let lastErr;
+  for (let i = 0; i <= delays.length; i += 1) {
+    try {
+      return await task();
+    } catch (err) {
+      lastErr = err;
+      const attempts = i + 1;
+      if (i >= delays.length) break;
+      if (!shouldRetry(err, attempts)) break;
+      await sleep(delays[i]);
+    }
+  }
+  throw lastErr;
+}
+function pushDeadLetter(buffer, rec, cap = DEAD_LETTER_CAP) {
+  const next = buffer.length >= cap ? [...buffer.slice(buffer.length - cap + 1), rec] : [...buffer, rec];
+  return next;
+}
+
+// src/collab/bridge.ts
+var MUTATION_TO_LAZY_GROUP = {
+  "sheet.mutation.add-conditional-rule": "cf",
+  "sheet.mutation.set-conditional-rule": "cf",
+  "sheet.mutation.delete-conditional-rule": "cf",
+  "sheet.mutation.move-conditional-rule": "cf",
+  "sheet.mutation.add-table": "table",
+  "sheet.mutation.delete-table": "table",
+  "sheet.mutation.set-sheet-table": "table",
+  "sheet.mutation.set-table-filter": "table",
+  "sheet.mutation.set-filter-criteria": "filter",
+  "sheet.mutation.set-filter-range": "filter",
+  "sheet.mutation.remove-filter": "filter",
+  "sheet.mutation.update-note": "note",
+  "sheet.mutation.remove-note": "note",
+  "sheet.mutation.add-hyper-link": "hyperlink",
+  "sheet.mutation.remove-hyper-link": "hyperlink",
+  "sheet.mutation.update-hyper-link": "hyperlink",
+  "data-validation.mutation.addRule": "dv",
+  "data-validation.mutation.removeRule": "dv",
+  "data-validation.mutation.updateRule": "dv",
+  "sheet.mutation.set-drawing-apply": "drawing"
+};
+var LOG_KEY = "ops";
+var SYNCED_MUTATIONS = /* @__PURE__ */ new Set([
+  // Cell-level — values, formulas, styles, rich text.
+  "sheet.mutation.set-range-values",
+  "sheet.mutation.set-style",
+  // Row / column structural.
+  "sheet.mutation.insert-row",
+  "sheet.mutation.insert-col",
+  "sheet.mutation.remove-row",
+  "sheet.mutation.remove-col",
+  "sheet.mutation.move-rows",
+  "sheet.mutation.move-cols",
+  "sheet.mutation.set-row-hidden",
+  "sheet.mutation.set-row-visible",
+  "sheet.mutation.set-col-hidden",
+  "sheet.mutation.set-col-visible",
+  "sheet.mutation.set-worksheet-row-height",
+  "sheet.mutation.set-worksheet-row-is-auto-height",
+  "sheet.mutation.set-worksheet-col-width",
+  // Merges.
+  "sheet.mutation.add-worksheet-merge",
+  "sheet.mutation.remove-worksheet-merge",
+  // Sheet lifecycle.
+  "sheet.mutation.insert-sheet",
+  "sheet.mutation.remove-sheet",
+  "sheet.mutation.set-worksheet-name",
+  "sheet.mutation.set-worksheet-order",
+  // Sheet visibility — hide/show. NB: `set-worksheet-activate` is
+  // deliberately omitted so each peer keeps their own active sheet
+  // independent of which sheet another user is editing.
+  "sheet.mutation.set-worksheet-hidden",
+  // Freeze.
+  "sheet.mutation.set-frozen",
+  // Hyperlinks (sheets-hyper-link).
+  "sheet.mutation.add-hyper-link",
+  "sheet.mutation.remove-hyper-link",
+  "sheet.mutation.update-hyper-link",
+  // Tab colour — picks up the right-click "Tab color" menu.
+  "sheet.mutation.set-tab-color",
+  // Move + sort. Without these, a peer's cut-and-paste-cell-block or
+  // sort-range action silently doesn't appear on receivers.
+  "sheet.mutation.move-range",
+  "sheet.mutation.reorder-range",
+  // Per-row / per-column metadata (height, custom style, colData).
+  // The narrower set-worksheet-row-height / set-worksheet-col-width
+  // are already allowlisted; these are the broader resource-style
+  // mutations Univer emits for "Format → Row/Column" operations.
+  "sheet.mutation.set-row-data",
+  "sheet.mutation.set-col-data",
+  "sheet.mutation.set-worksheet-default-style",
+  // Format-as-table / sheets-table — adds/removes named tables and
+  // their config. Picked up so the table chrome appears on both peers.
+  "sheet.mutation.add-table",
+  "sheet.mutation.delete-table",
+  "sheet.mutation.set-sheet-table",
+  "sheet.mutation.set-table-filter",
+  // Autofilter (sheets-filter).
+  "sheet.mutation.set-filter-criteria",
+  "sheet.mutation.set-filter-range",
+  "sheet.mutation.remove-filter",
+  // Notes (sheets-note) — the small cell-corner indicator + popup.
+  "sheet.mutation.update-note",
+  "sheet.mutation.remove-note",
+  // Conditional formatting (sheets-conditional-formatting). Mutations
+  // are self-contained — `add` carries the full rule, `set` carries
+  // the patched rule, `delete` / `move` carry rule ids. Univer's
+  // `ConditionalFormattingRuleModel` consumes them and triggers a
+  // canvas re-render so highlighted cells update on peers. Existing
+  // rules in a downloaded seed already load via the workbook's
+  // resource channel; the mutations cover deltas during the session.
+  "sheet.mutation.add-conditional-rule",
+  "sheet.mutation.set-conditional-rule",
+  "sheet.mutation.delete-conditional-rule",
+  "sheet.mutation.move-conditional-rule",
+  // Data validation (data-validation core). NB: this package uses the
+  // `data-validation.mutation.*` prefix, not `sheet.mutation.*`.
+  // Mutation handlers live in @univerjs/data-validation; the
+  // sheets-data-validation plugin is the lazy-loaded integration our
+  // MUTATION_TO_LAZY_GROUP map keys on.
+  "data-validation.mutation.addRule",
+  "data-validation.mutation.removeRule",
+  "data-validation.mutation.updateRule",
+  // Drawings / images (sheets-drawing). Single all-purpose mutation
+  // wraps add / remove / update via a JSON-1 op + an enum type. Params
+  // can be large (embedded image blobs) — accept the bandwidth hit
+  // until we move drawings to a side-channel resource model.
+  "sheet.mutation.set-drawing-apply",
+  // Workbook / worksheet metadata. Each is rarely changed mid-session
+  // but cheap to propagate when it does happen. Without these,
+  // renaming the workbook or toggling gridlines silently stays
+  // local-only — confusing in a shared room.
+  // NOTE: `set-worksheet-right-to-left` is intentionally NOT here —
+  // neither the command nor the mutation is registered in
+  // @univerjs/sheets@0.22.1 (it's exported but never wired up by any
+  // plugin), so nothing in our app can emit it. Add it back if a
+  // future Univer bump registers it.
+  "sheet.mutation.set-workbook-name",
+  "sheet.mutation.set-worksheet-row-count",
+  "sheet.mutation.set-worksheet-column-count",
+  "sheet.mutation.toggle-gridlines",
+  "sheet.mutation.set-gridlines-color"
+]);
+var REVERTABLE_MUTATIONS = /* @__PURE__ */ new Set([
+  "sheet.mutation.set-range-values"
+]);
+var COMPACT_OPS_THRESHOLD = 200;
+var COMPACT_MIN_INTERVAL_MS = 6e4;
+var COMPACT_CHECK_INTERVAL_MS = 3e4;
+function startBridge(api, doc, opts = {}) {
+  const role = opts.role ?? "write";
+  const injector = api._injector;
+  if (!injector) {
+    throw new Error("[collab] FUniver injector not accessible \u2014 Univer too old?");
+  }
+  const cmdSvc = injector.get(import_core.ICommandService);
+  const log = doc.getArray(LOG_KEY);
+  const myClientId = String(doc.clientID);
+  let splitChunkWarned = false;
+  let replayFailures = 0;
+  const replayFailureSubscribers = /* @__PURE__ */ new Set();
+  let deadLetter = [];
+  const deadLetterSubscribers = /* @__PURE__ */ new Set();
+  const noteReplayFailure = (rec) => {
+    replayFailures += 1;
+    deadLetter = pushDeadLetter(deadLetter, rec);
+    for (const cb of replayFailureSubscribers) {
+      try {
+        cb(replayFailures);
+      } catch (err) {
+        console.warn("[collab] replay-failure subscriber threw", err);
+      }
+    }
+    for (const cb of deadLetterSubscribers) {
+      try {
+        cb(deadLetter);
+      } catch (err) {
+        console.warn("[collab] dead-letter subscriber threw", err);
+      }
+    }
+  };
+  const pendingUndo = /* @__PURE__ */ new Map();
+  const subBeforeDispose = cmdSvc.beforeCommandExecuted((info, options) => {
+    if (role === "view") return;
+    if (options?.fromCollab) return;
+    if (!REVERTABLE_MUTATIONS.has(info.id)) return;
+    try {
+      const undo = (0, import_sheets.SetRangeValuesUndoMutationFactory)(injector, info.params);
+      pendingUndo.set(JSON.stringify(info.params), undo);
+    } catch (err) {
+      console.warn("[collab] failed to capture undo params for", info.id, err);
+    }
+  });
+  let pending = [];
+  let flushScheduled = false;
+  const flush = () => {
+    flushScheduled = false;
+    if (pending.length === 0) return;
+    const batch = pending;
+    pending = [];
+    doc.transact(() => {
+      log.push(batch);
+    });
+  };
+  const subDispose = cmdSvc.onMutationExecutedForCollab((info, options) => {
+    if (role === "view") return;
+    if (options?.fromCollab) return;
+    if (!SYNCED_MUTATIONS.has(info.id)) return;
+    if (!splitChunkWarned && hasSplitChunkMarker(info.params)) {
+      splitChunkWarned = true;
+      console.warn(
+        '[collab] mutation "%s" carries __splitChunk__ \u2014 Univer reintroduced chunked mutations; bridge needs reassembly logic. See docs/COLLAB-FIXES.md issue 8.',
+        info.id
+      );
+    }
+    const key = JSON.stringify(info.params);
+    const undoParams = pendingUndo.get(key);
+    pendingUndo.delete(key);
+    pending.push({
+      c: myClientId,
+      t: Date.now(),
+      id: info.id,
+      // Univer mutation params are already JSON-friendly (numbers, strings,
+      // plain objects). If something carries a Map / Set / cyclic ref we'll
+      // discover it via a runtime error; that's the signal to drop the
+      // mutation from SYNCED_MUTATIONS.
+      p: info.params,
+      ...undoParams !== void 0 ? { u: undoParams } : {}
+    });
+    if (!flushScheduled) {
+      flushScheduled = true;
+      queueMicrotask(flush);
+    }
+  });
+  let appliedCount = 0;
+  let replayInFlight = null;
+  const replayPending = () => {
+    if (replayInFlight) return replayInFlight;
+    let resolveOuter;
+    const p = new Promise((r) => {
+      resolveOuter = r;
+    });
+    replayInFlight = p;
+    void (async () => {
+      try {
+        while (true) {
+          const total = log.length;
+          if (appliedCount > total) appliedCount = 0;
+          if (appliedCount >= total) {
+            break;
+          }
+          const rec = log.get(appliedCount);
+          appliedCount += 1;
+          if (!rec) continue;
+          if (rec.c === myClientId) continue;
+          if (rec.kind === "snapshot") {
+            if (opts.onSnapshotReceived) {
+              try {
+                await opts.onSnapshotReceived(rec.wb);
+              } catch (err) {
+                console.warn("[collab] failed to apply compaction snapshot", err);
+              }
+            } else {
+              console.warn(
+                "[collab] received compaction snapshot but no handler \u2014 workbook may diverge"
+              );
+            }
+            continue;
+          }
+          const params = rewriteUnitId(api, rec.p, rec.id);
+          const sheetBefore = rec.id === "sheet.mutation.insert-sheet" ? captureActiveSheetId(api) : null;
+          const lazyGroup = MUTATION_TO_LAZY_GROUP[rec.id];
+          const attempt = () => (lazyGroup ? ensurePluginByName(lazyGroup) : Promise.resolve()).then(
+            () => cmdSvc.executeCommand(rec.id, params, { fromCollab: true })
+          );
+          void withRetry(
+            attempt,
+            TRANSIENT_RETRY_DELAYS_MS,
+            (err) => classifyReplayError(err) === "transient"
+          ).then(() => {
+            if (sheetBefore) restoreActiveSheetId(api, sheetBefore);
+          }).catch((err) => {
+            const cls = classifyReplayError(err);
+            const message = err instanceof Error ? err.message : String(err);
+            console.warn(
+              "[collab] replay failed for",
+              rec.id,
+              "(class:",
+              cls + ",",
+              "gave up)",
+              err
+            );
+            const now = Date.now();
+            const failure = {
+              id: rec.id,
+              params: rec.p,
+              lastError: message,
+              // Permanent = 1 attempt; transient = 1 + N retries
+              // configured in TRANSIENT_RETRY_DELAYS_MS.
+              attempts: cls === "transient" ? 1 + TRANSIENT_RETRY_DELAYS_MS.length : 1,
+              firstFailedAt: now,
+              lastFailedAt: now,
+              classification: cls
+            };
+            noteReplayFailure(failure);
+            if (sheetBefore) restoreActiveSheetId(api, sheetBefore);
+          });
+        }
+      } finally {
+        if (replayInFlight === p) replayInFlight = null;
+        resolveOuter();
+      }
+    })();
+    return p;
+  };
+  const observer = (event) => {
+    void event;
+    void replayPending();
+  };
+  log.observe(observer);
+  void replayPending();
+  let lastCompactedAt = Date.now();
+  let intervalHandle = null;
+  let idleHandle = null;
+  const cic = globalThis.cancelIdleCallback;
+  if (role !== "view" && opts.awareness) {
+    const awareness = opts.awareness;
+    const tryCompact = () => {
+      try {
+        if (log.length < COMPACT_OPS_THRESHOLD) return;
+        if (Date.now() - lastCompactedAt < COMPACT_MIN_INTERVAL_MS) return;
+        const keys = Array.from(awareness.getStates().keys());
+        if (keys.length === 0) return;
+        const designated = Math.min(...keys);
+        if (designated !== doc.clientID) return;
+        const wb = api.getActiveWorkbook();
+        if (!wb) return;
+        const snap = wb.save();
+        const snapshotRec = {
+          kind: "snapshot",
+          c: myClientId,
+          t: Date.now(),
+          wb: snap
+        };
+        const opsBefore = log.length;
+        doc.transact(() => {
+          log.delete(0, log.length);
+          log.push([snapshotRec]);
+        });
+        appliedCount = 1;
+        lastCompactedAt = Date.now();
+        console.info("[collab] op-log compacted: %d ops \u2192 1 snapshot record", opsBefore);
+      } catch (err) {
+        console.warn("[collab] compaction attempt failed", err);
+      }
+    };
+    const ric = globalThis.requestIdleCallback;
+    if (typeof ric === "function") {
+      const scheduleNext = () => {
+        idleHandle = ric(
+          (deadline) => {
+            if (deadline.didTimeout || deadline.timeRemaining() > 5) {
+              tryCompact();
+            }
+            scheduleNext();
+          },
+          { timeout: COMPACT_CHECK_INTERVAL_MS }
+        );
+      };
+      scheduleNext();
+    } else {
+      intervalHandle = setInterval(tryCompact, COMPACT_CHECK_INTERVAL_MS);
+      intervalHandle.unref?.();
+    }
+    globalThis.__bridgeLogLength = () => log.length;
+    globalThis.__bridgeForceCompact = () => {
+      lastCompactedAt = 0;
+      tryCompact();
+    };
+  }
+  return {
+    doc,
+    dispose: () => {
+      subDispose.dispose();
+      subBeforeDispose.dispose();
+      if (pending.length > 0) flush();
+      log.unobserve(observer);
+      pendingUndo.clear();
+      replayFailureSubscribers.clear();
+      deadLetterSubscribers.clear();
+      if (intervalHandle) clearInterval(intervalHandle);
+      if (idleHandle !== null && typeof cic === "function") cic(idleHandle);
+    },
+    getReplayFailures: () => replayFailures,
+    subscribeReplayFailures: (cb) => {
+      replayFailureSubscribers.add(cb);
+      return () => {
+        replayFailureSubscribers.delete(cb);
+      };
+    },
+    getReplayDeadLetter: () => deadLetter,
+    subscribeReplayDeadLetter: (cb) => {
+      deadLetterSubscribers.add(cb);
+      return () => {
+        deadLetterSubscribers.delete(cb);
+      };
+    }
+  };
+}
+function rewriteUnitId(api, params, mutationId) {
+  const wb = api.getActiveWorkbook();
+  if (!wb) return params;
+  const localUnitId = wb.getId();
+  let senderUnitId;
+  if (mutationId === "sheet.mutation.set-drawing-apply" && params && typeof params === "object") {
+    const u = params.unitId;
+    if (typeof u === "string") senderUnitId = u;
+  }
+  const rewritten = deepRewriteUnitId(params, localUnitId);
+  if (!senderUnitId || senderUnitId === localUnitId) return rewritten;
+  if (rewritten && typeof rewritten === "object") {
+    const r = rewritten;
+    const fixedOp = rewriteJson1OpPathUnitId(r.op, senderUnitId, localUnitId);
+    if (fixedOp !== r.op) {
+      return { ...r, op: fixedOp };
+    }
+  }
+  return rewritten;
+}
+function captureActiveSheetId(api) {
+  try {
+    const wb = api.getActiveWorkbook();
+    if (!wb) return null;
+    const sheet = wb.getActiveSheet();
+    if (!sheet) return null;
+    const id = sheet.getSheetId?.() ?? sheet.getId?.() ?? null;
+    return typeof id === "string" ? id : null;
+  } catch {
+    return null;
+  }
+}
+function restoreActiveSheetId(api, sheetId) {
+  try {
+    const wb = api.getActiveWorkbook();
+    if (!wb) return;
+    const current = wb.getActiveSheet()?.getSheetId?.();
+    if (current === sheetId) return;
+    const sheets = wb.getSheets();
+    const target = sheets.find((s) => s.getSheetId?.() === sheetId);
+    if (!target) return;
+    wb.setActiveSheet?.(target);
+  } catch (err) {
+    console.warn("[collab] failed to restore active sheet after remote insert-sheet", err);
+  }
+}
+function hasSplitChunkMarker(params) {
+  if (!params || typeof params !== "object") return false;
+  return Object.prototype.hasOwnProperty.call(params, "__splitChunk__");
+}
+
+// src/collab/ws-url.ts
+function buildWsUrl(server, room, role, password) {
+  const sep = server.includes("?") ? "&" : "?";
+  return `${server}${sep}room=${encodeURIComponent(room)}${password ? `&p=${encodeURIComponent(password)}` : ""}&role=${encodeURIComponent(role)}`;
+}
+
+// src/collab/attachCollab.ts
+function resolveFacade(api) {
+  const maybe = api;
+  return typeof maybe.getActiveWorkbook === "function" ? api : maybe.univer;
+}
+function attachCollab(api, opts) {
+  const facade = resolveFacade(api);
+  const role = opts.role ?? "write";
+  const doc = new Y.Doc();
+  const ws = new import_provider.HocuspocusProviderWebsocket({
+    url: buildWsUrl(opts.server, opts.room, role, opts.password),
+    messageReconnectTimeout: 1e4
+  });
+  const provider = new import_provider.HocuspocusProvider({
+    websocketProvider: ws,
+    name: opts.room,
+    document: doc,
+    // Truthy token so the handshake completes even when the server has an
+    // onAuthenticate hook (used for role enforcement). See option docs above.
+    token: opts.token ?? "anon"
+  });
+  const bridge = startBridge(facade, doc, {
+    role,
+    awareness: provider.awareness ?? void 0,
+    onSnapshotReceived: opts.onSnapshot
+  });
+  let current = "connecting";
+  const onStatus = (ev) => {
+    const next = ev.status === "connected" ? "live" : ev.status === "connecting" ? "connecting" : "offline";
+    if (next === current) return;
+    current = next;
+    opts.onStatus?.(next);
+  };
+  provider.on("status", onStatus);
+  let detached = false;
+  const detach = () => {
+    if (detached) return;
+    detached = true;
+    provider.off("status", onStatus);
+    bridge.dispose();
+    provider.destroy();
+    doc.destroy();
+  };
+  return {
+    doc,
+    provider,
+    bridge,
+    status: () => current,
+    detach
+  };
+}
+//# sourceMappingURL=collab.cjs.map