@panphora/clayjs 1.17.0 → 1.18.1

package/src/page/ybind/bridge.js

@@ -1,14 +1,15 @@
 import * as Y from "../../vendor/yjs.vendor.js";
 import { REMOTE_META, LOCAL, HISTORY_META, attrKeys, sameJson, parseKey, mintOp } from "./layout.js";
 import { walk, hashText } from "./walk.js";
+import { captureDelta, rewalk, walkSignature } from "./walk-delta.js";
 import { docOf } from "./doc.js";
 import { localGroup } from "./group.js";
 import { yBefore, yAfter } from "./tokens.js";
 import { yIndexAt, posAtY, cellPoint, cellAt } from "./positions.js";
 import { state as pmState } from "../../vendor/prosemirror.vendor.js";
-import { repairSiblings } from "../model.js";
+import { repairSiblings, isKey } from "../model.js";
 import { createOriginIndex, installUndoOrigins } from "./origins.js";
-import { reduceRecovery, canonicalRevision, restoreKey, physicalKeyOf, authorKey, RECOVERED_PREFIX, parsePhysicalKey, parseGoneIntents } from "./recovery.js";
+import { reduceRecovery, reduceRecoverable, canonicalRevision, restoreKey, physicalKeyOf, authorKey, RECOVERED_PREFIX, parsePhysicalKey, parseGoneIntents } from "./recovery.js";
 import { moveBlocks } from "./moves.js";
 import { createBoardCommands } from "./board-commands.js";
 import { continuesGroup, intentOf } from "../history-intent.js";
@@ -20,6 +21,7 @@ export function sameBareShape(a, b) {
   if (a.childCount !== b.childCount) return false;
   for (let i = 0; i < a.childCount; i++) {
     const left = a.child(i), right = b.child(i);
+    if (left === right) continue;
     if (left.type !== right.type) return false;
     if (attrKeys(left.type).some((key) => !sameJson(left.attrs[key], right.attrs[key]))) return false;
     if ((left.isTextblock || left.type.name === "table") && !left.content.eq(right.content)) return false;
@@ -88,11 +90,46 @@ export function keepViewPos(derived, current = null) {
     }
     if (pos === block.attrs.pos && content === block.content) return block;
     changed = true;
-    return block.type.create({ ...block.attrs, pos }, content, block.marks);
+    const attrs = { ...block.attrs, pos };
+    // The view's own node, when it is the node this would build: a block a full walk
+    // derived again unchanged keeps the object the view holds.
+    const prev = previous.get(block.attrs.id);
+    if (prev && content === block.content && prev.hasMarkup(block.type, attrs, block.marks) && prev.content.eq(content)) return prev;
+    return block.type.create(attrs, content, block.marks);
   });
   return changed ? derived.type.create(derived.attrs, placed) : derived;
 }
 
+const orderedSiblings = (node) => {
+  const ids = new Set();
+  let previous = null;
+  for (let i = 0; i < node.childCount; i++) {
+    const { id, pos } = node.child(i).attrs;
+    if (!id || ids.has(id) || !isKey(pos) || (previous !== null && previous >= pos)) return false;
+    ids.add(id);
+    previous = pos;
+  }
+  return true;
+};
+
+const sameAttrsBesidePos = (left, right) => {
+  for (const key in left.attrs) if (key !== "pos" && left.attrs[key] !== right.attrs[key]) return false;
+  return true;
+};
+
+export function keepsView(current, derived) {
+  if (current.childCount !== derived.childCount || !orderedSiblings(current)) return false;
+  for (let i = 0; i < current.childCount; i++) {
+    const left = current.child(i), right = derived.child(i);
+    if (left === right) continue;
+    const markup = left.type === right.type && left.marks === right.marks && sameAttrsBesidePos(left, right);
+    if (!markup && !left.hasMarkup(right.type, { ...right.attrs, pos: left.attrs.pos }, right.marks)) return false;
+    if (!left.content.eq(right.content)) return false;
+    if (left.type.name === "table" && !orderedSiblings(left)) return false;
+  }
+  return true;
+}
+
 const freezeDeep = (value) => {
   if (value && typeof value === "object") {
     for (const key of Object.keys(value)) freezeDeep(value[key]);
@@ -123,8 +160,16 @@ const newestLocalMarker = (pd, blockId) => {
 
 export function createBridge({ pd, onNotice = () => {}, ownedTokens = [], authorToken = null, stats = { groups: 0, mismatch: 0, renders: 0, first: null }, captureTimeout = 500 }) {
   let view = null;
-  let w = walk(pd);
+  let w = null;
+  let docVersion = 0, walkedAt = -1;
+  // The one transaction since the last walk, when there was exactly one and it changed
+  // text inside one live block (walk-delta.js); any other history forces a full walk.
+  let delta = null, deltas = 0;
+  // A view node per walk segment it was proven equal to, so an unchanged block is not
+  // derived again and comes back as the same object the view holds.
+  const nodes = new WeakMap();
   const origins = createOriginIndex(pd.origins);
+  w = walk(pd, origins);
   const um = new Y.UndoManager([pd.flow, pd.attrs, pd.gone, pd.tableFields, pd.boardFields], {
     trackedOrigins: new Set([LOCAL]),
     captureTimeout,
@@ -159,12 +204,22 @@ export function createBridge({ pd, onNotice = () => {}, ownedTokens = [], author
     const authors = [...owners].filter(Boolean).sort();
     return { kind: "recovered-change", source: record.source, revision: record.revision, blockId: record.blockId, author: authors[0] ?? null, authors };
   };
-  const recoveryState = () => {
-    if (recoveryMemo && recoveryMemo.version === recoveryVersion) return recoveryMemo.snapshot;
-    const reduced = reduceRecovery(pd, { index: origins });
+  const snapshotOf = (reduced) => {
     const recoverable = reduced.list.filter((record) => record.recoverable).map((record) => detached(record));
     const notices = detached(recoverable.map((record) => personalNotice(record)).filter((notice) => notice && !dismissed.has(`${notice.source}\u0000${notice.revision}`)));
-    const snapshot = Object.freeze({ recoverable: Object.freeze(recoverable), notices: Object.freeze(notices) });
+    return Object.freeze({ recoverable: Object.freeze(recoverable), notices: Object.freeze(notices) });
+  };
+  const proveSnapshot = (snapshot, current) => {
+    const fresh = JSON.stringify(snapshotOf(reduceRecovery(pd, { index: origins, walked: current })));
+    if (fresh === JSON.stringify(snapshot)) { stats.provedRecoveries = (stats.provedRecoveries ?? 0) + 1; return; }
+    stats.walkMismatch = (stats.walkMismatch ?? 0) + 1;
+    throw new Error("Recovery snapshot built from the displacing sources diverged from a full reduction");
+  };
+  const recoveryState = () => {
+    if (recoveryMemo && recoveryMemo.version === recoveryVersion) return recoveryMemo.snapshot;
+    const current = walkedAt === docVersion ? w : undefined;
+    const snapshot = snapshotOf(reduceRecoverable(pd, { index: origins, walked: current }));
+    if (stats.proveWalks) proveSnapshot(snapshot, current);
     recoveryMemo = { version: recoveryVersion, snapshot };
     return snapshot;
   };
@@ -182,10 +237,75 @@ export function createBridge({ pd, onNotice = () => {}, ownedTokens = [], author
     recoverySignature = signature;
     for (const listener of [...recoveryListeners]) listener(snapshot);
   };
+  const walked = (result) => { w = result; walkedAt = docVersion; delta = null; deltas = 0; };
+  const currentWalk = () => (walkedAt === docVersion ? w : null);
+  const proveWalk = (next) => {
+    const a = walkSignature(pd, next), b = walkSignature(pd, walk(pd));
+    if (a === b) { stats.provedWalks = (stats.provedWalks ?? 0) + 1; return; }
+    stats.walkMismatch = (stats.walkMismatch ?? 0) + 1;
+    throw new Error(`Incremental walk diverged from the full walk:\n${a}\n---\n${b}`);
+  };
+  // Every walk the bridge takes runs after Yjs has settled (onSettled), when the index's
+  // observer has seen every origin record; the proof walks again with a fresh index that
+  // reads the boundary and alias keys from the map itself.
+  const intentsSignature = (intents) => JSON.stringify([intents.removals, intents.restores, intents.textDeletes, [...intents.copyActive], [...intents.attrs].map(([key, fields]) => [key, [...fields]])]);
+  const proveIntents = () => {
+    if (intentsSignature(parseGoneIntents(pd.gone)) === intentsSignature(parseGoneIntents(pd.gone, { kept: false }))) { stats.provedIntents = (stats.provedIntents ?? 0) + 1; return; }
+    stats.walkMismatch = (stats.walkMismatch ?? 0) + 1;
+    throw new Error("Removal records kept across writes diverged from a fresh parse of the gone map");
+  };
+  const proveIndexWalk = (full) => {
+    proveIntents();
+    const fresh = createOriginIndex(pd.origins);
+    let b;
+    try { b = walkSignature(pd, walk(pd, { resolve: fresh.resolve, boundaryOf: fresh.boundaryOf })); } finally { fresh.dispose(); }
+    const a = walkSignature(pd, full);
+    if (a === b) { stats.provedIndexWalks = (stats.provedIndexWalks ?? 0) + 1; return; }
+    stats.walkMismatch = (stats.walkMismatch ?? 0) + 1;
+    throw new Error(`A walk with the kept origin index diverged from one with a fresh index:\n${a}\n---\n${b}`);
+  };
+  const proveRecovery = () => {
+    const fresh = JSON.stringify(snapshotOf(reduceRecovery(pd, { index: origins, walked: w })));
+    if (fresh === JSON.stringify(recoveryState())) return;
+    stats.walkMismatch = (stats.walkMismatch ?? 0) + 1;
+    throw new Error("Recovery snapshot kept across an incremental walk diverged from a fresh one");
+  };
+  // Walks from the start, or re-walks the one block the only transaction since the last
+  // walk changed. Returns that transaction's delta when the walk was incremental.
+  const walkNow = () => {
+    const change = deltas === 1 ? delta : null;
+    const next = !change ? null : change.marker ? rewalk(pd, w, change.marker, change) : w;
+    if (!next) {
+      const full = walk(pd, origins);
+      if (stats.proveWalks) proveIndexWalk(full);
+      walked(full);
+      return null;
+    }
+    if (change.fields.size) for (const seg of next.visible) if (change.fields.has(seg.baseId)) nodes.delete(seg);
+    stats.incrementalWalks = (stats.incrementalWalks ?? 0) + 1;
+    if (stats.proveWalks) proveWalk(next);
+    walked(next);
+    return change;
+  };
+  const adopt = (doc) => {
+    if (doc.childCount !== w.visible.length) return;
+    for (let i = 0; i < doc.childCount; i++) if (!nodes.has(w.visible[i])) nodes.set(w.visible[i], doc.child(i));
+  };
+  const forget = (before, after) => {
+    if (before.childCount !== w.visible.length) return;
+    const d = docDiff(before, after);
+    if (!d) return;
+    const from = before.resolve(d.start).index(0), to = Math.min(before.childCount - 1, before.resolve(d.endA).index(0));
+    for (let i = from; i <= to; i++) nodes.delete(w.visible[i]);
+  };
   const refresh = () => {
-    w = walk(pd);
-    bumpRecovery();
-    return docOf(pd, w);
+    const change = walkNow();
+    // Text this tab inserted into one live block has fresh ids, so it is no copy's source
+    // and the recovery snapshot stands. A deletion can displace a moved copy's source, and
+    // a peer's late insert can be the source of a hidden copy's displaced run.
+    if (!change || change.deleted || change.fields.size || (change.remote && w.hidden.length)) bumpRecovery();
+    else if (stats.proveWalks) proveRecovery();
+    return docOf(pd, w, nodes);
   };
   let saved = null;
   let lastIntent = null;
@@ -197,7 +317,7 @@ export function createBridge({ pd, onNotice = () => {}, ownedTokens = [], author
     saved = null;
     const derived = keepViewPos(fresh ?? refresh(), view.state.doc);
     const d = docDiff(view.state.doc, derived);
-    if (!d) return;
+    if (!d) { adopt(view.state.doc); return; }
     const tr = view.state.tr.replace(d.start, d.endA, derived.slice(d.start, d.endB)).setMeta(REMOTE_META, true).setMeta("addToHistory", false);
     if (own) tr.setMeta("yundo", true);
     if (keep) {
@@ -226,6 +346,27 @@ export function createBridge({ pd, onNotice = () => {}, ownedTokens = [], author
       if (a !== null && a !== undefined && h !== null && h !== undefined) tr.setSelection(pmState.TextSelection.create(tr.doc, a, h));
     }
     view.dispatch(tr);
+    adopt(view.state.doc);
+  };
+  // A transaction that wrote nothing (an update the tab already had, Yjs's formatting
+  // cleanup after a remote insert) leaves the walk as it was: it is not a delta, it is
+  // never rendered, and a walk current before it stays current after it.
+  const began = new WeakMap();
+  const idle = new WeakSet();
+  const unchanged = (t) => {
+    if (t.changed.size || t.deleteSet.clients.size) return false;
+    for (const [client, clock] of t.afterState) if ((t.beforeState.get(client) ?? 0) !== clock) return false;
+    return true;
+  };
+  const stale = (t) => { began.set(t, docVersion); docVersion++; };
+  const onTransaction = (t) => {
+    if (unchanged(t)) {
+      idle.add(t);
+      if (walkedAt === began.get(t) && docVersion === walkedAt + 1) walkedAt = docVersion;
+      return;
+    }
+    deltas++;
+    delta = deltas === 1 ? captureDelta(pd, t, w) : null;
   };
   const onBefore = (t) => {
     if (groupOpen && !joining && t.origin === LOCAL) { um.stopCapturing(); groupOpen = false; }
@@ -245,12 +386,24 @@ export function createBridge({ pd, onNotice = () => {}, ownedTokens = [], author
   };
   const onAfter = (t) => {
     if (t.origin !== LOCAL) { lastIntent = null; groupOpen = false; }
+  };
+  // One render per batch Yjs settles (a transaction and those its observers queued), after
+  // its garbage collection and merges, so the walk it leaves is current for the next keystroke.
+  const onSettled = (doc, transactions) => {
+    let changed = false, local = false, own = false;
+    for (const t of transactions) {
+      if (idle.has(t)) continue;
+      changed = true;
+      if (t.origin === LOCAL) local = true;
+      else if (t.origin === um) own = true;
+    }
+    if (!changed) { saved = null; return; }
     if (!view) { bumpRecovery(); return; }
-    if (t.origin === LOCAL) { saved = null; return; }
-    render(t.origin === um);
+    if (local) { saved = null; return; }
+    render(own);
   };
   const portMove = (tr, move) => {
-    const result = moveBlocks({ pd, view, um, origins, render }, move);
+    const result = moveBlocks({ pd, view, um, origins, render, walked: currentWalk() }, move);
     if (result.status !== "moved") {
       if (result.status === "refused") stats.moveRefusals = (stats.moveRefusals ?? 0) + 1;
       return result;
@@ -273,17 +426,23 @@ export function createBridge({ pd, onNotice = () => {}, ownedTokens = [], author
     return result;
   };
   const board = createBoardCommands({ pd, um, origins, render: () => (view ? render() : refresh()) });
+  pd.ydoc.on("beforeTransaction", stale);
   pd.ydoc.on("beforeTransaction", onBefore);
+  pd.ydoc.on("afterTransaction", onTransaction);
   pd.ydoc.on("afterTransaction", onAfter);
+  pd.ydoc.on("afterAllTransactions", onSettled);
   return {
     pd, stats, render, um, board,
     attach(v) {
       view = v;
-      w = walk(pd);
+      walked(walk(pd, origins));
     },
     dispose() {
+      pd.ydoc.off("beforeTransaction", stale);
       pd.ydoc.off("beforeTransaction", onBefore);
+      pd.ydoc.off("afterTransaction", onTransaction);
       pd.ydoc.off("afterTransaction", onAfter);
+      pd.ydoc.off("afterAllTransactions", onSettled);
       offOrigins();
       origins.dispose();
       um.destroy();
@@ -320,7 +479,8 @@ export function createBridge({ pd, onNotice = () => {}, ownedTokens = [], author
         }
         return;
       }
-      w = walk(pd);
+      if (walkedAt !== docVersion) walkNow();
+      else stats.reusedWalks = (stats.reusedWalks ?? 0) + 1;
       const history = transactions.every((t) => t.getMeta("addToHistory") !== false);
       const register = registerAuthor;
       registerAuthor = null;
@@ -334,10 +494,17 @@ export function createBridge({ pd, onNotice = () => {}, ownedTokens = [], author
         joining = false;
       }
       groupOpen = intent !== null;
+      const current = view.state.doc;
+      forget(local[0].before, current);
       const derived = refresh();
-      if (!sameBareShape(derived, view.state.doc)) {
+      if (!sameBareShape(derived, current)) {
         stats.mismatch++;
-        stats.first ??= { before: bareShape(local[0].before), pm: bareShape(view.state.doc), y: bareShape(derived) };
+        stats.first ??= { before: bareShape(local[0].before), pm: bareShape(current), y: bareShape(derived) };
+      } else if (keepsView(current, derived)) {
+        stats.renders++;
+        saved = null;
+        adopt(current);
+        return;
       }
       render(false, derived);
     },
@@ -377,7 +544,7 @@ export function createBridge({ pd, onNotice = () => {}, ownedTokens = [], author
       return { status: "restored", id: blockId };
     },
     moveBlocks(args) {
-      return moveBlocks({ pd, view, um, origins, render }, args);
+      return moveBlocks({ pd, view, um, origins, render, walked: currentWalk() }, args);
     },
     undo() { return um.undo() !== null; },
     redo() { return um.redo() !== null; },

package/src/page/ybind/containment.js

@@ -0,0 +1,162 @@
+/**
+ * containment.js — whether an update adds anything to a state, asked without applying it.
+ *
+ * Applying an update changes nothing exactly when every item it carries is already there,
+ * by id, and every id it deletes is already deleted. So a state is read once into ranges,
+ * the clock ranges its items occupy and the ranges it deletes, and each update is then
+ * read, never applied: a hundred records cost one reading of the state, not a hundred.
+ *
+ * Two kinds of state answer. A state integrated into a document answers exactly as
+ * applying would, and one that leaves anything pending contains nothing. The union of some
+ * entries' own ranges answers for content: an update inside it adds no item and no explicit
+ * deletion any of those entries lacks, so retiring it loses nothing they do not hold. It can
+ * miss a deletion Yjs only makes while integrating, never claim one. A state vector alone
+ * proves nothing about deletions.
+ */
+
+import { Doc, Skip, applyUpdateV2, decodeUpdateV2, createDeleteSetFromStructStore } from "../../vendor/yjs.vendor.js";
+
+function merged(map) {
+  for (const [client, list] of map) {
+    list.sort((a, b) => a[0] - b[0]);
+    const out = [];
+    for (const range of list) {
+      const last = out[out.length - 1];
+      if (last && range[0] <= last[1]) { if (range[1] > last[1]) last[1] = range[1]; }
+      else out.push([range[0], range[1]]);
+    }
+    map.set(client, out);
+  }
+  return map;
+}
+
+const add = (map, client, from, to) => {
+  if (to <= from) return;
+  const list = map.get(client);
+  if (list) list.push([from, to]);
+  else map.set(client, [[from, to]]);
+};
+
+/**
+ * The clock ranges one update's items occupy and the ranges it deletes.
+ *
+ * @param {Uint8Array} update - a V2 update
+ * @returns {{items: Map<number, Array<[number, number]>>, deletes: Map<number, Array<[number, number]>>}}
+ */
+export function rangesOf(update) {
+  const { structs, ds } = decodeUpdateV2(update);
+  const items = new Map();
+  for (const struct of structs) if (!(struct instanceof Skip)) add(items, struct.id.client, struct.id.clock, struct.id.clock + struct.length);
+  const deletes = new Map();
+  for (const [client, list] of ds.clients) for (const { clock, len } of list) add(deletes, client, clock, clock + len);
+  return { items: merged(items), deletes: merged(deletes) };
+}
+
+/**
+ * The ranges several entries hold together.
+ *
+ * @param {Array<Object>} list - from rangesOf() or unite()
+ * @returns {Object}
+ */
+export function unite(list) {
+  if (list.length === 1) return list[0];
+  const items = new Map();
+  const deletes = new Map();
+  for (const ranges of list) {
+    for (const [client, spans] of ranges.items) for (const [from, to] of spans) add(items, client, from, to);
+    for (const [client, spans] of ranges.deletes) for (const [from, to] of spans) add(deletes, client, from, to);
+  }
+  return { items: merged(items), deletes: merged(deletes) };
+}
+
+function inside(spans, from, to) {
+  if (!spans) return false;
+  let lo = 0, hi = spans.length - 1;
+  while (lo <= hi) {
+    const mid = (lo + hi) >> 1;
+    const span = spans[mid];
+    if (from < span[0]) hi = mid - 1;
+    else if (from >= span[1]) lo = mid + 1;
+    else return to <= span[1];
+  }
+  return false;
+}
+
+/**
+ * Whether every item and deletion of `ranges` is already inside `state`.
+ *
+ * @param {Object} state - from unite(), rangesOf() or indexOf()
+ * @param {Object} ranges - from rangesOf()
+ * @returns {boolean}
+ */
+export function within(state, ranges) {
+  if (state.complete === false) return false;
+  for (const [client, spans] of ranges.items) for (const [from, to] of spans) if (!inside(state.items.get(client), from, to)) return false;
+  for (const [client, spans] of ranges.deletes) for (const [from, to] of spans) if (!inside(state.deletes.get(client), from, to)) return false;
+  return true;
+}
+
+/**
+ * A document's state as ranges: every item from clock 0 to its state, and every deletion
+ * it holds, its own and the ones integration made.
+ *
+ * @param {Doc} doc
+ * @returns {Object}
+ */
+export function docRanges(doc) {
+  if (doc.store.pendingStructs || doc.store.pendingDs) return { complete: false };
+  const items = new Map();
+  for (const [client, structs] of doc.store.clients) {
+    const last = structs[structs.length - 1];
+    add(items, client, 0, last.id.clock + last.length);
+  }
+  const deletes = new Map();
+  for (const [client, list] of createDeleteSetFromStructStore(doc.store).clients) for (const { clock, len } of list) add(deletes, client, clock, clock + len);
+  return { complete: true, items, deletes: merged(deletes) };
+}
+
+/**
+ * The state some updates make together, integrated once.
+ *
+ * @param {Array<Uint8Array>} updates
+ * @returns {Object}
+ */
+export function stateIndex(updates) {
+  const doc = new Doc({ gc: false });
+  try {
+    for (const update of updates) applyUpdateV2(doc, update);
+    return docRanges(doc);
+  } finally {
+    doc.destroy();
+  }
+}
+
+const indexes = new WeakMap();
+
+/**
+ * The state one checkpoint's bytes make, read once for as long as those bytes are held.
+ * The bytes are never written to after they are indexed.
+ *
+ * @param {Uint8Array} bytes
+ * @param {Doc} [doc] - the document these bytes were just encoded from, when there is one
+ * @returns {Object}
+ */
+export function indexOf(bytes, doc = null) {
+  let index = indexes.get(bytes);
+  if (!index) {
+    index = doc ? docRanges(doc) : stateIndex([bytes]);
+    indexes.set(bytes, index);
+  }
+  return index;
+}
+
+/**
+ * Whether applying `update` to the indexed state would add no item and no deletion.
+ *
+ * @param {Object} index - from indexOf() or stateIndex()
+ * @param {Uint8Array} update
+ * @returns {boolean}
+ */
+export function indexContains(index, update) {
+  return index.complete !== false && within(index, rangesOf(update));
+}

package/src/page/ybind/doc.js

@@ -26,16 +26,21 @@ const rawOf = (pd, b) => {
   return out;
 };
 
-export function docOf(pd, w) {
-  const blocks = w.visible.map((b) => {
+// `nodes`, when given, maps a walk segment to a node already proven equal to what this
+// function would build for it (the bridge fills it from the view): that block costs
+// nothing to derive again, and the same node object comes back.
+export function docOf(pd, w, nodes = null) {
+  const build = (b) => {
     if (b.opaque) {
       const fields = b.recovered ? { ...copy(b.fields ?? {}) } : rawOf(pd, b);
       return { b, type: schema.nodes.opaque_block, fields, opaque: true };
     }
     const type = schema.nodes[b.t] ?? schema.nodes.paragraph;
     return { b, type, fields: { ...(b.fields ?? fieldsOf(pd, b, type)) } };
-  });
-  const byId = new Map(blocks.map((block) => [block.b.id, block]));
+  };
+  const blocks = w.visible.map((b) => { const node = nodes?.get(b); return node ? { b, node } : build(b); });
+  const byId = new Map(blocks.map((block, i) => [block.b.id, i]));
+  const parentOf = (i) => (blocks[i].node ? blocks[i].node.attrs.parent : blocks[i].fields.parent);
   const rankOf = (block) => {
     const item = block.b.recovered
       ? pd.gone._map.get(attrKey(block.b.sourceKey, "parent"))
@@ -48,17 +53,20 @@ export function docOf(pd, w) {
     while (byId.has(id) && !positions.has(id)) {
       positions.set(id, chain.length);
       chain.push(id);
-      id = byId.get(id).fields.parent;
+      id = parentOf(byId.get(id));
     }
     if (!positions.has(id)) continue;
     const cycle = chain.slice(positions.get(id));
     const lowest = cycle.reduce((left, right) => {
-      const a = rankOf(byId.get(left)), b = rankOf(byId.get(right));
+      const a = rankOf(blocks[byId.get(left)]), b = rankOf(blocks[byId.get(right)]);
       return a.clock < b.clock || (a.clock === b.clock && a.client < b.client) ? left : right;
     });
-    byId.get(lowest).fields.parent = null;
+    const at = byId.get(lowest);
+    if (blocks[at].node) blocks[at] = build(blocks[at].b);
+    blocks[at].fields.parent = null;
   }
-  const nodes = blocks.map(({ b, type, fields, opaque }) => {
+  const built = blocks.map(({ b, node, type, fields, opaque }) => {
+    if (node) return node;
     if (opaque) {
       const content = [];
       for (const r of b.runs) {
@@ -79,5 +87,5 @@ export function docOf(pd, w) {
     }
     return type.create(attrs, content);
   });
-  return nodes.length ? schema.nodes.doc.create(null, nodes) : schema.nodes.doc.createAndFill();
+  return built.length ? schema.nodes.doc.create(null, built) : schema.nodes.doc.createAndFill();
 }

package/src/page/ybind/file-debt.js

@@ -0,0 +1,63 @@
+/**
+ * file-debt.js — what this tab authored that no accepted file save has covered yet.
+ *
+ * One merged Yjs update per page binding, not a list of per-keystroke records and not an
+ * IndexedDB journal: a leave needs to know whether this tab's own input still owes the
+ * file, and it needs that answer synchronously. Adopting a peer's update, delivering one
+ * and compacting the store are not this tab's input, so none of them records here.
+ *
+ * Only accepted page bytes clear it, and only by the coverage primitive: a state that does
+ * not decode, or does not carry every insertion and deletion this tab owns, leaves the
+ * obligation exactly where it was.
+ */
+
+import { mergeUpdatesV2 } from "../../vendor/yjs.vendor.js";
+import { canonicalPageBytes, containsUpdate } from "./recovery-proof.js";
+
+/**
+ * The file obligation of one page binding.
+ *
+ * @param {{changed?: Function}} [options] - notified whenever the answer may have changed
+ * @returns {{local: Function, pending: Function, accepted: Function}}
+ */
+export function createPageFileDebt({ changed = () => {} } = {}) {
+  // Merged in runs of doubling length, as a binary counter carries: slot k holds 2^k of
+  // this tab's updates. A keystroke merges with the runs it completes, not with everything
+  // the session typed, so a long session without an accepted save stays cheap to type in.
+  let runs = [];
+  const owned = () => {
+    const parts = runs.filter(Boolean);
+    if (!parts.length) return null;
+    const merged = parts.length === 1 ? parts[0] : mergeUpdatesV2(parts);
+    runs = runs.map(() => null);
+    runs[runs.length - 1] = merged;
+    return merged;
+  };
+  return {
+    local(update) {
+      let carry = update.slice();
+      let k = 0;
+      for (; runs[k]; k++) {
+        carry = mergeUpdatesV2([runs[k], carry]);
+        runs[k] = null;
+      }
+      runs[k] = carry;
+      changed();
+    },
+    pending() {
+      return runs.some(Boolean);
+    },
+    accepted(state) {
+      const merged = owned();
+      if (!merged) return true;
+      let covered = false;
+      try {
+        covered = containsUpdate(canonicalPageBytes(state), merged);
+      } catch {}
+      if (!covered) return false;
+      runs = [];
+      changed();
+      return true;
+    },
+  };
+}

package/src/page/ybind/layout.js

@@ -9,9 +9,14 @@ export const HISTORY_META = Symbol("page-history");
 export const PAGE_ROOTS = Object.freeze(["flow", "attrs", "gone", "boardFields", "tableFields", "origins"]);
 
 const SKIP = new Set(["id", "pos"]);
-export const attrKeys = (type) => [...Object.keys(type.spec.attrs || {}).filter((k) => !SKIP.has(k)), ...(type.name === "table" ? ["rows"] : [])];
+const KEYS = new WeakMap();
+export const attrKeys = (type) => {
+  let keys = KEYS.get(type);
+  if (!keys) KEYS.set(type, keys = Object.freeze([...Object.keys(type.spec.attrs || {}).filter((k) => !SKIP.has(k)), ...(type.name === "table" ? ["rows"] : [])]));
+  return keys;
+};
 export const defaultOf = (type, k) => type.name === "table" && k === "rows" ? {} : type.spec.attrs[k].default;
-export const sameJson = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+export const sameJson = (a, b) => a === b || JSON.stringify(a) === JSON.stringify(b);
 export const idKey = (id) => `${id.client}.${id.clock}`;
 export const parseKey = (k) => { const i = k.indexOf("."); return { client: +k.slice(0, i), clock: +k.slice(i + 1) }; };
 export const isHigh = (u) => u >= 0xd800 && u <= 0xdbff;

package/src/page/ybind/marks.js

@@ -30,7 +30,7 @@ export function marksFromAttributes(a, blockType) {
   const marks = [];
   let unknown = null;
   for (const [n, v] of best) {
-    if (schema.marks[n] && (!NATIVE_NAMES.has(n) || nativeAttrs(n, v))) marks.push(schema.marks[n].create(v === true ? null : v));
+    if (schema.marks[n] && (!NATIVE_NAMES.has(n) || nativeAttrs(n, v === true ? {} : v))) marks.push(schema.marks[n].create(v === true ? null : v));
     else (unknown ??= {})[n] = v;
   }
   // The walk asks this of every text run on every keystroke, and almost none carry a

package/src/page/ybind/moves.js

@@ -4,6 +4,7 @@ import { state as pmState } from "../../vendor/prosemirror.vendor.js";
 import { walk } from "./walk.js";
 import { docOf } from "./doc.js";
 import { createProjectionMap } from "./projection-map.js";
+import { beforeFence } from "./writer.js";
 import { unitIds } from "./origins.js";
 import { attrKey, copyActiveKey, parseGoneIntents, physicalKeyOf, recoveredRoot, removeKey, restoreKey } from "./recovery.js";
 
@@ -113,12 +114,12 @@ const liveRemovals = (pd, current, selected) => {
   return out;
 };
 
-export function moveBlocks({ pd, view, um, origins, render }, args = {}) {
+export function moveBlocks({ pd, view, um, origins, render, walked = null }, args = {}) {
   const ids = Array.isArray(args?.ids) ? [...new Set(args.ids)] : [];
   const afterId = args?.afterId === undefined ? null : args.afterId;
   const hasParent = args?.parent !== undefined;
 
-  const current = walk(pd, origins);
+  const current = walked ?? walk(pd, origins);
   // An opaque block is an operation this runtime must refuse before writing: it
   // has no turn-into, it cannot be carried, and its record is never rewritten.
   const protectedIds = new Set(current.visible.filter((seg) => seg.opaque).map((seg) => seg.id));
@@ -264,7 +265,7 @@ export function moveBlocks({ pd, view, um, origins, render }, args = {}) {
       let text = null, textAttrs = null;
       const flush = () => {
         if (text === null) return;
-        pd.flow.insert(cursor, text, textAttrs ?? undefined);
+        beforeFence(pd, cursor, after.fences, () => pd.flow.insert(cursor, text, textAttrs ?? undefined));
         cursor += text.length;
         text = null;
       };
@@ -275,7 +276,7 @@ export function moveBlocks({ pd, view, um, origins, render }, args = {}) {
           text += unit.ch;
         } else {
           flush();
-          pd.flow.insertEmbed(cursor, unit.embed, unit.attrs);
+          beforeFence(pd, cursor, after.fences, () => pd.flow.insertEmbed(cursor, unit.embed, unit.attrs));
           cursor += 1;
         }
       }