@arbidocs/coedit 0.0.0-stage → 0.4.33

package/dist/hocuspocus.cjs

@@ -0,0 +1,1723 @@
+'use strict';
+
+var Y3 = require('yjs');
+var awareness = require('y-protocols/awareness');
+var provider = require('@hocuspocus/provider');
+var store = require('@docx-editor.dev/core/store');
+var collaboration = require('@docx-editor.dev/core/collaboration');
+var replication = require('@docx-editor.dev/core/collaboration/replication');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var Y3__namespace = /*#__PURE__*/_interopNamespace(Y3);
+
+// src/hocuspocus.ts
+
+// src/rich.ts
+var WML = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+var WRAPPERS = /* @__PURE__ */ new Set([
+  "ins",
+  "del",
+  "moveFrom",
+  "moveTo",
+  "hyperlink",
+  "smartTag",
+  "fldSimple",
+  "customXml",
+  "dir",
+  "bdo",
+  "sdtContent"
+]);
+var TEXT_ELEMENTS = /* @__PURE__ */ new Set(["t", "delText", "instrText"]);
+var isEl = (n) => typeof n !== "string";
+var isWml = (el, local) => el.ns === WML && el.local === local;
+function describe(el) {
+  const desc = { ns: el.ns, local: el.local, attrs: el.attrs, bindings: el.bindings };
+  if (el.prefix !== void 0) desc.prefix = el.prefix;
+  return desc;
+}
+function withChildren(desc, children, id) {
+  const el = {
+    ns: desc.ns,
+    local: desc.local,
+    attrs: desc.attrs,
+    bindings: desc.bindings,
+    children
+  };
+  if (desc.prefix !== void 0) el.prefix = desc.prefix;
+  if (id !== void 0) el._id = id;
+  return el;
+}
+var counter = 0;
+function newRunId() {
+  counter += 1;
+  return `${Math.random().toString(36).slice(2, 8)}${counter.toString(36)}`;
+}
+var Unrepresentable = class extends Error {
+};
+function fail() {
+  throw new Unrepresentable();
+}
+function encodeRun(run, wrappers, out) {
+  const children = run.children;
+  let rPr = null;
+  let start = 0;
+  const first = children[0];
+  if (first !== void 0 && isEl(first) && isWml(first, "rPr")) {
+    rPr = first;
+    start = 1;
+  }
+  const base = { r: rPr, ra: describe(run), ri: run._id ?? newRunId(), w: wrappers };
+  let produced = false;
+  for (let i = start; i < children.length; i++) {
+    const child = children[i];
+    if (!isEl(child)) fail();
+    const only = child.children[0];
+    if (child.ns === WML && TEXT_ELEMENTS.has(child.local) && child.children.length === 1 && typeof only === "string" && only.length > 0) {
+      const tx = describe(child);
+      for (let c = 0; c < only.length; c++) out.push({ v: only[c], a: { ...base, tx, k: null } });
+    } else {
+      out.push({ v: { x: child }, a: { ...base, tx: null, k: null } });
+    }
+    produced = true;
+  }
+  if (!produced)
+    out.push({
+      v: { x: { ns: WML, local: "e", attrs: [], bindings: [], children: [] } },
+      a: { ...base, tx: null, k: "e" }
+    });
+}
+function encodeInline(children, wrappers, out) {
+  for (const child of children) {
+    if (!isEl(child)) fail();
+    if (child.ns === WML && child.local === "r") {
+      encodeRun(child, wrappers, out);
+    } else if (child.ns === WML && WRAPPERS.has(child.local)) {
+      const before = out.length;
+      const desc = { ...describe(child), head: [], id: child._id ?? newRunId() };
+      let ok = true;
+      const inner = [];
+      try {
+        encodeInline(child.children, [...wrappers, desc], inner);
+      } catch (error) {
+        if (!(error instanceof Unrepresentable)) throw error;
+        ok = false;
+      }
+      if (ok && inner.length > 0) out.push(...inner);
+      else {
+        out.length = before;
+        out.push(atom(child, wrappers));
+      }
+    } else if (child.ns === WML && child.local === "sdt") {
+      const last = child.children[child.children.length - 1];
+      const head = child.children.slice(0, -1);
+      if (last !== void 0 && isEl(last) && isWml(last, "sdtContent") && head.every(isEl)) {
+        const before = out.length;
+        const sdt = {
+          ...describe(child),
+          head,
+          id: child._id ?? newRunId()
+        };
+        const content = { ...describe(last), head: [], id: last._id ?? newRunId() };
+        const inner = [];
+        let ok = true;
+        try {
+          encodeInline(last.children, [...wrappers, sdt, content], inner);
+        } catch (error) {
+          if (!(error instanceof Unrepresentable)) throw error;
+          ok = false;
+        }
+        if (ok && inner.length > 0) out.push(...inner);
+        else {
+          out.length = before;
+          out.push(atom(child, wrappers));
+        }
+      } else out.push(atom(child, wrappers));
+    } else {
+      out.push(atom(child, wrappers));
+    }
+  }
+}
+function atom(el, wrappers) {
+  return { v: { x: el }, a: { r: null, ra: null, ri: null, w: wrappers, tx: null, k: "a" } };
+}
+function encodeParagraph(children) {
+  const head = [];
+  let start = 0;
+  const first = children[0];
+  if (first !== void 0 && isEl(first) && isWml(first, "pPr")) {
+    head.push(first);
+    start = 1;
+  }
+  const units = [];
+  try {
+    encodeInline(children.slice(start), [], units);
+  } catch (error) {
+    if (error instanceof Unrepresentable) return null;
+    throw error;
+  }
+  return { head, units };
+}
+var same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+function decodeRange(units, from, to, depth) {
+  const out = [];
+  let i = from;
+  while (i < to) {
+    const unit = units[i];
+    const { w } = unit.a;
+    if (w.length > depth) {
+      const wrapper = w[depth];
+      let j = i + 1;
+      while (j < to && units[j].a.w.length > depth && same(units[j].a.w[depth], wrapper)) j++;
+      out.push(
+        withChildren(wrapper, [...wrapper.head, ...decodeRange(units, i, j, depth + 1)], wrapper.id)
+      );
+      i = j;
+    } else if (unit.a.k === "a") {
+      out.push(unit.v.x);
+      i++;
+    } else {
+      let j = i + 1;
+      while (unit.a.k !== "e" && j < to && units[j].a.w.length === depth && units[j].a.k !== "a" && units[j].a.k !== "e" && units[j].a.ri === unit.a.ri && same(units[j].a.r, unit.a.r) && same(units[j].a.ra, unit.a.ra)) {
+        j++;
+      }
+      out.push(decodeRun(units, i, j));
+      i = j;
+    }
+  }
+  return out;
+}
+function decodeRun(units, from, to) {
+  const { r, ra } = units[from].a;
+  const children = [];
+  if (r) children.push(r);
+  let i = from;
+  while (i < to) {
+    const unit = units[i];
+    if (unit.a.k === "e") {
+      i++;
+    } else if (typeof unit.v === "string") {
+      let j = i + 1;
+      while (j < to && typeof units[j].v === "string" && same(units[j].a.tx, unit.a.tx)) j++;
+      let text = "";
+      for (let c = i; c < j; c++) text += units[c].v;
+      children.push(withChildren(unit.a.tx, [text]));
+      i = j;
+    } else {
+      children.push(unit.v.x);
+      i++;
+    }
+  }
+  return withChildren(ra, children, units[from].a.ri ?? void 0);
+}
+function decodeInline(units) {
+  return decodeRange(units, 0, units.length, 0);
+}
+var KEYS = ["r", "ra", "ri", "w", "tx", "k"];
+function toAttributes(a) {
+  const out = {};
+  for (const key of KEYS) {
+    const value = a[key];
+    if (value !== null && !(key === "w" && value.length === 0)) out[key] = value;
+  }
+  return out;
+}
+function fromAttributes(attributes) {
+  const a = attributes ?? {};
+  return {
+    r: a.r ?? null,
+    ra: a.ra ?? null,
+    ri: a.ri ?? null,
+    w: a.w ?? [],
+    tx: a.tx ?? null,
+    k: a.k ?? null
+  };
+}
+function readUnits(text) {
+  const units = [];
+  for (const op of text.toDelta()) {
+    const a = fromAttributes(op.attributes);
+    if (typeof op.insert === "string") {
+      for (let i = 0; i < op.insert.length; i++) units.push({ v: op.insert[i], a });
+    } else {
+      units.push({ v: op.insert, a });
+    }
+  }
+  return units;
+}
+var valueKeyOf = (u) => typeof u.v === "string" ? u.v : JSON.stringify(u.v);
+var attrsKeyOf = (u) => JSON.stringify(u.a);
+function attributeChange(from, to) {
+  const a = toAttributes(from);
+  const b = toAttributes(to);
+  const change = {};
+  for (const key of KEYS) {
+    if (JSON.stringify(a[key]) !== JSON.stringify(b[key])) change[key] = b[key] ?? null;
+  }
+  return change;
+}
+function pushRetain(delta, length, attributes) {
+  if (length === 0) return;
+  const last = delta[delta.length - 1];
+  const empty = !attributes || Object.keys(attributes).length === 0;
+  if (last && last.retain !== void 0 && !last.attributes && empty) {
+    last.retain += length;
+    return;
+  }
+  delta.push(empty ? { retain: length } : { retain: length, attributes });
+}
+function reformat(delta, previous, from, next, to, length) {
+  let i = 0;
+  while (i < length) {
+    const change = attributeChange(previous[from + i].a, next[to + i].a);
+    const key = JSON.stringify(change);
+    let j = i + 1;
+    while (j < length && JSON.stringify(attributeChange(previous[from + j].a, next[to + j].a)) === key) {
+      j++;
+    }
+    pushRetain(delta, j - i, change);
+    i = j;
+  }
+}
+function applyUnits(text, previous, next) {
+  let start = 0;
+  const limit = Math.min(previous.length, next.length);
+  while (start < limit && valueKeyOf(previous[start]) === valueKeyOf(next[start])) start++;
+  let endPrev = previous.length;
+  let endNext = next.length;
+  while (endPrev > start && endNext > start && valueKeyOf(previous[endPrev - 1]) === valueKeyOf(next[endNext - 1])) {
+    endPrev--;
+    endNext--;
+  }
+  const delta = [];
+  reformat(delta, previous, 0, next, 0, start);
+  if (endPrev > start) delta.push({ delete: endPrev - start });
+  let i = start;
+  while (i < endNext) {
+    const unit = next[i];
+    if (typeof unit.v !== "string") {
+      delta.push({ insert: unit.v, attributes: toAttributes(unit.a) });
+      i++;
+      continue;
+    }
+    let j = i + 1;
+    let chunk = unit.v;
+    const attributes = attrsKeyOf(unit);
+    while (j < endNext && typeof next[j].v === "string" && attrsKeyOf(next[j]) === attributes) {
+      chunk += next[j].v;
+      j++;
+    }
+    delta.push({ insert: chunk, attributes: toAttributes(unit.a) });
+    i = j;
+  }
+  reformat(delta, previous, endPrev, next, endNext, previous.length - endPrev);
+  if (delta.every((op) => op.retain !== void 0 && !op.attributes)) return;
+  text.applyDelta(delta, { sanitize: false });
+}
+function writeUnits(text, units) {
+  applyUnits(text, [], units);
+}
+
+// src/mirror.ts
+function isRichParagraph(map) {
+  return map.has("inline");
+}
+function isParagraphEl(el) {
+  return el.ns === WML && el.local === "p";
+}
+function fieldsOf(map, xml) {
+  map.set("ns", xml.ns);
+  map.set("local", xml.local);
+  if (xml.prefix !== void 0) map.set("prefix", xml.prefix);
+  const attrs = new Y3__namespace.Array();
+  attrs.push(xml.attrs.map((a) => ({ ...a })));
+  map.set("attrs", attrs);
+  const bindings = new Y3__namespace.Array();
+  bindings.push(xml.bindings.map((b) => ({ ...b })));
+  map.set("bindings", bindings);
+}
+function newText(value) {
+  const text = new Y3__namespace.Text();
+  text.insert(0, value);
+  return text;
+}
+function createRichParagraph(xml, encoded) {
+  const map = new Y3__namespace.Map();
+  fieldsOf(map, xml);
+  const children = new Y3__namespace.Array();
+  children.push(encoded.head.map((el) => xmlToLive(el)));
+  map.set("children", children);
+  const inline = new Y3__namespace.Text();
+  writeUnits(inline, encoded.units);
+  map.set("inline", inline);
+  return map;
+}
+function xmlToLive(xml) {
+  if (isParagraphEl(xml)) {
+    const encoded = encodeParagraph(xml.children);
+    if (encoded) return createRichParagraph(xml, encoded);
+  }
+  return xmlToGenericLive(xml);
+}
+function xmlToGenericLive(xml) {
+  const map = new Y3__namespace.Map();
+  fieldsOf(map, xml);
+  const children = new Y3__namespace.Array();
+  children.push(xml.children.map((c) => typeof c === "string" ? newText(c) : xmlToLive(c)));
+  map.set("children", children);
+  return map;
+}
+function liveToXml(map) {
+  const prefix = map.get("prefix");
+  const stored = map.get("children").toArray().map((child) => child instanceof Y3__namespace.Text ? child.toString() : liveToXml(child));
+  const children = isRichParagraph(map) ? [...stored, ...decodeInline(readUnits(map.get("inline")))] : stored;
+  const xml = {
+    ns: map.get("ns"),
+    local: map.get("local"),
+    attrs: map.get("attrs").toArray().map((a) => ({ ...a })),
+    bindings: map.get("bindings").toArray().map((b) => ({ ...b })),
+    children
+  };
+  if (prefix !== void 0) xml.prefix = prefix;
+  return xml;
+}
+var escapeText = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var escapeAttr = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/\t/g, "&#9;").replace(/\n/g, "&#10;").replace(/\r/g, "&#13;");
+var qualified = (prefix, local) => prefix ? `${prefix}:${local}` : local;
+function serializeXml(el, scope) {
+  const inScope = new Map(scope);
+  for (const b of el.bindings) inScope.set(b.prefix, b.ns);
+  let out = `<${qualified(el.prefix, el.local)}`;
+  for (const b of el.bindings) {
+    out += b.prefix === "" ? ` xmlns="${escapeAttr(b.ns)}"` : ` xmlns:${b.prefix}="${escapeAttr(b.ns)}"`;
+  }
+  for (const a of el.attrs) {
+    let p = a.prefix;
+    if (a.ns !== "" && !p) {
+      for (const [candidate, uri] of inScope) {
+        if (candidate !== "" && uri === a.ns) {
+          p = candidate;
+          break;
+        }
+      }
+    }
+    out += ` ${qualified(p, a.local)}="${escapeAttr(a.value)}"`;
+  }
+  if (el.children.length === 0) return `${out}/>`;
+  out += ">";
+  for (const child of el.children) {
+    out += typeof child === "string" ? escapeText(child) : serializeXml(child, inScope);
+  }
+  return `${out}</${qualified(el.prefix, el.local)}>`;
+}
+function serializeLive(el, scope) {
+  if (isRichParagraph(el)) return serializeXml(liveToXml(el), scope);
+  const prefix = el.get("prefix");
+  const local = el.get("local");
+  const bindings = el.get("bindings").toArray();
+  const attrs = el.get("attrs").toArray();
+  const children = el.get("children").toArray();
+  const inScope = new Map(scope);
+  for (const b of bindings) inScope.set(b.prefix, b.ns);
+  let out = `<${qualified(prefix, local)}`;
+  for (const b of bindings) {
+    out += b.prefix === "" ? ` xmlns="${escapeAttr(b.ns)}"` : ` xmlns:${b.prefix}="${escapeAttr(b.ns)}"`;
+  }
+  for (const a of attrs) {
+    let p = a.prefix;
+    if (a.ns !== "" && !p) {
+      for (const [candidate, uri] of inScope) {
+        if (candidate !== "" && uri === a.ns) {
+          p = candidate;
+          break;
+        }
+      }
+    }
+    out += ` ${qualified(p, a.local)}="${escapeAttr(a.value)}"`;
+  }
+  if (children.length === 0) return `${out}/>`;
+  out += ">";
+  for (const child of children) {
+    out += child instanceof Y3__namespace.Text ? escapeText(child.toString()) : serializeLive(child, inScope);
+  }
+  return `${out}</${qualified(prefix, local)}>`;
+}
+
+// src/encoding.ts
+var COLLAB_FORMAT = "arbi-docx/1";
+function isBootstrapped(doc) {
+  return doc.getMap("meta").get("format") !== void 0;
+}
+function readFormat(doc) {
+  const format = doc.getMap("meta").get("format");
+  return typeof format === "string" ? format : void 0;
+}
+function serializePart(doc, partName) {
+  const root = doc.getMap("parts").get(partName);
+  if (!root) throw new Error(`collab: part ${partName} is not in the room`);
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+${serializeLive(root, /* @__PURE__ */ new Map())}`;
+}
+function contentTypeOf(doc, partName) {
+  const override = doc.getMap("ctOverrides").get(partName.toLowerCase());
+  if (override !== void 0) return override;
+  const dot = partName.lastIndexOf(".");
+  if (dot < 0) return void 0;
+  return doc.getMap("ctDefaults").get(partName.slice(dot + 1).toLowerCase());
+}
+function registerMirror(doc, registry, only) {
+  const parts = doc.getMap("parts");
+  if (!only) {
+    registry.clear();
+    for (const [name, root] of parts) registry.registerTree(name, root);
+    return;
+  }
+  for (const name of only) {
+    registry.dropPart(name);
+    const root = parts.get(name);
+    if (root) registry.registerTree(name, root);
+  }
+}
+var MaterializeCache = class {
+  parts = /* @__PURE__ */ new Map();
+  dirty = /* @__PURE__ */ new Set();
+  everything = true;
+  stop = [];
+  constructor(doc) {
+    const parts = doc.getMap("parts");
+    const onParts = (events) => {
+      for (const event of events) {
+        if (event.target === parts) {
+          for (const key of event.keysChanged) this.dirty.add(key);
+        } else if (typeof event.path[0] === "string") this.dirty.add(event.path[0]);
+      }
+    };
+    parts.observeDeep(onParts);
+    this.stop.push(() => parts.unobserveDeep(onParts));
+    for (const name of ["ctOverrides", "ctDefaults"]) {
+      const map = doc.getMap(name);
+      const onTypes = () => {
+        this.everything = true;
+      };
+      map.observe(onTypes);
+      this.stop.push(() => map.unobserve(onTypes));
+    }
+  }
+  /** Names to re-read, or null when everything must be. Clears the pending set. */
+  take() {
+    const names = this.everything ? null : this.dirty;
+    this.dirty = /* @__PURE__ */ new Set();
+    this.everything = false;
+    return names;
+  }
+  /** Mark parts changed again, for a materialisation that did not complete. */
+  restore(names) {
+    if (names === null) this.everything = true;
+    else for (const name of names) this.dirty.add(name);
+  }
+  destroy() {
+    for (const stop of this.stop.splice(0)) stop();
+  }
+};
+var RELS_CONTENT_TYPE = "application/vnd.openxmlformats-package.relationships+xml";
+var RELS_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/relationships";
+function isRelsPart(partName) {
+  return partName.endsWith(".rels");
+}
+function relationshipsXml(records) {
+  const rows = records.map(
+    (r) => `<Relationship Id="${escapeAttr(r.id)}" Type="${escapeAttr(r.type)}" Target="${escapeAttr(r.rawTarget)}"${r.targetMode === "External" ? ' TargetMode="External"' : ""}/>`
+  ).join("");
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="${RELS_NAMESPACE}">${rows}</Relationships>`;
+}
+var MaterializeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MaterializeError";
+  }
+};
+function materialize(doc, cache, changed = null) {
+  const meta = doc.getMap("meta");
+  const main = meta.get("mainDocumentPart");
+  if (typeof main !== "string") throw new MaterializeError("room has no main document part");
+  const parts = /* @__PURE__ */ new Map();
+  for (const name of doc.getMap("parts").keys()) {
+    if (isRelsPart(name)) continue;
+    const reusable = cache && changed && !changed.has(name) ? cache.parts.get(name) : void 0;
+    if (reusable) {
+      parts.set(name, reusable);
+      continue;
+    }
+    const contentType = contentTypeOf(doc, name);
+    if (contentType === void 0) throw new MaterializeError(`part ${name} has no content type`);
+    const read = store.readOoxmlPart(serializePart(doc, name), { name, contentType });
+    if (!read.ok) throw new MaterializeError(`part ${name} is not readable: ${read.reason}`);
+    parts.set(name, read.part);
+  }
+  if (cache) {
+    cache.parts.clear();
+    for (const [name, part] of parts) if (!isRelsPart(name)) cache.parts.set(name, part);
+  }
+  const partBytes = /* @__PURE__ */ new Map();
+  for (const [name, bytes] of doc.getMap("binaries")) partBytes.set(name, bytes);
+  const relationships = /* @__PURE__ */ new Map();
+  const externalTargets = [];
+  for (const [owner, byId] of doc.getMap("rels")) {
+    const records = [...byId.values()].sort((a, b) => a.order - b.order || a.id.localeCompare(b.id));
+    if (records.length === 0) continue;
+    const internal = records.filter((r) => r.targetMode !== "External");
+    if (internal.length > 0) relationships.set(owner, internal);
+    for (const r of records) {
+      if (r.targetMode !== "External") continue;
+      externalTargets.push({
+        ownerPart: r.ownerPart,
+        id: r.id,
+        type: r.type,
+        rawTarget: r.rawTarget,
+        sinkSafe: store.validateExternalTarget(r.rawTarget).ok
+      });
+    }
+    const relsName = store.relsPartNameFor(owner);
+    const read = store.readOoxmlPart(relationshipsXml(records), {
+      name: relsName,
+      contentType: RELS_CONTENT_TYPE
+    });
+    if (!read.ok)
+      throw new MaterializeError(`relationships of ${owner} are not valid: ${read.reason}`);
+    parts.set(relsName, read.part);
+  }
+  const contentTypes = {
+    defaults: new Map(doc.getMap("ctDefaults")),
+    overrides: new Map(doc.getMap("ctOverrides"))
+  };
+  return {
+    parts,
+    partBytes,
+    relationships,
+    externalTargets,
+    contentTypes,
+    mainDocumentPart: main
+  };
+}
+function materializeBytes(doc) {
+  return store.writeOoxmlPackage(materialize(doc));
+}
+var RegistryError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RegistryError";
+  }
+};
+function childrenOf(el) {
+  return el.get("children");
+}
+function attrsOf(el) {
+  return el.get("attrs");
+}
+function bindingsOf(el) {
+  return el.get("bindings");
+}
+var IDENTIFIED = /* @__PURE__ */ new Set([
+  "r",
+  "ins",
+  "del",
+  "moveFrom",
+  "moveTo",
+  "hyperlink",
+  "smartTag",
+  "fldSimple",
+  "customXml",
+  "dir",
+  "bdo",
+  "sdt",
+  "sdtContent"
+]);
+function plainToXml(node) {
+  if (node.type === "text") return node.value;
+  const xml = {
+    ns: node.ns,
+    local: node.local,
+    attrs: node.attrs.map((a) => ({ ...a })),
+    bindings: node.bindings.map((b) => ({ ...b })),
+    children: node.children.map(plainToXml)
+  };
+  if (node.prefix !== void 0) xml.prefix = node.prefix;
+  if (node.ns === WML && IDENTIFIED.has(node.local)) {
+    node.rid ??= newRunId();
+    xml._id = node.rid;
+  }
+  return xml;
+}
+function xmlToPlain(xml, id) {
+  if (typeof xml === "string") return { type: "text", id, value: xml };
+  const plain = {
+    type: "element",
+    id,
+    ns: xml.ns,
+    local: xml.local,
+    attrs: xml.attrs.map((a) => ({ ...a })),
+    bindings: xml.bindings.map((b) => ({ ...b })),
+    children: xml.children.map((child, index) => xmlToPlain(child, `${id}.${index}`))
+  };
+  if (xml.prefix !== void 0) plain.prefix = xml.prefix;
+  if (xml._id !== void 0) plain.rid = xml._id;
+  return plain;
+}
+var partOf = (id) => id.slice(0, id.indexOf("#"));
+var NodeRegistry = class {
+  entries = /* @__PURE__ */ new Map();
+  /** Ids per part (the text before `#`), so one part can be dropped without scanning the rest. */
+  byPart = /* @__PURE__ */ new Map();
+  liveIds = /* @__PURE__ */ new WeakMap();
+  open = /* @__PURE__ */ new Map();
+  ownerOf = /* @__PURE__ */ new WeakMap();
+  dirty = /* @__PURE__ */ new Set();
+  clear() {
+    this.entries.clear();
+    this.byPart.clear();
+    this.open.clear();
+    this.dirty.clear();
+  }
+  /** Forget every node of one part, live or detached. */
+  dropPart(partName) {
+    for (const id of this.byPart.get(partName) ?? []) this.entries.delete(id);
+    this.byPart.delete(partName);
+    for (const [live, record] of this.open) {
+      if (partOf(record.id) !== partName) continue;
+      this.open.delete(live);
+      this.dirty.delete(live);
+    }
+  }
+  index(id) {
+    const part = partOf(id);
+    let ids = this.byPart.get(part);
+    if (!ids) this.byPart.set(part, ids = /* @__PURE__ */ new Set());
+    ids.add(id);
+  }
+  get(id) {
+    return this.entries.get(id);
+  }
+  require(id) {
+    let entry = this.entries.get(id) ?? this.resolveInsideParagraph(id);
+    if (!entry) throw new RegistryError(`journal names unknown node ${id}`);
+    if ("live" in entry && entry.live instanceof Y3__namespace.Map && isRichParagraph(entry.live)) {
+      this.openParagraph(entry.live);
+      entry = this.entries.get(id);
+    }
+    if ("plain" in entry) {
+      const owner = this.ownerOf.get(entry.plain);
+      if (owner) this.dirty.add(owner);
+    }
+    return entry;
+  }
+  /** An id inside a paragraph that is not open yet: open the paragraph it belongs to. */
+  resolveInsideParagraph(id) {
+    const hash = id.indexOf("#");
+    if (hash < 0 || id.startsWith("new:", hash + 1)) return void 0;
+    const path = id.slice(hash + 1).split(".");
+    for (let length = path.length - 1; length >= 1; length--) {
+      const ancestor = this.entries.get(id.slice(0, hash + 1) + path.slice(0, length).join("."));
+      if (!ancestor) continue;
+      if ("live" in ancestor && ancestor.live instanceof Y3__namespace.Map && isRichParagraph(ancestor.live)) {
+        this.openParagraph(ancestor.live);
+        return this.entries.get(id);
+      }
+      return void 0;
+    }
+    return void 0;
+  }
+  idOf(node) {
+    return this.liveIds.get(node);
+  }
+  isCurrentLive(id, node) {
+    const entry = this.entries.get(id);
+    return entry !== void 0 && "live" in entry && entry.live === node;
+  }
+  registerLive(id, node) {
+    this.entries.set(id, { live: node });
+    this.liveIds.set(node, id);
+    this.index(id);
+  }
+  registerPlain(node, keepNewer = false) {
+    const existing = this.entries.get(node.id);
+    if (!(keepNewer && existing && "plain" in existing)) {
+      this.entries.set(node.id, { plain: node });
+      this.index(node.id);
+    }
+    if (node.type === "element")
+      for (const child of node.children) this.registerPlain(child, keepNewer);
+  }
+  /**
+   * Walk a mirror root and register every node under its positional id, `${part}#0` for the root and
+   * `${parent}.${index}` below it. This is the id scheme core assigns when it reads a part. A rich
+   * paragraph is registered as one node; its inner nodes appear when it is opened.
+   */
+  registerTree(partName, root) {
+    const walk = (node, id) => {
+      this.registerLive(id, node);
+      if (node instanceof Y3__namespace.Text) return;
+      if (isRichParagraph(node)) return;
+      childrenOf(node).forEach((child, index) => walk(child, `${id}.${index}`));
+    };
+    walk(root, `${partName}#0`);
+  }
+  // ── Rich paragraphs ──────────────────────────────────────────────────────
+  own(node, live) {
+    if (live) this.ownerOf.set(node, live);
+    else this.ownerOf.delete(node);
+    if (node.type === "element") for (const child of node.children) this.own(child, live);
+  }
+  openParagraph(live) {
+    const existing = this.open.get(live);
+    if (existing) return existing;
+    const id = this.liveIds.get(live);
+    if (id === void 0) throw new RegistryError("paragraph has no registered id");
+    const root = xmlToPlain(liveToXml(live), id);
+    const record = { live, root, id };
+    this.open.set(live, record);
+    this.registerPlain(root, true);
+    this.own(root, live);
+    return record;
+  }
+  /** The Yjs paragraph an open plain root stands for. */
+  liveOfRoot(node) {
+    const live = this.ownerOf.get(node);
+    return live && this.open.get(live)?.root === node ? live : void 0;
+  }
+  /** Parent and index of a node inside an open paragraph. */
+  locatePlain(node) {
+    const live = this.ownerOf.get(node);
+    const record = live && this.open.get(live);
+    if (!record) return void 0;
+    const search = (parent) => {
+      const index = parent.children.indexOf(node);
+      if (index >= 0) return { parent, index };
+      for (const child of parent.children) {
+        if (child.type === "element") {
+          const found = search(child);
+          if (found) return found;
+        }
+      }
+      return void 0;
+    };
+    return search(record.root);
+  }
+  /** Mark the paragraph a plain node belongs to as changed. */
+  touch(node) {
+    const owner = this.ownerOf.get(node);
+    if (owner) this.dirty.add(owner);
+  }
+  /** Nodes just placed under `parent` belong to the same paragraph as it, if any. */
+  adopt(parent, children) {
+    const owner = this.ownerOf.get(parent);
+    for (const child of children) this.own(child, owner);
+    if (owner) this.dirty.add(owner);
+  }
+  /** Write every changed open paragraph back into the mirror. Call at the end of a journal. */
+  flushRich() {
+    for (const live of [...this.dirty]) {
+      this.dirty.delete(live);
+      const record = this.open.get(live);
+      if (record) this.writeBack(record);
+    }
+  }
+  writeBack(record) {
+    const { live, root } = record;
+    const xml = plainToXml(root);
+    const encoded = encodeParagraph(xml.children);
+    if (!encoded) {
+      this.degrade(record);
+      return;
+    }
+    const attrs = attrsOf(live);
+    if (JSON.stringify(attrs.toArray()) !== JSON.stringify(xml.attrs)) {
+      attrs.delete(0, attrs.length);
+      attrs.push(xml.attrs.map((a) => ({ ...a })));
+    }
+    const bindings = bindingsOf(live);
+    if (JSON.stringify(bindings.toArray()) !== JSON.stringify(xml.bindings)) {
+      bindings.delete(0, bindings.length);
+      bindings.push(xml.bindings.map((b) => ({ ...b })));
+    }
+    const head = childrenOf(live);
+    const stored = head.toArray().map((child) => liveToXml(child));
+    if (JSON.stringify(stored) !== JSON.stringify(encoded.head)) {
+      head.delete(0, head.length);
+      head.push(encoded.head.map((el) => xmlToLive(el)));
+    }
+    const inline = live.get("inline");
+    applyUnits(inline, readUnits(inline), encoded.units);
+  }
+  /** The paragraph can no longer be held as rich text: store it as plain elements instead. */
+  degrade(record) {
+    const parent = record.live.parent;
+    if (!(parent instanceof Y3__namespace.Array))
+      throw new RegistryError("a paragraph outside a parent cannot change form");
+    const index = parent.toArray().indexOf(record.live);
+    const generic = this.toGenericLive(record.root);
+    this.open.delete(record.live);
+    parent.delete(index, 1);
+    parent.insert(index, [generic]);
+  }
+  // ── Snapshots and conversion ─────────────────────────────────────────────
+  /** Deep copy of a node into plain objects carrying the same ids. */
+  snapshot(id) {
+    const entry = this.require(id);
+    if ("plain" in entry) return entry.plain;
+    return this.snapshotLive(entry.live);
+  }
+  snapshotLive(node) {
+    const id = this.liveIds.get(node);
+    if (id === void 0) throw new RegistryError("live node has no registered id");
+    if (node instanceof Y3__namespace.Text) return { type: "text", id, value: node.toString() };
+    if (isRichParagraph(node)) {
+      return this.open.get(node)?.root ?? xmlToPlain(liveToXml(node), id);
+    }
+    const prefix = node.get("prefix");
+    const plain = {
+      type: "element",
+      id,
+      ns: node.get("ns"),
+      local: node.get("local"),
+      attrs: attrsOf(node).toArray().map((a) => ({ ...a })),
+      bindings: bindingsOf(node).toArray().map((b) => ({ ...b })),
+      children: childrenOf(node).map((child) => this.snapshotLive(child))
+    };
+    if (prefix !== void 0) plain.prefix = prefix;
+    return plain;
+  }
+  /**
+   * Replace the registry entries of a subtree with plain copies, if they still point at these exact
+   * live nodes. A node that was already re-registered elsewhere (moved) is left alone.
+   */
+  detach(node) {
+    this.detachInto(node, this.snapshotLive(node));
+  }
+  detachInto(node, plain) {
+    const id = this.liveIds.get(node);
+    if (id !== void 0 && this.isCurrentLive(id, node)) {
+      this.entries.set(id, { plain });
+    }
+    if (node instanceof Y3__namespace.Text || plain.type === "text") return;
+    if (isRichParagraph(node)) {
+      this.open.delete(node);
+      this.dirty.delete(node);
+      return;
+    }
+    const liveChildren = childrenOf(node).toArray();
+    liveChildren.forEach((child, index) => this.detachInto(child, plain.children[index]));
+  }
+  /** Build Yjs types for a plain subtree and register every node as live. */
+  toLive(plain) {
+    if (plain.type === "text") {
+      const text = new Y3__namespace.Text();
+      text.insert(0, plain.value);
+      this.registerLive(plain.id, text);
+      return text;
+    }
+    if (isParagraphEl(plain)) {
+      const xml = plainToXml(plain);
+      const encoded = encodeParagraph(xml.children);
+      if (encoded) {
+        const map = createRichParagraph(xml, encoded);
+        this.liveIds.set(map, plain.id);
+        this.registerPlain(plain);
+        this.own(plain, map);
+        this.open.set(map, { live: map, root: plain, id: plain.id });
+        return map;
+      }
+    }
+    return this.toGenericLive(plain);
+  }
+  toGenericLive(plain) {
+    const map = xmlToGenericShell(plain);
+    const children = new Y3__namespace.Array();
+    children.push(plain.children.map((child) => this.toLive(child)));
+    map.set("children", children);
+    this.registerLive(plain.id, map);
+    return map;
+  }
+  /**
+   * A live node that can be inserted into a parent. Anything not yet attached is built fresh; an
+   * attached node is copied, because a Yjs type cannot have two parents.
+   */
+  attachable(id) {
+    return this.toLive(this.snapshot(id));
+  }
+};
+function xmlToGenericShell(plain) {
+  const map = new Y3__namespace.Map();
+  map.set("ns", plain.ns);
+  map.set("local", plain.local);
+  if (plain.prefix !== void 0) map.set("prefix", plain.prefix);
+  const attrs = new Y3__namespace.Array();
+  attrs.push(plain.attrs.map((a) => ({ ...a })));
+  map.set("attrs", attrs);
+  const bindings = new Y3__namespace.Array();
+  bindings.push(plain.bindings.map((b) => ({ ...b })));
+  map.set("bindings", bindings);
+  return map;
+}
+
+// src/journal.ts
+var JournalError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "JournalError";
+  }
+};
+function sameAttr(a, qname) {
+  return a.ns === qname.namespaceUri && a.local === qname.localName;
+}
+function attrJson(qname, value) {
+  const json = { ns: qname.namespaceUri, local: qname.localName, value };
+  if (qname.prefix !== void 0) json.prefix = qname.prefix;
+  return json;
+}
+function setAttribute(registry, id, qname, value) {
+  const entry = registry.require(id);
+  if ("plain" in entry) {
+    const el = asPlainElement(entry.plain, id);
+    const index2 = el.attrs.findIndex((a) => sameAttr(a, qname));
+    if (value === null) {
+      if (index2 >= 0) el.attrs.splice(index2, 1);
+    } else if (index2 >= 0) {
+      el.attrs[index2] = attrJson(qname, value);
+    } else {
+      el.attrs.push(attrJson(qname, value));
+    }
+    return;
+  }
+  const attrs = attrsOf(asLiveElement(entry.live, id));
+  const index = attrs.toArray().findIndex((a) => sameAttr(a, qname));
+  if (index >= 0) attrs.delete(index, 1);
+  if (value !== null) {
+    if (index >= 0) attrs.insert(index, [attrJson(qname, value)]);
+    else attrs.push([attrJson(qname, value)]);
+  }
+}
+function setNamespaceBinding(registry, id, prefix, uri) {
+  const entry = registry.require(id);
+  const binding = uri === null ? null : { prefix, ns: uri };
+  if ("plain" in entry) {
+    const el = asPlainElement(entry.plain, id);
+    const index2 = el.bindings.findIndex((b) => b.prefix === prefix);
+    if (index2 >= 0) el.bindings.splice(index2, 1);
+    if (binding) {
+      if (index2 >= 0) el.bindings.splice(index2, 0, binding);
+      else el.bindings.push(binding);
+    }
+    return;
+  }
+  const bindings = bindingsOf(asLiveElement(entry.live, id));
+  const index = bindings.toArray().findIndex((b) => b.prefix === prefix);
+  if (index >= 0) bindings.delete(index, 1);
+  if (binding) {
+    if (index >= 0) bindings.insert(index, [binding]);
+    else bindings.push([binding]);
+  }
+}
+function asLiveElement(node, id) {
+  if (node instanceof Y3__namespace.Text) throw new JournalError(`${id} is a text node, not an element`);
+  return node;
+}
+function asPlainElement(node, id) {
+  if (node.type === "text") throw new JournalError(`${id} is a text node, not an element`);
+  return node;
+}
+function spliceText(registry, id, start, deleteCount, insert) {
+  const entry = registry.require(id);
+  if ("plain" in entry) {
+    const text2 = entry.plain;
+    if (text2.type !== "text") throw new JournalError(`${id} is not a text node`);
+    text2.value = text2.value.slice(0, start) + insert + text2.value.slice(start + deleteCount);
+    return;
+  }
+  const text = entry.live;
+  if (!(text instanceof Y3__namespace.Text)) throw new JournalError(`${id} is not a text node`);
+  if (start < 0 || start + deleteCount > text.length) {
+    throw new JournalError(`text splice out of range on ${id}`);
+  }
+  if (deleteCount > 0) text.delete(start, deleteCount);
+  if (insert.length > 0) text.insert(start, insert);
+}
+function detachRemoved(registry, parent, start, count) {
+  for (let i = start; i < start + count; i++) registry.detach(parent.get(i));
+}
+function spliceChildren(registry, parentId, start, deleteCount, childIds) {
+  const parentEntry = registry.require(parentId);
+  if ("plain" in parentEntry) {
+    const parent = asPlainElement(parentEntry.plain, parentId);
+    if (start < 0 || start + deleteCount > parent.children.length) {
+      throw new JournalError(`child splice out of range on ${parentId}`);
+    }
+    const inserted2 = childIds.map((id) => registry.snapshot(id));
+    parent.children.splice(start, deleteCount, ...inserted2);
+    registry.adopt(parent, inserted2);
+    return;
+  }
+  const children = childrenOf(asLiveElement(parentEntry.live, parentId));
+  if (start < 0 || start + deleteCount > children.length) {
+    throw new JournalError(`child splice out of range on ${parentId}`);
+  }
+  detachRemoved(registry, children, start, deleteCount);
+  const inserted = childIds.map((id) => registry.attachable(id));
+  if (deleteCount > 0) children.delete(start, deleteCount);
+  if (inserted.length > 0) children.insert(start, inserted);
+}
+function locate(registry, id, node) {
+  const children = node.parent;
+  if (!(children instanceof Y3__namespace.Array)) throw new JournalError(`${id} is not attached`);
+  const index = children.toArray().indexOf(node);
+  if (index < 0) throw new JournalError(`${id} is not in its parent`);
+  return { children, index };
+}
+function moveNode(registry, id, destinationId, destinationIndex) {
+  const entry = registry.require(id);
+  const live = "live" in entry ? entry.live : registry.liveOfRoot(entry.plain);
+  const copy = registry.snapshot(id);
+  if (live) {
+    const { children: source, index } = locate(registry, id, live);
+    registry.detach(live);
+    source.delete(index, 1);
+  } else {
+    const plain = "plain" in entry ? entry.plain : void 0;
+    const where = plain && registry.locatePlain(plain);
+    if (!where) throw new JournalError(`cannot move detached node ${id}`);
+    where.parent.children.splice(where.index, 1);
+    registry.touch(where.parent);
+  }
+  const destinationEntry = registry.require(destinationId);
+  if ("plain" in destinationEntry) {
+    const destination2 = asPlainElement(destinationEntry.plain, destinationId);
+    destination2.children.splice(destinationIndex, 0, copy);
+    registry.adopt(destination2, [copy]);
+    return;
+  }
+  const destination = childrenOf(asLiveElement(destinationEntry.live, destinationId));
+  destination.insert(destinationIndex, [registry.toLive(copy)]);
+}
+function putNode(registry, effect) {
+  const d = effect.descriptor;
+  if (d.kind === "textValue") {
+    registry.registerPlain({ type: "text", id: d.logicalId, value: "" });
+    return;
+  }
+  const element = {
+    type: "element",
+    id: d.logicalId,
+    ns: d.qname.namespaceUri,
+    local: d.qname.localName,
+    attrs: [],
+    bindings: [],
+    children: []
+  };
+  if (d.qname.prefix !== void 0) element.prefix = d.qname.prefix;
+  registry.registerPlain(element);
+}
+function rootFor(registry, id) {
+  const entry = registry.require(id);
+  const live = "live" in entry && entry.live.parent === null ? entry.live : registry.attachable(id);
+  return asLiveElement(live, id);
+}
+function applyEffect(doc, registry, effect, context) {
+  switch (effect.kind) {
+    case "putNode":
+      putNode(registry, effect);
+      return;
+    case "spliceText":
+      spliceText(registry, effect.logicalId, effect.utf16Start, effect.deleteCount, effect.insert);
+      return;
+    case "setAttribute":
+      setAttribute(registry, effect.logicalId, effect.qname, effect.value);
+      return;
+    case "setNamespaceBinding":
+      setNamespaceBinding(registry, effect.logicalId, effect.prefix, effect.uri);
+      return;
+    case "spliceChildren":
+      spliceChildren(
+        registry,
+        effect.parentLogicalId,
+        effect.start,
+        effect.deleteCount,
+        effect.childLogicalIds
+      );
+      return;
+    case "moveNode":
+      moveNode(
+        registry,
+        effect.logicalId,
+        effect.destinationParentLogicalId,
+        effect.destinationIndex
+      );
+      return;
+    case "putXmlPart":
+      doc.getMap("parts").set(effect.name, rootFor(registry, effect.rootLogicalId));
+      return;
+    case "deleteXmlPart":
+      doc.getMap("parts").delete(effect.name);
+      return;
+    case "putRelationship": {
+      const rels = doc.getMap("rels");
+      let byId = rels.get(effect.owner);
+      if (!byId) {
+        byId = new Y3__namespace.Map();
+        rels.set(effect.owner, byId);
+      }
+      byId.set(effect.record.id, { ...effect.record });
+      return;
+    }
+    case "deleteRelationship":
+      doc.getMap("rels").get(effect.owner)?.delete(effect.relationshipId);
+      return;
+    case "putContentTypeOverride":
+      doc.getMap("ctOverrides").set(effect.partName.toLowerCase(), effect.mediaType);
+      return;
+    case "deleteContentTypeOverride":
+      doc.getMap("ctOverrides").delete(effect.partName.toLowerCase());
+      return;
+    case "putBinary": {
+      const bytes = context.binary(effect.descriptor.storageKey);
+      if (!bytes) throw new JournalError(`binary ${effect.descriptor.storageKey} is not available`);
+      doc.getMap("binaries").set(effect.descriptor.storageKey, bytes);
+      return;
+    }
+    case "deleteBinary":
+      doc.getMap("binaries").delete(effect.storageKey);
+      return;
+  }
+}
+function applyJournal(doc, registry, journal, origin, context) {
+  try {
+    doc.transact(() => {
+      for (const effect of journal.effects) applyEffect(doc, registry, effect, context);
+      registry.flushRich();
+    }, origin);
+  } catch (error) {
+    if (error instanceof JournalError || error instanceof RegistryError) throw error;
+    throw new JournalError(error instanceof Error ? error.message : String(error));
+  }
+}
+
+// src/sync.ts
+var LOCAL_ORIGIN = /* @__PURE__ */ Symbol("arbi-coedit/local");
+var DEFAULT_REMOTE_DELAY_MS = 40;
+var MirrorSync = class {
+  doc;
+  registry = new NodeRegistry();
+  cache;
+  port;
+  actorId;
+  onFailure;
+  onLocalJournal;
+  disposers = [];
+  remoteDelayMs;
+  operation = 0;
+  applyingRemote = false;
+  failed = false;
+  remoteDirty = false;
+  remoteOrigin;
+  remoteTimer;
+  /** Parts whose node ids must be re-registered before the next local journal; true means all. */
+  staleParts = null;
+  constructor(options) {
+    this.doc = options.doc;
+    this.port = options.port;
+    this.actorId = options.actorId;
+    this.onFailure = options.onFailure;
+    this.onLocalJournal = options.onLocalJournal;
+    this.remoteDelayMs = options.remoteDelayMs ?? DEFAULT_REMOTE_DELAY_MS;
+    registerMirror(this.doc, this.registry);
+    this.cache = new MaterializeCache(this.doc);
+    this.disposers.push(() => this.cache.destroy());
+    this.disposers.push(
+      this.port.observePrimitiveJournal((journal) => {
+        if (this.failed || this.applyingRemote) return;
+        try {
+          this.refreshRegistry();
+          this.onLocalJournal?.(journal);
+          applyJournal(this.doc, this.registry, journal, LOCAL_ORIGIN, {
+            binary: (key) => this.port.binaryPart(key)
+          });
+        } catch (error) {
+          this.fail("journal", error);
+        }
+      })
+    );
+    const onAfterTransaction = (transaction) => {
+      if (transaction.origin === LOCAL_ORIGIN || this.failed) return;
+      if (transaction.changed.size === 0 && transaction.changedParentTypes.size === 0) return;
+      this.remoteDirty = true;
+      this.remoteOrigin = transaction.origin;
+      if (this.remoteDelayMs <= 0) this.flushRemote();
+      else if (this.remoteTimer === void 0) {
+        this.remoteTimer = setTimeout(() => this.flushRemote(), this.remoteDelayMs);
+      }
+    };
+    this.doc.on("afterTransaction", onAfterTransaction);
+    this.disposers.push(() => this.doc.off("afterTransaction", onAfterTransaction));
+    this.disposers.push(() => clearTimeout(this.remoteTimer));
+  }
+  get hasFailed() {
+    return this.failed;
+  }
+  /** Mirror any journal still queued locally. Call before integrating inbound updates. */
+  beforeRemote() {
+    this.port.flushPendingJournals();
+  }
+  /** Publish any waiting remote change now. Call before a local operation runs. */
+  flushRemote() {
+    clearTimeout(this.remoteTimer);
+    this.remoteTimer = void 0;
+    if (!this.remoteDirty || this.failed) return;
+    this.remoteDirty = false;
+    this.publishRemote(this.remoteOrigin);
+  }
+  /** Make the local tree equal to the room: used when the editor opened an older snapshot of it. */
+  adopt() {
+    this.remoteDirty = false;
+    this.publishRemote(void 0);
+  }
+  /** Re-register node ids for parts a remote publication replaced; deferred until a local edit needs them. */
+  refreshRegistry() {
+    if (this.staleParts === null) return;
+    registerMirror(this.doc, this.registry, this.staleParts === true ? void 0 : this.staleParts);
+    this.staleParts = null;
+  }
+  publishRemote(origin) {
+    this.applyingRemote = true;
+    const changed = this.cache.take();
+    try {
+      const result = this.port.applyRemotePackage(materialize(this.doc, this.cache, changed), {
+        origin: "dev.docx-editor.collaboration.remote",
+        actorId: typeof origin === "string" ? origin : this.actorId,
+        operationId: `${this.actorId}:remote:${this.operation++}`
+      });
+      if (!result.ok) throw new JournalError(result.reason);
+      if (changed === null || this.staleParts === true) this.staleParts = true;
+      else this.staleParts = /* @__PURE__ */ new Set([...this.staleParts ?? [], ...changed]);
+    } catch (error) {
+      this.cache.restore(changed);
+      this.fail(error instanceof MaterializeError ? "materialize" : "apply", error);
+    } finally {
+      this.applyingRemote = false;
+    }
+  }
+  fail(code, error) {
+    if (this.failed) return;
+    this.failed = true;
+    const detail = error instanceof JournalError || error instanceof RegistryError || error instanceof MaterializeError ? error.message : error instanceof Error ? error.message : String(error);
+    this.onFailure?.(code, detail);
+  }
+  destroy() {
+    for (const dispose of this.disposers.splice(0)) dispose();
+  }
+};
+
+// src/session.ts
+var MAX_TEXT = 128;
+var NEVER = 1e3 * 60 * 60 * 24 * 365;
+var CollaborationSessionError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message ?? code);
+    this.name = "CollaborationSessionError";
+    this.code = code;
+  }
+};
+function validateIdentity(identity) {
+  const bad = (value) => typeof value !== "string" || value.length === 0 || value.length > MAX_TEXT;
+  if (bad(identity.actorId) || bad(identity.name)) {
+    throw new CollaborationSessionError("invalid-identity");
+  }
+  if (identity.color !== void 0 && collaboration.safeParticipantColor(identity.color) === void 0) {
+    throw new CollaborationSessionError("invalid-identity-color");
+  }
+  return identity;
+}
+function readIdentity(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const { actorId, name, color, role } = value;
+  if (typeof actorId !== "string" || actorId.length === 0 || actorId.length > MAX_TEXT)
+    return void 0;
+  if (typeof name !== "string" || name.length === 0 || name.length > MAX_TEXT) return void 0;
+  return {
+    actorId,
+    name,
+    ...typeof color === "string" && collaboration.safeParticipantColor(color) ? { color } : {},
+    ...role === "human" || role === "agent" ? { role } : {}
+  };
+}
+var DocxCollaborationSession = class {
+  documentId;
+  sessionId;
+  identity;
+  doc;
+  awareness;
+  offlineEditing;
+  remoteDelayMs;
+  tracker = collaboration.createCollaborationStatusTracker("initializing");
+  statusListeners = /* @__PURE__ */ new Set();
+  participantListeners = /* @__PURE__ */ new Set();
+  selectionListeners = /* @__PURE__ */ new Set();
+  undoManager;
+  sync;
+  port;
+  lastGroup;
+  participantsCache = [];
+  selectionsCache = [];
+  selectionsKey = "[]";
+  baselineVector;
+  disposers = [];
+  constructor(options) {
+    this.documentId = options.documentId;
+    this.identity = validateIdentity(options.identity);
+    this.sessionId = `${options.identity.actorId}:${randomToken()}`;
+    this.doc = options.doc;
+    this.awareness = options.awareness;
+    this.offlineEditing = options.offlineEditing ?? false;
+    this.remoteDelayMs = options.remoteDelayMs;
+    this.undoManager = new Y3__namespace.UndoManager(
+      [
+        this.doc.getMap("parts"),
+        this.doc.getMap("rels"),
+        this.doc.getMap("ctOverrides"),
+        this.doc.getMap("binaries")
+      ],
+      { trackedOrigins: /* @__PURE__ */ new Set([LOCAL_ORIGIN]), captureTimeout: NEVER }
+    );
+    this.awareness.setLocalStateField("user", this.identity);
+    const onAwareness = () => {
+      this.refreshParticipants();
+      this.refreshSelections();
+    };
+    this.awareness.on("change", onAwareness);
+    this.disposers.push(() => this.awareness.off("change", onAwareness));
+    this.refreshParticipants();
+  }
+  // ── Status ───────────────────────────────────────────────────────────────
+  status() {
+    return this.tracker.status();
+  }
+  statusSnapshot() {
+    return this.tracker.snapshot();
+  }
+  subscribeStatus(listener) {
+    this.statusListeners.add(listener);
+    return () => this.statusListeners.delete(listener);
+  }
+  setStatus(status, code, detail) {
+    if (this.tracker.status() === "destroyed") return;
+    if (!this.tracker.set(status, code, detail)) return;
+    for (const listener of [...this.statusListeners]) listener(status, code, detail);
+  }
+  /** The room has synced and holds a document this build understands. */
+  markReady() {
+    if (!isBootstrapped(this.doc)) {
+      this.setStatus("error", "not-initialized");
+      return;
+    }
+    if (readFormat(this.doc) !== COLLAB_FORMAT) {
+      this.setStatus("error", "collaboration-format-mismatch", readFormat(this.doc));
+      return;
+    }
+    this.baselineVector = vectorKey(this.doc);
+    this.setStatus("ready");
+  }
+  markDisconnected() {
+    if (this.status() === "ready") this.setStatus("disconnected", "transport-disconnected");
+  }
+  markReconnected() {
+    if (this.status() === "disconnected") this.setStatus("ready");
+  }
+  markFailed(code, detail) {
+    this.setStatus("error", code, detail);
+  }
+  /** True once an editor has attached its document port. */
+  get attached() {
+    return this.port !== void 0;
+  }
+  gateOperations() {
+    this.sync?.flushRemote();
+    switch (this.status()) {
+      case "ready":
+        return this.port ? null : "collaboration-session-not-attached";
+      case "disconnected":
+        return this.offlineEditing && this.port ? null : "collaboration-session-not-ready";
+      case "destroyed":
+        return "collaboration-session-destroyed";
+      default:
+        return "collaboration-session-not-ready";
+    }
+  }
+  // ── Attachment ───────────────────────────────────────────────────────────
+  attach(port) {
+    if (this.port) {
+      this.markFailed("port-already-attached");
+      return () => {
+      };
+    }
+    if (port.documentId !== this.documentId) {
+      this.markFailed("document-id-mismatch");
+      return () => {
+      };
+    }
+    this.port = port;
+    const sync = new MirrorSync({
+      doc: this.doc,
+      port,
+      actorId: this.identity.actorId,
+      remoteDelayMs: this.remoteDelayMs,
+      onFailure: (code, detail) => {
+        this.markFailed(code === "journal" ? "local-mirror-failed" : "remote-apply-failed", detail);
+      },
+      onLocalJournal: (journal) => {
+        const group = replication.historyGroupOfJournal(journal);
+        if (group === void 0 || group !== this.lastGroup) this.undoManager.stopCapturing();
+        this.lastGroup = group;
+      }
+    });
+    this.sync = sync;
+    if (this.baselineVector !== void 0 && this.baselineVector !== vectorKey(this.doc)) {
+      sync.adopt();
+    }
+    const onPortChange = port.subscribe(() => this.refreshSelections());
+    return () => {
+      onPortChange();
+      sync.destroy();
+      if (this.sync === sync) this.sync = void 0;
+      if (this.port === port) this.port = void 0;
+    };
+  }
+  /** Transport hook: call before integrating inbound Yjs data so queued local edits are mirrored first. */
+  beforeRemote() {
+    this.sync?.beforeRemote();
+  }
+  // ── Undo ─────────────────────────────────────────────────────────────────
+  canUndo() {
+    return this.undoManager.undoStack.length > 0;
+  }
+  canRedo() {
+    return this.undoManager.redoStack.length > 0;
+  }
+  undo() {
+    this.flushPendingJournals();
+    if (this.gateOperations() !== null || !this.canUndo()) return false;
+    this.undoManager.stopCapturing();
+    this.undoManager.undo();
+    this.sync?.flushRemote();
+    return true;
+  }
+  redo() {
+    this.flushPendingJournals();
+    if (this.gateOperations() !== null || !this.canRedo()) return false;
+    this.undoManager.stopCapturing();
+    this.undoManager.redo();
+    this.sync?.flushRemote();
+    return true;
+  }
+  // ── Presence ─────────────────────────────────────────────────────────────
+  setLocalSelection(selection) {
+    this.awareness.setLocalStateField("selection", selection);
+  }
+  participants() {
+    return this.participantsCache;
+  }
+  subscribeParticipants(listener) {
+    this.participantListeners.add(listener);
+    return () => this.participantListeners.delete(listener);
+  }
+  remoteSelections() {
+    return this.selectionsCache;
+  }
+  subscribeRemoteSelections(listener) {
+    this.selectionListeners.add(listener);
+    return () => this.selectionListeners.delete(listener);
+  }
+  refreshParticipants() {
+    const byActor = /* @__PURE__ */ new Map();
+    for (const [clientId, state] of this.awareness.getStates()) {
+      const identity = readIdentity(state.user);
+      if (!identity) continue;
+      const isLocal = clientId === this.awareness.clientID;
+      const existing = byActor.get(identity.actorId);
+      byActor.set(identity.actorId, { ...identity, isLocal: isLocal || existing?.isLocal === true });
+    }
+    const next = [...byActor.values()].sort((a, b) => Number(b.isLocal) - Number(a.isLocal));
+    const same2 = next.length === this.participantsCache.length && next.every((p, i) => {
+      const previous = this.participantsCache[i];
+      return p.actorId === previous.actorId && p.name === previous.name && p.color === previous.color && p.isLocal === previous.isLocal;
+    });
+    if (same2) return;
+    this.participantsCache = next;
+    for (const listener of [...this.participantListeners]) listener(next);
+  }
+  refreshSelections() {
+    const port = this.port;
+    const next = [];
+    if (port) {
+      for (const [clientId, state] of this.awareness.getStates()) {
+        if (clientId === this.awareness.clientID) continue;
+        const record = state;
+        const identity = readIdentity(record.user);
+        const selection = record.selection;
+        if (!identity || !selection) continue;
+        const anchor = resolveAddress(port, selection.anchor);
+        const head = resolveAddress(port, selection.head);
+        if (!anchor || !head) continue;
+        next.push({
+          actorId: identity.actorId,
+          name: identity.name,
+          ...identity.color ? { color: identity.color } : {},
+          anchor,
+          head,
+          ...selection.kind ? { kind: selection.kind } : {}
+        });
+      }
+    }
+    const key = JSON.stringify(next);
+    if (key === this.selectionsKey) return;
+    this.selectionsKey = key;
+    this.selectionsCache = next;
+    for (const listener of [...this.selectionListeners]) listener(next);
+  }
+  // ── Lifecycle ────────────────────────────────────────────────────────────
+  flushPendingJournals() {
+    this.port?.flushPendingJournals();
+  }
+  destroy() {
+    if (this.status() === "destroyed") return;
+    this.flushPendingJournals();
+    this.sync?.destroy();
+    this.sync = void 0;
+    this.port = void 0;
+    this.undoManager.destroy();
+    this.awareness.setLocalState(null);
+    for (const dispose of this.disposers.splice(0)) dispose();
+    this.setStatus("destroyed");
+    this.statusListeners.clear();
+    this.participantListeners.clear();
+    this.selectionListeners.clear();
+  }
+};
+function resolveAddress(port, address) {
+  if (!address || typeof address.paragraphId !== "string" || !Number.isInteger(address.offset)) {
+    return void 0;
+  }
+  const paragraph = port.paragraphByStableId(address.paragraphId);
+  if (!paragraph) return void 0;
+  return {
+    paragraphId: paragraph.paragraphId,
+    nodeId: paragraph.nodeId,
+    offset: Math.max(0, Math.min(address.offset, paragraph.text.length))
+  };
+}
+function vectorKey(doc) {
+  return Array.from(Y3__namespace.encodeStateVector(doc)).join(",");
+}
+function randomToken() {
+  if (typeof crypto.randomUUID === "function") return crypto.randomUUID();
+  const bytes = crypto.getRandomValues(new Uint8Array(16));
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+// src/hocuspocus.ts
+var DEFAULT_SYNC_TIMEOUT_MS = 2e4;
+var CollaborationJoinError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "CollaborationJoinError";
+    this.code = code;
+  }
+};
+async function createHocuspocusCollaboration(options) {
+  const ydoc = new Y3__namespace.Doc();
+  const awareness$1 = new awareness.Awareness(ydoc);
+  const session = new DocxCollaborationSession({
+    doc: ydoc,
+    awareness: awareness$1,
+    documentId: options.roomId,
+    identity: options.identity,
+    offlineEditing: options.offlineEditing
+  });
+  let firstSync;
+  const joined = new Promise((resolve, reject) => {
+    firstSync = { resolve, reject };
+  });
+  let hasSynced = false;
+  const provider$1 = new provider.HocuspocusProvider({
+    url: options.url,
+    name: options.roomId,
+    document: ydoc,
+    awareness: awareness$1,
+    token: options.token,
+    // Runs before inbound data is applied, so queued local edits reach the room first.
+    onMessage: () => session.beforeRemote(),
+    onSynced: ({ state }) => {
+      if (!state) return;
+      if (!hasSynced) {
+        hasSynced = true;
+        firstSync?.resolve();
+      } else {
+        session.markReconnected();
+      }
+    },
+    onDisconnect: () => session.markDisconnected(),
+    onClose: () => session.markDisconnected(),
+    onAuthenticationFailed: ({ reason }) => {
+      session.markFailed("authentication-failed", reason);
+      firstSync?.reject(new CollaborationJoinError("authentication-failed", reason));
+    }
+  });
+  const timeout = setTimeout(() => {
+    firstSync?.reject(
+      new CollaborationJoinError("initialization-timeout", "Could not join the document in time.")
+    );
+  }, options.syncTimeoutMs ?? DEFAULT_SYNC_TIMEOUT_MS);
+  const destroy = () => {
+    clearTimeout(timeout);
+    session.destroy();
+    provider$1.destroy();
+    ydoc.destroy();
+  };
+  try {
+    await joined;
+    session.markReady();
+    if (session.status() === "error") {
+      throw new CollaborationJoinError(
+        "initialization-aborted",
+        session.statusSnapshot().reason?.code ?? "The document could not be opened."
+      );
+    }
+    const document = materializeBytes(ydoc);
+    return { ydoc, provider: provider$1, session, document, destroy };
+  } catch (error) {
+    destroy();
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+exports.CollaborationJoinError = CollaborationJoinError;
+exports.createHocuspocusCollaboration = createHocuspocusCollaboration;
+//# sourceMappingURL=hocuspocus.cjs.map
+//# sourceMappingURL=hocuspocus.cjs.map