quoin-editor 1.0.0 → 1.0.2

package/dist/yjs.js

@@ -1,172 +1,66 @@
 import {
+  applyRemote,
+  attrsMap,
   cleanEntry,
   createLayout,
+  definedEntries,
+  deleteText,
   emptySpan,
   grow,
   holdBinding,
   holdSelection,
   indexOf,
+  inlineOfOps,
+  insertInline,
+  isAtomEmbed,
+  markAttribute,
+  markerOf,
   offsetIn,
   piecesOf,
   placeEntries,
   pointOf,
+  readMarker,
+  regionNameOf,
   regionOf,
+  regionStart,
   restoreSelection,
+  sharedChange,
   spanAt,
   spanStart,
-  textLength
-} from "./chunk-TC4DARU2.js";
+  textLength,
+  textSteps,
+  writeBlock,
+  writeBlocks
+} from "./chunk-6NULZPVC.js";
 import {
-  HISTORY_GROUP,
   HISTORY_PROVIDER,
-  addMarkStep,
   createPluginKey,
   defineExtension,
   getPluginState,
+  groupOf,
   joinBlocksStep,
-  removeMarkStep,
   replaceBlockStep,
   replaceDocStep,
-  replaceInlineStep,
   sameDoc,
-  sameSelection,
   setAttrsStep,
   setIndentStep,
-  splitBlockStep,
-  validateSelection
-} from "./chunk-HJIQT3S5.js";
+  splitBlockStep
+} from "./chunk-OBMBSU2S.js";
 import {
   sameValue
-} from "./chunk-NOKWNK2O.js";
+} from "./chunk-RJRX34BZ.js";
 import {
-  atom,
   blockById,
   createDoc,
   equalInline,
   equalNode,
   inlineLength,
-  markKey,
-  nodeLength,
-  normalizeInline,
   sliceInline,
   text
-} from "./chunk-LCQSG4M6.js";
-
-// src/engine/collab/apply-remote.ts
-function applyRemote(editor, steps, selectionHint) {
-  const tr = editor.createTransaction().setOrigin("remote").setMeta("addToHistory", false);
-  for (const step of steps) tr.step(step);
-  if (selectionHint && sameSelection(validateSelection(tr.doc, editor.schema, selectionHint), selectionHint)) {
-    tr.setSelection(selectionHint);
-  }
-  editor.dispatch(tr);
-}
-
-// src/yjs/local-to-yjs.ts
-import * as Y4 from "yjs";
-
-// src/yjs/doc-shape.ts
-import * as Y from "yjs";
-
-// src/yjs/marks-codec.ts
-var ESCAPE = "$";
-var escapeKey = (key) => key in Object.prototype || key.startsWith(ESCAPE) ? ESCAPE + key : key;
-var unescapeKey = (key) => key.startsWith(ESCAPE) ? key.slice(1) : key;
-var onlyString = (attrs, key) => Object.keys(attrs).length === 1 && Object.hasOwn(attrs, key) && typeof attrs[key] === "string";
-function markAttribute(mark) {
-  const key = markKey(mark);
-  const { attrs } = mark;
-  const stacked = key !== mark.type;
-  if (attrs === void 0) return [escapeKey(key), !stacked];
-  if (stacked && onlyString(attrs, "id")) return [escapeKey(key), true];
-  if (onlyString(attrs, mark.type)) return [escapeKey(key), attrs[mark.type]];
-  return [escapeKey(key), attrs];
-}
-function stackedType(key) {
-  const colon = key.indexOf(":");
-  if (colon < 1) return null;
-  const type = key.slice(0, colon);
-  const id = key.slice(colon + 1);
-  return markKey({ type, attrs: { id } }) === key ? [type, id] : null;
-}
-function markFromAttribute(attribute, value) {
-  const key = unescapeKey(attribute);
-  const stacked = stackedType(key);
-  const type = stacked?.[0] ?? key;
-  if (value === true) return stacked === null ? { type } : { type, attrs: { id: stacked[1] } };
-  if (value === false) return { type };
-  if (typeof value === "string") return { type, attrs: { [type]: value } };
-  return { type, attrs: value };
-}
-var marksToAttributes = (marks) => Object.fromEntries(marks.map(markAttribute));
-var attributesToMarks = (attributes = {}) => Object.entries(attributes).map(([key, value]) => markFromAttribute(key, value));
-
-// src/yjs/inline-codec.ts
-var inlineOps = (inline) => inline.map((node) => ({
-  insert: node.kind === "text" ? node.text : { atom: node.type, attrs: node.attrs },
-  attributes: marksToAttributes(node.marks)
-}));
-function insertInline(target, at, inline) {
-  let offset = at;
-  for (const node of inline) {
-    const attributes = marksToAttributes(node.marks);
-    if (node.kind === "text") target.insert(offset, node.text, attributes);
-    else target.insertEmbed(offset, { atom: node.type, attrs: node.attrs }, attributes);
-    offset += nodeLength(node);
-  }
-}
-function nodeOf({ insert, attributes }) {
-  const marks = attributesToMarks(attributes);
-  return typeof insert === "string" ? text(insert, marks) : atom(insert.atom, insert.attrs, marks);
-}
-var inlineOfOps = (ops) => normalizeInline(ops.map(nodeOf));
-
-// src/yjs/doc-shape.ts
-var deleteText = (text2, at, length) => text2.applyDelta(at > 0 ? [{ retain: at }, { delete: length }] : [{ delete: length }]);
-var regionStart = (name) => ({ r: name });
-var isPlainObject = (value) => typeof value === "object" && value !== null && !(value instanceof Y.AbstractType);
-var regionNameOf = (embed) => isPlainObject(embed) && typeof embed.r === "string" && embed.atom === void 0 ? embed.r : null;
-var isAtomEmbed = (embed) => isPlainObject(embed) && typeof embed.atom === "string" && isPlainObject(embed.attrs);
-var definedEntries = (attrs) => Object.entries(attrs).filter(([, value]) => value !== void 0);
-function markerOf(block) {
-  return new Y.Map([
-    ["id", block.id],
-    ["type", block.type],
-    ["indent", block.indent],
-    ["attrs", new Y.Map(definedEntries(block.attrs))]
-  ]);
-}
-function readMarker(map) {
-  const [id, type, indent, attrs] = ["id", "type", "indent", "attrs"].map((key) => map.get(key));
-  if (typeof id !== "string") return null;
-  return {
-    id,
-    type: typeof type === "string" ? type : "",
-    indent: typeof indent === "number" ? indent : 0,
-    attrs: attrs instanceof Y.Map ? attrs : null
-  };
-}
-function blockOps(block, map, open) {
-  const ops = [{ insert: map, attributes: {} }];
-  for (const [name, inline] of Object.entries(block.regions)) {
-    ops.push({ insert: regionStart(name), attributes: {} });
-    if (name === open) break;
-    ops.push(...inlineOps(inline));
-  }
-  return ops;
-}
-var writeOps = (text2, at, ops) => text2.applyDelta(at > 0 ? [{ retain: at }, ...ops] : ops);
-function writeBlock(text2, at, block, map, open) {
-  writeOps(text2, at, blockOps(block, map, open));
-}
-function writeBlocks(text2, at, blocks) {
-  const maps = blocks.map(markerOf);
-  writeOps(text2, at, blocks.flatMap((block, i) => blockOps(block, maps[i])));
-  return maps;
-}
+} from "./chunk-4XFXB37X.js";
 
 // src/yjs/read-shared.ts
-import * as Y2 from "yjs";
+import * as Y from "yjs";
 
 // src/yjs/required-regions.ts
 var noRequiredRegions = () => [];
@@ -195,7 +89,6 @@ function reader(required) {
   let entry = null;
   let open = null;
   let stray = null;
-  let clean = true;
   const segFor = (region2, host, at, ops = []) => {
     const seg = { host, region: region2, at, length: 0 };
     host.segs.push(seg);
@@ -212,7 +105,6 @@ function reader(required) {
       open.length += length;
       held2.get(open).push(op);
     } else if (span.index === 0 || span.entry !== null) {
-      clean = false;
       if (stray === null) {
         stray = { host: span, at: span.length, length: 0, ops: [], after: order[order.length - 1] ?? null };
         strays.push(stray);
@@ -233,25 +125,26 @@ function reader(required) {
       span.entry = entry;
       entries.set(entry.id, entry);
       markers.set(entry, fields);
-    } else {
-      clean = false;
-      if (fields !== null) {
-        span.copyOf = entries.get(fields.id);
-        span.copyOf.copies.push(span);
-      }
+    } else if (fields !== null) {
+      span.copyOf = entries.get(fields.id);
+      span.copyOf.copies.push(span);
     }
   }
   function embed(value) {
-    const name = regionNameOf(value);
+    let name = regionNameOf(value);
     stray = null;
-    if (name !== null && entry !== null && !entry.regions.some((region2) => region2.name === name)) {
-      const region2 = { name, entry, segs: [] };
-      entry.regions.push(region2);
-      order.push(region2);
-      open = opened(region2);
-      return;
+    const missing = (one) => !entry.regions.some((region2) => region2.name === one);
+    if (name !== null && entry !== null) {
+      const needed = required(markers.get(entry).type);
+      if (needed.length > 0 && !needed.includes(name)) name = needed.find(missing) ?? null;
+      if (name !== null && missing(name)) {
+        const region2 = { name, entry, segs: [] };
+        entry.regions.push(region2);
+        order.push(region2);
+        open = opened(region2);
+        return;
+      }
     }
-    clean = false;
     if (open !== null) open = opened(open.region);
   }
   return {
@@ -263,7 +156,7 @@ function reader(required) {
         span.length += length;
         return;
       }
-      if (insert instanceof Y2.Map) marker(insert);
+      if (insert instanceof Y.Map) marker(insert);
       else embed(insert);
       span.length += 1;
     },
@@ -291,16 +184,32 @@ function reader(required) {
         const regions = kept.regions.map(({ name, segs }) => [name, inline(segs)]);
         return { id: kept.id, type, indent, attrs: attrs?.toJSON() ?? {}, regions: Object.fromEntries(regions) };
       });
-      const layout = createLayout(spans, entries, clean, { read, leading: new Set(leading), unread });
+      const layout = createLayout(spans, entries, { read, leading: new Set(leading), unread });
       return { doc: createDoc(blocks), layout };
     }
   };
 }
 function readShared(text2, required = noRequiredRegions) {
   const read = reader(required);
-  for (const op of text2.toDelta()) read.read(op);
+  readItems(text2, () => read, read);
   return read.finish();
 }
+function readItems(text2, readerOf, read) {
+  const attributes = /* @__PURE__ */ new Map();
+  for (let item = text2._start; item !== null; item = item.right) {
+    const { content } = item;
+    if (item.deleted) continue;
+    if (content instanceof Y.ContentFormat) {
+      if (content.value === null) attributes.delete(content.key);
+      else attributes.set(content.key, content.value);
+      continue;
+    }
+    for (const insert of content instanceof Y.ContentString ? [content.str] : content.getContent()) {
+      if (insert instanceof Y.Map) read = readerOf(insert);
+      read?.read({ insert, attributes: Object.fromEntries(attributes) });
+    }
+  }
+}
 
 // src/yjs/shared.ts
 function reread(shared) {
@@ -332,9 +241,6 @@ function openRegion(shared, { name, entry }, inline) {
   reread(shared);
 }
 
-// src/yjs/sync-block.ts
-import * as Y3 from "yjs";
-
 // src/yjs/inline-span.ts
 var units = (inline) => inline.flatMap(
   (node) => node.kind === "text" ? Array.from({ length: node.text.length }, (_, i) => text(node.text[i], node.marks)) : [node]
@@ -360,12 +266,12 @@ function isPlain({ span, regions }) {
   }
   return span.length === end;
 }
-function rewritten(entry, block, map = entry.map) {
-  const next = cleanEntry(block, map);
+function adopted(entry, next) {
   next.copies.push(...entry.copies);
   for (const copy of next.copies) copy.copyOf = next;
   return next;
 }
+var rewritten = (entry, block, map = entry.map) => adopted(entry, cleanEntry(block, map));
 function crossesStray(layout, index) {
   const { read, leading, unread } = layout.strays;
   return unread || read.some((seg) => {
@@ -428,11 +334,8 @@ function removeBlock(shared, id) {
 
 // src/yjs/sync-block.ts
 function syncAttrs(map, before, after) {
-  const current = map.get("attrs");
-  if (!(current instanceof Y3.Map)) {
-    map.set("attrs", new Y3.Map(definedEntries(after)));
-    return;
-  }
+  const current = attrsMap(map, after);
+  if (current === null) return;
   const kept = new Map(definedEntries(after));
   for (const key of [...current.keys()]) if (!kept.has(key)) current.delete(key);
   for (const [key, value] of kept) if (!sameValue(before[key], value)) current.set(key, value);
@@ -451,8 +354,8 @@ function keptNames(before, after) {
 function syncRegions(shared, entry, before, after) {
   const { text: text2, layout } = shared;
   const names = Object.keys(after.regions);
-  const kept = keptNames(Object.keys(before.regions), names);
-  const queue = Object.entries(before.regions);
+  const queue = entry.regions.map(({ name }) => [name, before.regions[name]]);
+  const kept = keptNames(queue.map(([name]) => name), names);
   let at = spanStart(layout, entry.span) + 1;
   const dropGone = () => {
     while (queue.length > 0 && !kept.has(queue[0][0])) deleteText(text2, at, 1 + inlineLength(queue.shift()[1]));
@@ -482,8 +385,7 @@ function syncBlock(shared, before, after, next) {
     insertBlocks(shared, next, [after]);
     return;
   }
-  if (before.type !== after.type) entry.map.set("type", after.type);
-  if (before.indent !== after.indent) entry.map.set("indent", after.indent);
+  for (const key of ["type", "indent"]) if (before[key] !== after[key]) entry.map.set(key, after[key]);
   syncAttrs(entry.map, before.attrs, after.attrs);
   if (plain) {
     const gains = Object.keys(before.regions).length === 0 && Object.keys(after.regions).length > 0;
@@ -593,8 +495,8 @@ function setAttrs({ shared, after, params }) {
   const id = params.block;
   const { map } = shared.layout.entries.get(id);
   const next = blockById(after, id).attrs;
-  const attrs = map.get("attrs");
-  if (!(attrs instanceof Y4.Map)) return void map.set("attrs", new Y4.Map(definedEntries(next)));
+  const attrs = attrsMap(map, next);
+  if (attrs === null) return;
   for (const key of Object.keys(params.patch)) {
     if (next[key] === void 0) attrs.delete(key);
     else attrs.set(key, next[key]);
@@ -643,94 +545,75 @@ function writeLocalSteps(shared, steps, docs) {
   });
 }
 
-// src/yjs/own-change.ts
-function ownChange(editor, steps, hint) {
-  const tr = editor.createTransaction().setOrigin("history").setMeta("addToHistory", false);
-  for (const step of steps) tr.step(step);
-  if (hint && sameSelection(validateSelection(tr.doc, editor.schema, hint), hint)) tr.setSelection(hint);
-  return tr;
-}
-
 // src/yjs/seed.ts
 function seedOrLoad(editor, text2, { origin, seed, required }) {
   const { blocks } = editor.state.doc;
   if (text2.length === 0 && seed === "if-empty") {
     let maps = [];
     text2.doc.transact(() => maps = writeBlocks(text2, 0, blocks), origin);
-    const entries = blocks.map((block, i) => cleanEntry(block, maps[i]));
-    const spans = [emptySpan(), ...entries.map((entry) => entry.span)];
-    return createLayout(spans, new Map(entries.map((entry) => [entry.id, entry])), true);
+    const layout2 = createLayout([emptySpan()], /* @__PURE__ */ new Map());
+    placeEntries(layout2, 1, 0, blocks.map((block, i) => cleanEntry(block, maps[i])));
+    return layout2;
   }
   const { doc, layout } = readShared(text2, required);
   if (!sameDoc(doc, editor.state.doc)) applyRemote(editor, [replaceDocStep(doc)]);
   return layout;
 }
 
-// src/yjs/undo-history.ts
-import * as Y5 from "yjs";
-var GROUP_DELAY = 500;
-var SELECTION = "selection";
-function groupOf(tr) {
-  if (tr.getMeta("closeHistory") === true) return null;
-  const named = tr.getMeta(HISTORY_GROUP);
-  if (named !== void 0) return named;
-  const before = tr.before.selection;
-  if (tr.origin !== "input" || before?.kind !== "text") return null;
-  return JSON.stringify([before.head.block, before.head.region]);
-}
-function undoHistory(text2, origin) {
-  const manager = new Y5.UndoManager(text2, { trackedOrigins: /* @__PURE__ */ new Set([origin]), captureTimeout: Infinity });
-  let group = null;
-  let time = 0;
-  let before = null;
-  let hint = null;
-  manager.on("stack-item-added", ({ stackItem }) => stackItem.meta.set(SELECTION, before));
-  return {
-    manager,
-    record(tr) {
-      if (!tr.docChanged) {
-        if (tr.getMeta("closeHistory") === true) group = null;
-        return;
-      }
-      const next = groupOf(tr);
-      if (next === null || next !== group || tr.time - time >= GROUP_DELAY) manager.stopCapturing();
-      group = next;
-      time = tr.time;
-      before = tr.before.selection;
-    },
-    travel(direction, editor) {
-      const stack = direction === "undo" ? manager.undoStack : manager.redoStack;
-      const item = stack.at(-1);
-      if (item === void 0) return false;
-      hint = item.meta.get(SELECTION) ?? null;
-      before = editor.state.selection;
-      group = null;
-      try {
-        return (direction === "undo" ? manager.undo() : manager.redo()) !== null;
-      } finally {
-        hint = null;
-      }
-    },
-    hint: () => hint,
-    destroy: () => manager.destroy()
-  };
+// src/yjs/read-blocks.ts
+import * as Y2 from "yjs";
+function touchedEntries(layout, delta) {
+  const touched = /* @__PURE__ */ new Map();
+  let at = 0;
+  for (const op of delta) {
+    const length = op.retain ?? op.delete ?? 0;
+    if (op.insert instanceof Y2.Map || op.retain && op.attributes) return null;
+    if (op.retain === void 0) {
+      const span = spanAt(layout, at, op.insert === void 0);
+      const start = spanStart(layout, span);
+      if (span.entry === null || start === at || at + length > start + span.length) return null;
+      touched.set(span.entry.map, span.entry);
+    }
+    at += length;
+  }
+  return touched;
+}
+function readBlocks(shared, entries, doc) {
+  const { layout } = shared;
+  const readers = /* @__PURE__ */ new Map();
+  for (const [map, entry] of entries) {
+    if (!isPlain(entry)) return null;
+    readers.set(map, reader(shared.required));
+  }
+  readItems(shared.text, (marker) => readers.get(marker));
+  const steps = [];
+  for (const [map, entry] of entries) {
+    const { doc: one, layout: own } = readers.get(map).finish();
+    const next = own.spans[1].entry;
+    const at = indexOf(layout, entry.span);
+    if (crossesStray(own, 1) || crossesStray(layout, at)) return null;
+    placeEntries(layout, at, 1, [adopted(entry, next)]);
+    if (!sameValue(blockById(doc, entry.id), one.blocks[0])) steps.push(replaceBlockStep(one.blocks[0]));
+  }
+  return steps;
 }
 
 // src/yjs/read-split-join.ts
-import * as Y6 from "yjs";
+import * as Y3 from "yjs";
 var bare = (op) => op === void 0 || op.attributes === void 0;
 function split(layout, delta, required) {
   const [at, ops] = delta[0]?.retain === void 0 ? [0, delta] : [delta[0].retain, delta.slice(1)];
   const map = ops[0]?.insert;
   const name = regionNameOf(ops[1]?.insert);
-  if (ops.length !== 2 || !(map instanceof Y6.Map) || name === null || !bare(delta[0])) return null;
+  if (ops.length !== 2 || !(map instanceof Y3.Map) || name === null || !bare(delta[0])) return null;
   const marker = readMarker(map);
   const span = spanAt(layout, at);
   if (span.entry === null || !isPlain(span.entry)) return null;
   const region2 = span.entry.regions.at(-1);
   const seg = region2?.segs[0];
   const rel = at - spanStart(layout, span);
-  if (marker === null || seg === void 0 || rel < seg.at || rel > seg.at + seg.length) return null;
+  if (marker === null || layout.entries.has(marker.id) || seg === void 0) return null;
+  if (rel < seg.at || rel > seg.at + seg.length) return null;
   if (required(marker.type).some((needed) => needed !== name)) return null;
   const { id, type, indent, attrs } = marker;
   const created = { id, type, indent, attrs: attrs?.toJSON() ?? {}, region: name, regions: {} };
@@ -760,101 +643,55 @@ function splitOrJoin(layout, delta, doc, required) {
   return step;
 }
 
-// src/yjs/text-steps.ts
-function segAt(layout, at, item) {
-  const span = spanAt(layout, at, item);
-  const rel = at - spanStart(layout, span);
-  const seg = span.segs.find((candidate) => candidate.at <= rel && rel <= candidate.at + candidate.length);
-  return seg === void 0 ? null : { seg, rel };
-}
-function formatSteps(layout, at, length, attributes) {
-  const steps = [];
-  for (let span = spanAt(layout, at, true); ; span = layout.spans[span.index + 1]) {
-    const start = spanStart(layout, span);
-    if (start >= at + length) break;
-    for (const seg of span.segs) {
-      const from = Math.max(at - start, seg.at);
-      const to = Math.min(at + length - start, seg.at + seg.length);
-      if (to <= from) continue;
-      const { entry, name } = seg.region;
-      const [first, last] = [offsetIn(seg, from), offsetIn(seg, to)];
-      for (const [key, value] of Object.entries(attributes)) {
-        const mark = markFromAttribute(key, value ?? true);
-        steps.push((value === null ? removeMarkStep : addMarkStep)(entry.id, name, first, last, mark));
-      }
-    }
-    if (span.index + 1 >= layout.spans.length) break;
-  }
-  return steps;
-}
-function textSteps(layout, delta) {
-  const steps = [];
-  let at = 0;
-  for (const op of delta) {
-    if (op.retain !== void 0) {
-      if (op.attributes !== void 0) steps.push(...formatSteps(layout, at, op.retain, op.attributes));
-      at += op.retain;
-    } else if (op.delete !== void 0) {
-      const found = segAt(layout, at, true);
-      if (found === null || found.rel + op.delete > found.seg.at + found.seg.length) return null;
-      const from = offsetIn(found.seg, found.rel);
-      const { entry, name } = found.seg.region;
-      steps.push(replaceInlineStep(entry.id, name, from, from + op.delete, []));
-      grow(layout, found.seg, found.rel, -op.delete);
-    } else {
-      const found = typeof op.insert === "string" || isAtomEmbed(op.insert) ? segAt(layout, at, false) : null;
-      if (found === null) return null;
-      const inline = inlineOfOps([op]);
-      const from = offsetIn(found.seg, found.rel);
-      const { entry, name } = found.seg.region;
-      steps.push(replaceInlineStep(entry.id, name, from, from, inline));
-      grow(layout, found.seg, found.rel, inlineLength(inline));
-      at += inlineLength(inline);
-    }
-  }
-  return steps;
-}
-
 // src/yjs/yjs-to-steps.ts
 var REREAD = new Error("reread");
-function markerSteps(shared, event, doc) {
+function markerSteps(shared, event, doc, read) {
   const target = event.target;
   const marker = target.parent === shared.text ? target : target.parent;
+  const keys = [...event.keysChanged];
+  if (target === marker && keys.includes("id")) throw REREAD;
   const fields = readMarker(marker);
   const block = fields === null ? void 0 : blockById(doc, fields.id);
-  if (block === void 0 || shared.layout.entries.get(block.id)?.map !== marker) return [];
-  const keys = [...event.keysChanged];
+  const entry = block === void 0 ? void 0 : shared.layout.entries.get(block.id);
+  if (block === void 0 || entry?.map !== marker || read.has(marker)) return [];
   if (target !== marker) {
     if (fields.attrs !== target) return [];
     return [setAttrsStep(block.id, Object.fromEntries(keys.map((key) => [key, target.get(key)])))];
   }
-  if (keys.includes("id")) throw REREAD;
-  if (keys.every((key) => key === "indent")) return [setIndentStep(block.id, fields.indent)];
-  const { type, indent, attrs } = fields;
-  const empty = shared.layout.entries.get(block.id).regions.some((region2) => region2.segs.length === 0);
-  if (empty || shared.required(type).some((name) => !Object.hasOwn(block.regions, name))) throw REREAD;
-  return [replaceBlockStep({ ...block, type, indent, attrs: attrs?.toJSON() ?? {} })];
+  if (keys.includes("type")) {
+    read.set(marker, entry);
+    return [];
+  }
+  const { indent, attrs } = fields;
+  if (keys.every((key) => key === "indent")) return [setIndentStep(block.id, indent)];
+  return [replaceBlockStep({ ...block, indent, attrs: attrs?.toJSON() ?? {} })];
 }
 function contentSteps(shared, events, doc) {
   const textEvent = events.find((event) => event.target === shared.text);
   const delta = textEvent?.delta ?? [];
+  const touched = touchedEntries(shared.layout, delta);
   const structure = splitOrJoin(shared.layout, delta, doc, shared.required);
   const steps = structure === null ? textSteps(shared.layout, delta) : [structure];
-  if (steps === null) throw REREAD;
-  let current = steps.reduce((changed, step) => step.apply(changed).doc, doc);
-  for (const event of events) {
-    if (event === textEvent) continue;
-    for (const step of markerSteps(shared, event, current)) {
+  if (steps === null && touched === null) throw REREAD;
+  const read = steps === null ? touched : /* @__PURE__ */ new Map();
+  const all = [];
+  let current = doc;
+  const take = (more) => {
+    if (more === null) throw REREAD;
+    for (const step of more) {
       current = step.apply(current).doc;
-      steps.push(step);
+      all.push(step);
     }
-  }
-  return steps;
+  };
+  take(steps ?? []);
+  for (const event of events) if (event !== textEvent) take(markerSteps(shared, event, current, read));
+  if (read.size > 0) take(readBlocks(shared, read, current));
+  return { steps: all, structural: read.size > 0 };
 }
 function readRemote(shared, events, doc) {
   try {
-    return { steps: contentSteps(shared, events, doc), structural: false };
-  } catch {
+    return contentSteps(shared, events, doc);
+  } catch (error) {
     const read = readShared(shared.text, shared.required);
     shared.layout = read.layout;
     const blocks = read.doc.blocks.map((block) => {
@@ -862,44 +699,45 @@ function readRemote(shared, events, doc) {
       return held2 !== void 0 && sameValue(held2, block) ? held2 : block;
     });
     const next = createDoc(blocks);
-    return { steps: sameDoc(next, doc) ? [] : [replaceDocStep(next)], structural: true };
+    const failed = error === REREAD ? void 0 : error;
+    return { steps: sameDoc(next, doc) ? [] : [replaceDocStep(next)], structural: true, failed };
   }
 }
 
 // src/yjs/binding.ts
-function bind(editor, text2, { origins, seed }) {
+function bind(editor, text2, options) {
+  const { origins, seed, onError } = options;
   const doc = text2.doc;
   const required = requiredRegions(editor.state.schema);
   const layout = seedOrLoad(editor, text2, { origin: origins.local, seed, required });
+  const history = options.history();
   const shared = { text: text2, layout, stale: false, required };
-  const history = undoHistory(text2, origins.local);
   const ours = (origin) => origin === origins.local || origin === origins.untracked;
-  let held2 = null;
+  const held2 = /* @__PURE__ */ new WeakMap();
   const written = /* @__PURE__ */ new WeakSet();
   const hold = (transaction) => {
-    if (!ours(transaction.origin)) held2 = holdSelection(text2, shared.layout, editor.state.selection);
+    if (!ours(transaction.origin)) held2.set(transaction, holdSelection(text2, shared.layout, editor.state.selection));
   };
   const observer = (events, transaction) => {
     if (ours(transaction.origin)) return;
-    const { steps, structural } = readRemote(shared, events, editor.state.doc);
-    if (steps.length === 0) return;
-    if (transaction.origin !== history.manager)
-      return applyRemote(editor, steps, structural ? restoreSelection(text2, shared.layout, held2) : null);
-    const tr = ownChange(editor, steps, history.hint());
-    written.add(tr);
-    editor.dispatch(tr);
+    const { steps, structural, failed } = readRemote(shared, events, editor.state.doc);
+    if (steps.length > 0 && transaction.origin !== history.manager) {
+      applyRemote(editor, steps, structural ? restoreSelection(text2, shared.layout, held2.get(transaction)) : null);
+    } else if (steps.length > 0) {
+      const tr = sharedChange(editor, steps, history.hint(), "history");
+      written.add(tr);
+      editor.dispatch(tr);
+    }
+    if (failed) onError(failed);
   };
   const settle = () => {
     shared.stale = false;
-    const read = readShared(text2, required);
-    shared.layout = read.layout;
-    if (!sameDoc(read.doc, editor.state.doc)) applyRemote(editor, [replaceDocStep(read.doc)]);
+    shared.layout = seedOrLoad(editor, text2, { origin: origins.local, seed: false, required });
   };
   doc.on("beforeTransaction", hold);
   text2.observeDeep(observer);
   return {
     editor,
-    history,
     shared,
     local(tr) {
       if (written.has(tr)) return;
@@ -914,18 +752,59 @@ function bind(editor, text2, { origins, seed }) {
     stop() {
       doc.off("beforeTransaction", hold);
       text2.unobserveDeep(observer);
-      history.destroy();
     }
   };
 }
 
+// src/yjs/undo-history.ts
+import * as Y4 from "yjs";
+var GROUP_DELAY = 500;
+var SELECTION = "selection";
+function undoHistory(text2, origin) {
+  const manager = new Y4.UndoManager(text2, { trackedOrigins: /* @__PURE__ */ new Set([origin]), captureTimeout: Infinity });
+  let group = null;
+  let time = 0;
+  let before = null;
+  let hint = null;
+  manager.on("stack-item-added", ({ stackItem }) => stackItem.meta.set(SELECTION, before));
+  return {
+    manager,
+    record(tr) {
+      if (!tr.docChanged) {
+        if (tr.getMeta("closeHistory") === true) group = null;
+        return;
+      }
+      const next = groupOf(tr);
+      if (next === null || next !== group || tr.time - time >= GROUP_DELAY) manager.stopCapturing();
+      group = next;
+      time = tr.time;
+      before = tr.before.selection;
+    },
+    travel(direction, editor) {
+      const item = manager[`${direction}Stack`].at(-1);
+      if (item === void 0) return false;
+      hint = item.meta.get(SELECTION) ?? null;
+      before = editor.state.selection;
+      group = null;
+      try {
+        return manager[direction]() !== null;
+      } finally {
+        hint = null;
+      }
+    },
+    hint: () => hint
+  };
+}
+
 // src/yjs/index.ts
 function yjsCollaboration(options) {
   const { doc, field = "quoin", awareness, user, seed = "if-empty" } = options;
   const onError = options.onError ?? ((error) => console.error(error));
   const text2 = doc.getText(field);
   const origins = { local: { user }, untracked: {} };
+  let history;
   let binding = null;
+  let disconnects = 0;
   const collaboration = {
     doc,
     text: text2,
@@ -937,11 +816,22 @@ function yjsCollaboration(options) {
         onError(new Error("A Yjs collaboration connects one editor at a time; this editor stays unconnected."));
         return () => void 0;
       }
-      const current = bind(editor, text2, { origins, seed });
+      const current = bind(editor, text2, {
+        origins,
+        seed,
+        onError,
+        history: () => history ??= undoHistory(text2, origins.local)
+      });
       binding = current;
       return () => {
         current.stop();
         if (binding === current) binding = null;
+        const at = ++disconnects;
+        setTimeout(() => {
+          if (binding !== null || at !== disconnects) return;
+          history?.manager.destroy();
+          history = void 0;
+        }, 16);
       };
     },
     onLocalTransaction: (tr, state) => {
@@ -950,8 +840,8 @@ function yjsCollaboration(options) {
     history: {
       undo: () => binding?.travel("undo") ?? false,
       redo: () => binding?.travel("redo") ?? false,
-      canUndo: () => binding?.history.manager.canUndo() ?? false,
-      canRedo: () => binding?.history.manager.canRedo() ?? false
+      canUndo: () => binding !== null && history.manager.canUndo(),
+      canRedo: () => binding !== null && history.manager.canRedo()
     }
   };
   holdBinding(collaboration, () => binding);