@arbidocs/coedit 0.5.21 → 0.5.23

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var Y3 = require('yjs');
+var Y = require('yjs');
 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');
@@ -23,7 +23,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var Y3__namespace = /*#__PURE__*/_interopNamespace(Y3);
+var Y__namespace = /*#__PURE__*/_interopNamespace(Y);
 
 // src/encoding.ts
 
@@ -336,6 +336,92 @@ function writeUnits(text, units) {
 function isRichParagraph(map) {
   return map.has("inline");
 }
+var PACKED = "xml";
+function isPackedElement(map) {
+  return map.has(PACKED);
+}
+function isCompact(map) {
+  return isRichParagraph(map) || isPackedElement(map);
+}
+var TEXT_BEARING = /* @__PURE__ */ new Set(["p", "t", "delText", "instrText", "delInstrText"]);
+function packable(xml) {
+  if (xml.ns === WML && TEXT_BEARING.has(xml.local)) return false;
+  return xml.children.every((c) => typeof c === "string" || packable(c));
+}
+function createPacked(xml, scope) {
+  const map = new Y__namespace.Map();
+  map.set(PACKED, serializeXml(xml, scope));
+  return map;
+}
+function repack(map, xml) {
+  const next = serializeXml(xml, scopeOf(map));
+  if (map.get(PACKED) !== next) map.set(PACKED, next);
+}
+function scopeOf(node) {
+  const chain = [];
+  let parent = node.parent;
+  while (parent instanceof Y__namespace.Array) {
+    const owner = parent.parent;
+    if (!(owner instanceof Y__namespace.Map)) break;
+    chain.push(owner);
+    parent = owner.parent;
+  }
+  const scope = /* @__PURE__ */ new Map();
+  for (const el of chain.reverse()) {
+    for (const b of el.get("bindings").toArray()) scope.set(b.prefix, b.ns);
+  }
+  return scope;
+}
+function scopeWithin(el) {
+  const scope = scopeOf(el);
+  if (!isPackedElement(el)) {
+    for (const b of el.get("bindings").toArray()) scope.set(b.prefix, b.ns);
+  }
+  return scope;
+}
+var unpackLimits = { maxBytes: 64 * 1024 * 1024, maxElements: 2e6 };
+function unpack(text, scope) {
+  const read = store.readXml(text, unpackLimits);
+  if (!read.ok) throw new Error(`collab: a packed element is not readable XML (${read.reason})`);
+  const convert = (node, outer) => {
+    const bindings = [];
+    const named = [];
+    for (const [name, value] of Object.entries(node.attributes)) {
+      if (name === "xmlns") bindings.push({ prefix: "", ns: value });
+      else if (name.startsWith("xmlns:")) bindings.push({ prefix: name.slice(6), ns: value });
+      else named.push([name, value]);
+    }
+    const inner = new Map(outer);
+    for (const b of bindings) inner.set(b.prefix, b.ns);
+    const resolve = (prefix) => {
+      if (prefix === "xml") return store.XML_NAMESPACE_URI;
+      const ns = inner.get(prefix);
+      if (ns === void 0)
+        throw new Error(`collab: prefix ${prefix} is not bound in a packed element`);
+      return ns;
+    };
+    const colon = node.name.indexOf(":");
+    const xml = {
+      ns: colon < 0 ? inner.get("") ?? "" : resolve(node.name.slice(0, colon)),
+      local: colon < 0 ? node.name : node.name.slice(colon + 1),
+      attrs: named.map(([name, value]) => {
+        const at = name.indexOf(":");
+        if (at < 0) return { ns: "", local: name, value };
+        const prefix = name.slice(0, at);
+        return { ns: resolve(prefix), local: name.slice(at + 1), prefix, value };
+      }),
+      bindings,
+      children: node.children.map(
+        (child) => child.type === "text" ? child.value : convert(child, inner)
+      )
+    };
+    if (colon >= 0) xml.prefix = node.name.slice(0, colon);
+    return xml;
+  };
+  const root = read.nodes.find((n) => n.type === "element");
+  if (!root || root.type !== "element") throw new Error("collab: a packed element is empty");
+  return convert(root, scope);
+}
 function isParagraphEl(el) {
   return el.ns === WML && el.local === "p";
 }
@@ -343,47 +429,53 @@ 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();
+  const attrs = new Y__namespace.Array();
   attrs.push(xml.attrs.map((a) => ({ ...a })));
   map.set("attrs", attrs);
-  const bindings = new Y3__namespace.Array();
+  const bindings = new Y__namespace.Array();
   bindings.push(xml.bindings.map((b) => ({ ...b })));
   map.set("bindings", bindings);
 }
 function newText(value) {
-  const text = new Y3__namespace.Text();
+  const text = new Y__namespace.Text();
   text.insert(0, value);
   return text;
 }
-function createRichParagraph(xml, encoded) {
-  const map = new Y3__namespace.Map();
+function createRichParagraph(xml, encoded, scope = /* @__PURE__ */ new Map()) {
+  const map = new Y__namespace.Map();
   fieldsOf(map, xml);
-  const children = new Y3__namespace.Array();
-  children.push(encoded.head.map((el) => xmlToLive(el)));
+  const inner = withBindings(scope, xml.bindings);
+  const children = new Y__namespace.Array();
+  children.push(encoded.head.map((el) => xmlToLive(el, inner)));
   map.set("children", children);
-  const inline = new Y3__namespace.Text();
+  const inline = new Y__namespace.Text();
   writeUnits(inline, encoded.units);
   map.set("inline", inline);
   return map;
 }
-function xmlToLive(xml) {
+function withBindings(scope, bindings) {
+  const inner = new Map(scope);
+  for (const b of bindings) inner.set(b.prefix, b.ns);
+  return inner;
+}
+function xmlToLive(xml, scope = /* @__PURE__ */ new Map(), root = false) {
   if (isParagraphEl(xml)) {
     const encoded = encodeParagraph(xml.children);
-    if (encoded) return createRichParagraph(xml, encoded);
+    if (encoded) return createRichParagraph(xml, encoded, scope);
   }
-  return xmlToGenericLive(xml);
-}
-function xmlToGenericLive(xml) {
-  const map = new Y3__namespace.Map();
+  if (!root && packable(xml)) return createPacked(xml, scope);
+  const map = new Y__namespace.Map();
   fieldsOf(map, xml);
-  const children = new Y3__namespace.Array();
-  children.push(xml.children.map((c) => typeof c === "string" ? newText(c) : xmlToLive(c)));
+  const inner = withBindings(scope, xml.bindings);
+  const children = new Y__namespace.Array();
+  children.push(xml.children.map((c) => typeof c === "string" ? newText(c) : xmlToLive(c, inner)));
   map.set("children", children);
   return map;
 }
 function liveToXml(map) {
+  if (isPackedElement(map)) return unpack(map.get(PACKED), scopeOf(map));
   const prefix = map.get("prefix");
-  const stored = map.get("children").toArray().map((child) => child instanceof Y3__namespace.Text ? child.toString() : liveToXml(child));
+  const stored = map.get("children").toArray().map((child) => child instanceof Y__namespace.Text ? child.toString() : liveToXml(child));
   const children = isRichParagraph(map) ? [...stored, ...decodeInline(readUnits(map.get("inline")))] : stored;
   const xml = {
     ns: map.get("ns"),
@@ -398,14 +490,13 @@ function liveToXml(map) {
 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) {
+function startTag(prefix, local, bindings, attrs, scope) {
+  const inScope = withBindings(scope, bindings);
+  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 el.attrs) {
+  for (const a of attrs) {
     let p = a.prefix;
     if (a.ns !== "" && !p) {
       for (const [candidate, uri] of inScope) {
@@ -417,48 +508,41 @@ function serializeXml(el, scope) {
     }
     out += ` ${qualified(p, a.local)}="${escapeAttr(a.value)}"`;
   }
+  return [out, inScope];
+}
+function serializeXml(el, scope) {
+  const [out, inScope] = startTag(el.prefix, el.local, el.bindings, el.attrs, scope);
   if (el.children.length === 0) return `${out}/>`;
-  out += ">";
+  let body = "";
   for (const child of el.children) {
-    out += typeof child === "string" ? escapeText(child) : serializeXml(child, inScope);
+    body += typeof child === "string" ? escapeText(child) : serializeXml(child, inScope);
   }
-  return `${out}</${qualified(el.prefix, el.local)}>`;
+  return `${out}>${body}</${qualified(el.prefix, el.local)}>`;
 }
 function serializeLive(el, scope) {
-  if (isRichParagraph(el)) return serializeXml(liveToXml(el), scope);
+  if (isPackedElement(el)) return el.get(PACKED);
   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 += ">";
+  const [out, inScope] = startTag(prefix, local, bindings, attrs, scope);
+  const inline = isRichParagraph(el) ? decodeInline(readUnits(el.get("inline"))) : [];
+  if (children.length === 0 && inline.length === 0) return `${out}/>`;
+  let body = "";
   for (const child of children) {
-    out += child instanceof Y3__namespace.Text ? escapeText(child.toString()) : serializeLive(child, inScope);
+    body += child instanceof Y__namespace.Text ? escapeText(child.toString()) : serializeLive(child, inScope);
   }
-  return `${out}</${qualified(prefix, local)}>`;
+  for (const child of inline) body += serializeXml(child, inScope);
+  return `${out}>${body}</${qualified(prefix, local)}>`;
 }
 
 // src/encoding.ts
-var COLLAB_FORMAT = "arbi-docx/1";
+var COLLAB_FORMAT = "arbi-docx/2";
+var READABLE_FORMATS = /* @__PURE__ */ new Set(["arbi-docx/1", COLLAB_FORMAT]);
+function isReadableFormat(format) {
+  return format !== void 0 && READABLE_FORMATS.has(format);
+}
 function isBootstrapped(doc) {
   return doc.getMap("meta").get("format") !== void 0;
 }
@@ -752,7 +836,7 @@ var NodeRegistry = class {
   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)) {
+    if ("live" in entry && entry.live instanceof Y__namespace.Map && isCompact(entry.live)) {
       this.openParagraph(entry.live);
       entry = this.entries.get(id);
     }
@@ -770,7 +854,7 @@ var NodeRegistry = class {
     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)) {
+      if ("live" in ancestor && ancestor.live instanceof Y__namespace.Map && isCompact(ancestor.live)) {
         this.openParagraph(ancestor.live);
         return this.entries.get(id);
       }
@@ -802,13 +886,13 @@ var NodeRegistry = class {
   /**
    * 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.
+   * paragraph or a packed element 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;
+      if (node instanceof Y__namespace.Text) return;
+      if (isCompact(node)) return;
       childrenOf(node).forEach((child, index) => walk(child, `${id}.${index}`));
     };
     walk(root, `${partName}#0`);
@@ -865,7 +949,7 @@ var NodeRegistry = class {
     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. */
+  /** Write every changed open paragraph or packed element back into the mirror. Call at the end of a journal. */
   flushRich() {
     for (const live of [...this.dirty]) {
       this.dirty.delete(live);
@@ -876,6 +960,11 @@ var NodeRegistry = class {
   writeBack(record) {
     const { live, root } = record;
     const xml = plainToXml(root);
+    if (isPackedElement(live)) {
+      if (packable(xml)) repack(live, xml);
+      else this.degrade(record);
+      return;
+    }
     const encoded = encodeParagraph(xml.children);
     if (!encoded) {
       this.degrade(record);
@@ -892,21 +981,22 @@ var NodeRegistry = class {
       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)) {
+    const scope = scopeWithin(live);
+    const stored = head.toArray().map((child) => serializeLive(child, scope)).join("");
+    if (stored !== encoded.head.map((el) => serializeXml(el, scope)).join("")) {
       head.delete(0, head.length);
-      head.push(encoded.head.map((el) => xmlToLive(el)));
+      head.push(encoded.head.map((el) => xmlToLive(el, scope)));
     }
     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. */
+  /** The paragraph can no longer be held as rich text, or the element packed: store it as a tree. */
   degrade(record) {
     const parent = record.live.parent;
-    if (!(parent instanceof Y3__namespace.Array))
+    if (!(parent instanceof Y__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);
+    const generic = this.toGenericLive(record.root, scopeOf(record.live));
     this.open.delete(record.live);
     parent.delete(index, 1);
     parent.insert(index, [generic]);
@@ -921,8 +1011,8 @@ var NodeRegistry = class {
   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)) {
+    if (node instanceof Y__namespace.Text) return { type: "text", id, value: node.toString() };
+    if (isCompact(node)) {
       return this.open.get(node)?.root ?? xmlToPlain(liveToXml(node), id);
     }
     const prefix = node.get("prefix");
@@ -950,8 +1040,8 @@ var NodeRegistry = class {
     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)) {
+    if (node instanceof Y__namespace.Text || plain.type === "text") return;
+    if (isCompact(node)) {
       this.open.delete(node);
       this.dirty.delete(node);
       return;
@@ -959,53 +1049,61 @@ var NodeRegistry = class {
     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) {
+  /**
+   * Build Yjs types for a plain subtree placed where `scope` is in force, and register every node as
+   * live. A rich paragraph or packed element stays open on the plain tree, which is already current.
+   * A part's `root` is never packed.
+   */
+  toLive(plain, scope = /* @__PURE__ */ new Map(), root = false) {
     if (plain.type === "text") {
-      const text = new Y3__namespace.Text();
+      const text = new Y__namespace.Text();
       text.insert(0, plain.value);
       this.registerLive(plain.id, text);
       return text;
     }
+    const xml = plainToXml(plain);
+    let map;
     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;
-      }
+      if (encoded) map = createRichParagraph(xml, encoded, scope);
+    }
+    if (!map && !root && packable(xml)) map = xmlToLive(xml, scope);
+    if (map) {
+      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);
+    return this.toGenericLive(plain, scope);
   }
-  toGenericLive(plain) {
+  toGenericLive(plain, scope) {
     const map = xmlToGenericShell(plain);
-    const children = new Y3__namespace.Array();
-    children.push(plain.children.map((child) => this.toLive(child)));
+    const inner = withBindings(scope, plain.bindings);
+    const children = new Y__namespace.Array();
+    children.push(plain.children.map((child) => this.toLive(child, inner)));
     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.
+   * A live node that can be inserted into a parent (`scope` is in force there), or a part's `root`.
+   * 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));
+  attachable(id, scope = /* @__PURE__ */ new Map(), root = false) {
+    return this.toLive(this.snapshot(id), scope, root);
   }
 };
 function xmlToGenericShell(plain) {
-  const map = new Y3__namespace.Map();
+  const map = new Y__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();
+  const attrs = new Y__namespace.Array();
   attrs.push(plain.attrs.map((a) => ({ ...a })));
   map.set("attrs", attrs);
-  const bindings = new Y3__namespace.Array();
+  const bindings = new Y__namespace.Array();
   bindings.push(plain.bindings.map((b) => ({ ...b })));
   map.set("bindings", bindings);
   return map;
@@ -1070,7 +1168,7 @@ function setNamespaceBinding(registry, id, prefix, uri) {
   }
 }
 function asLiveElement(node, id) {
-  if (node instanceof Y3__namespace.Text) throw new JournalError(`${id} is a text node, not an element`);
+  if (node instanceof Y__namespace.Text) throw new JournalError(`${id} is a text node, not an element`);
   return node;
 }
 function asPlainElement(node, id) {
@@ -1086,7 +1184,7 @@ function spliceText(registry, id, start, deleteCount, insert) {
     return;
   }
   const text = entry.live;
-  if (!(text instanceof Y3__namespace.Text)) throw new JournalError(`${id} is not a text node`);
+  if (!(text instanceof Y__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}`);
   }
@@ -1099,27 +1197,29 @@ function detachRemoved(registry, parent, start, count) {
 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) {
+    const parent2 = asPlainElement(parentEntry.plain, parentId);
+    if (start < 0 || start + deleteCount > parent2.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);
+    parent2.children.splice(start, deleteCount, ...inserted2);
+    registry.adopt(parent2, inserted2);
     return;
   }
-  const children = childrenOf(asLiveElement(parentEntry.live, parentId));
+  const parent = asLiveElement(parentEntry.live, parentId);
+  const children = childrenOf(parent);
   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));
+  const scope = scopeWithin(parent);
+  const inserted = childIds.map((id) => registry.attachable(id, scope));
   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`);
+  if (!(children instanceof Y__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 };
@@ -1146,8 +1246,10 @@ function moveNode(registry, id, destinationId, destinationIndex) {
     registry.adopt(destination2, [copy]);
     return;
   }
-  const destination = childrenOf(asLiveElement(destinationEntry.live, destinationId));
-  destination.insert(destinationIndex, [registry.toLive(copy)]);
+  const destination = asLiveElement(destinationEntry.live, destinationId);
+  childrenOf(destination).insert(destinationIndex, [
+    registry.toLive(copy, scopeWithin(destination))
+  ]);
 }
 function renameNode(registry, id, qname) {
   const entry = registry.require(id);
@@ -1162,7 +1264,7 @@ function renameNode(registry, id, qname) {
     return true;
   }
   const live = entry.live;
-  if (live instanceof Y3__namespace.Text || isRichParagraph(live)) return false;
+  if (live instanceof Y__namespace.Text || isCompact(live)) return false;
   if (live.get("ns") !== qname.namespaceUri) live.set("ns", qname.namespaceUri);
   if (live.get("local") !== qname.localName) live.set("local", qname.localName);
   if (qname.prefix === void 0) {
@@ -1192,7 +1294,7 @@ function putNode(registry, effect) {
 }
 function rootFor(registry, id) {
   const entry = registry.require(id);
-  const live = "live" in entry && entry.live.parent === null ? entry.live : registry.attachable(id);
+  const live = "live" in entry && entry.live.parent === null ? entry.live : registry.attachable(id, /* @__PURE__ */ new Map(), true);
   return asLiveElement(live, id);
 }
 function applyEffect(doc, registry, effect, context) {
@@ -1236,7 +1338,7 @@ function applyEffect(doc, registry, effect, context) {
       const rels = doc.getMap("rels");
       let byId = rels.get(effect.owner);
       if (!byId) {
-        byId = new Y3__namespace.Map();
+        byId = new Y__namespace.Map();
         rels.set(effect.owner, byId);
       }
       byId.set(effect.record.id, { ...effect.record });
@@ -1441,7 +1543,7 @@ var DocxCollaborationSession = class {
     this.doc = options.doc;
     this.awareness = options.awareness;
     this.offlineEditing = options.offlineEditing ?? false;
-    this.undoManager = new Y3__namespace.UndoManager(
+    this.undoManager = new Y__namespace.UndoManager(
       [
         this.doc.getMap("parts"),
         this.doc.getMap("rels"),
@@ -1481,7 +1583,7 @@ var DocxCollaborationSession = class {
       this.setStatus("error", "not-initialized");
       return;
     }
-    if (readFormat(this.doc) !== COLLAB_FORMAT) {
+    if (!isReadableFormat(readFormat(this.doc))) {
       this.setStatus("error", "collaboration-format-mismatch", readFormat(this.doc));
       return;
     }
@@ -1755,7 +1857,7 @@ function resolveAddress(port, address) {
   };
 }
 function vectorKey(doc) {
-  return Array.from(Y3__namespace.encodeStateVector(doc)).join(",");
+  return Array.from(Y__namespace.encodeStateVector(doc)).join(",");
 }
 function randomToken() {
   if (typeof crypto.randomUUID === "function") return crypto.randomUUID();