@panphora/clayjs 1.13.1 → 1.14.0

package/src/page/binding.js

@@ -1,647 +0,0 @@
-// The page editor's live binding: one ProseMirror view on one live store, with
-// every text block merged by its own replay (replay.js).
-//
-// The store's value is { blocks: { <id>: block }, deleted: { <id>: true } }.
-// A text block is { t, pos, ...attrs, c, m? } (model.js, inline.js), and this
-// binding's writes add w (replay.js). Any other block is written whole and the
-// later write wins. A delete sets the tombstone in the same update, so a stale
-// write never brings the block back.
-//
-// Local side: each transaction becomes one store update with one write per
-// block it changed, never a ProseMirror step carried across keys. A split
-// truncates the first half and creates the second; a join or a delete across
-// blocks rewrites the first and deletes the rest.
-//
-// Remote side: each frame's ops go through the replays in room order. A block
-// is released into the editor (its agreed value, as minimal steps kept out of
-// the undo history) once this tab has no write for it in flight and is not
-// composing, so a release never has unconfirmed local steps under it.
-import { state as pmState, transform as pmTransform } from "../vendor/prosemirror.vendor.js";
-import { REMOTE, blockJson, docFromBlocks, newId, nodeFromBlock } from "./model.js";
-import { flatten, marksOf, unflatten } from "./inline.js";
-import { createReplay, hashOf, join, mapCaret, regions, step, strip, tombstone } from "./replay.js";
-import { registerUnsavedState } from "../lib/unsaved-state.js";
-
-const { TextSelection } = pmState;
-const rawOf = (value, id) => (value && value.blocks && value.blocks[id]) || null;
-const tombOf = (value, id) => !!(value && value.deleted && value.deleted[id]);
-const same = (a, b) => (a === null || b === null ? a === b : hashOf(a) === hashOf(b));
-const keyAt = (m, i) => (m && m[i]) || "";
-const isHigh = (u) => u >= 0xd800 && u <= 0xdbff;
-const isLow = (u) => u >= 0xdc00 && u <= 0xdfff;
-
-// The record's document: every block not under its tombstone.
-export function docFromRecord(schema, value) {
-  const blocks = {};
-  for (const [id, block] of Object.entries((value && value.blocks) || {})) if (!tombOf(value, id)) blocks[id] = strip(block);
-  return docFromBlocks(schema, blocks);
-}
-
-// The block an op touches, or null for one on the whole map.
-function blockOf(op) {
-  if ((op.path[0] === "blocks" || op.path[0] === "deleted") && op.path.length >= 2) return String(op.path[1]);
-  return null;
-}
-
-// One frame's ops as block ops, in order: { id, X } (X null: deleted) or
-// { id, tombstone: true }. An op deeper than a block (a data API set on one
-// field) or on the whole map takes the block's value after the frame, whole.
-function blockOps(ops, prev, next) {
-  const out = [];
-  for (const op of ops) {
-    const [root, id] = op.path;
-    if (op.path.length === 0 || (op.path.length === 1 && root === "blocks")) {
-      const ids = new Set([...Object.keys(prev?.blocks ?? {}), ...Object.keys(next?.blocks ?? {})]);
-      for (const k of ids) out.push({ id: k, X: rawOf(next, k) ? strip(rawOf(next, k)) : null });
-      if (op.path.length === 0) for (const k of Object.keys(next?.deleted ?? {})) out.push({ id: k, tombstone: true });
-      continue;
-    }
-    if (root === "deleted") {
-      if (op.path.length === 1 && op.op === "set" && op.value) for (const k of Object.keys(op.value)) if (op.value[k]) out.push({ id: k, tombstone: true });
-      if (op.path.length === 2 && op.op === "set" && op.value) out.push({ id: String(id), tombstone: true });
-      continue;
-    }
-    if (root !== "blocks") continue;
-    if (op.path.length === 2) out.push({ id: String(id), X: op.op === "set" ? op.value : null });
-    else out.push({ id: String(id), X: rawOf(next, id) ? strip(rawOf(next, id)) : null });
-  }
-  return out;
-}
-
-// Per top-level block of the final document, the range of its content every
-// step of these transactions touched, in that document's offsets. A step that
-// only changes a node's type or attrs touches no content.
-function touchedRanges(trs, doc) {
-  const maps = trs.flatMap((tr) => tr.mapping.maps);
-  const steps = trs.flatMap((tr) => tr.steps);
-  const ranges = [];
-  steps.forEach((s, i) => {
-    if (s instanceof pmTransform.AttrStep) return;
-    if (s instanceof pmTransform.ReplaceAroundStep && s.structure && s.gapFrom === s.from + 1 && s.gapTo === s.to - 1 && s.slice.content.childCount === 1 && s.slice.openStart === 0) return;
-    const later = new pmTransform.Mapping(maps.slice(i + 1));
-    const own = [];
-    if (s instanceof pmTransform.AddMarkStep || s instanceof pmTransform.RemoveMarkStep) own.push([s.from, s.to]);
-    else s.getMap().forEach((_a, _b, from, to) => own.push([from, to]));
-    for (const [from, to] of own) ranges.push([later.map(from, -1), later.map(to, 1)]);
-  });
-  const out = new Map();
-  doc.forEach((node, offset) => {
-    if (!node.isTextblock || !node.attrs.id) return;
-    const start = offset + 1, end = offset + node.nodeSize - 1;
-    for (const [a, b] of ranges) {
-      if (b < start || a > end) continue;
-      const r = out.get(node.attrs.id) ?? { from: Infinity, to: -Infinity };
-      out.set(node.attrs.id, { from: Math.min(r.from, Math.max(a, start) - start), to: Math.max(r.to, Math.min(b, end) - start) });
-    }
-  });
-  return out;
-}
-
-const sameUnit = (x, i, y, j) => x.c.charCodeAt(i) === y.c.charCodeAt(j) && keyAt(x.m, i) === keyAt(y.m, j);
-
-// The splice that turns prev into next (flat { c, m }): prev[p, e) became
-// next[p, q). Its position comes from the steps' range when that range explains
-// the change; otherwise from a diff. Units equal in text and marks at either
-// end are trimmed off, and a surrogate pair is never cut.
-function spliceFrom(prev, next, range) {
-  let p, e, q;
-  const fits = (p, e, q) => {
-    if (p < 0 || e < p || q < p || e > prev.c.length || q > next.c.length || prev.c.length - e !== next.c.length - q) return false;
-    for (let i = 0; i < p; i++) if (!sameUnit(prev, i, next, i)) return false;
-    for (let i = 0; i < prev.c.length - e; i++) if (!sameUnit(prev, e + i, next, q + i)) return false;
-    return true;
-  };
-  if (range && fits(range.from, prev.c.length - (next.c.length - range.to), range.to)) {
-    p = range.from;
-    q = range.to;
-    e = prev.c.length - (next.c.length - q);
-  } else {
-    p = 0;
-    while (p < prev.c.length && p < next.c.length && sameUnit(prev, p, next, p)) p++;
-    let s = 0;
-    while (s < prev.c.length - p && s < next.c.length - p && sameUnit(prev, prev.c.length - 1 - s, next, next.c.length - 1 - s)) s++;
-    e = prev.c.length - s;
-    q = next.c.length - s;
-  }
-  while (p < e && p < q && sameUnit(prev, p, next, p)) p++;
-  while (e > p && q > p && sameUnit(prev, e - 1, next, q - 1)) { e--; q--; }
-  if (p > 0 && isHigh(prev.c.charCodeAt(p - 1))) p--;
-  if (e < prev.c.length && isLow(prev.c.charCodeAt(e))) { e++; q++; }
-  if (p === e && p === q) return null;
-  const rm = prev.m.slice(p, e);
-  return [p, e, prev.c.slice(p, e), prev.c.length, ...(rm.some(Boolean) ? [rm] : [])];
-}
-
-function changedFields(before, after) {
-  const out = [];
-  for (const name of new Set([...Object.keys(before), ...Object.keys(after)])) {
-    if (name === "c" || name === "m" || name === "w") continue;
-    if (JSON.stringify(before[name]) !== JSON.stringify(after[name])) out.push(name);
-  }
-  return out;
-}
-
-function findBlock(doc, id) {
-  let found = null;
-  doc.forEach((node, pos, index) => { if (!found && node.attrs.id === id) found = { node, pos, index }; });
-  return found;
-}
-
-const orderKey = (pos, id) => [pos ?? "", id ?? ""];
-const before = (a, b) => (a[0] !== b[0] ? a[0] < b[0] : a[1] < b[1]);
-
-/**
- * @param {object} o
- * @param {object} o.schema
- * @param {object} o.store         the live store (plugins/live.js storeOf)
- * @param {object} o.lane          the fast lane (fastLane()), for its writer and epoch
- * @param {string} o.me            this tab's client id: the author of its writes
- * @param {Function} [o.setTimer] @param {Function} [o.clearTimer]
- * @param {number} [o.quiet]       ms of quiet before the writer repairs the room
- * @param {Function} [o.checkpointWithin]  plugins/live.js; nudged after every change
- * @param {Function} [o.requestCheckpoint] plugins/live.js; the end of a flush
- * @param {Function} [o.onNotice]
- */
-export function createPageBinding({ schema, store, lane, me, setTimer = setTimeout, clearTimer = clearTimeout, quiet = 500, checkpointWithin = () => {}, requestCheckpoint = null, onNotice = () => {} }) {
-  const blocks = new Map();
-  const dirty = new Set();
-  const opBlock = new Map();
-  const own = [];
-  const stats = { writes: 0, releases: 0, repairs: 0, follows: 0, heals: 0 };
-  const waiters = new Set();
-  let view = null;
-  let epoch = null;
-  let seq = 0;
-  let composing = false;
-
-  const isText = (t) => !!schema.nodes[t]?.isTextblock;
-  const agreedOf = (B) => (B.text ? B.r.S : B.tomb ? null : strip(rawOf(store.authoritative, B.id)));
-  const epochNow = () => epoch ?? lane.status.epoch ?? null;
-
-  function ensure(id, value, X) {
-    let B = blocks.get(id);
-    if (B) return B;
-    const raw = value ? rawOf(value, id) : null;
-    const t = (X && X.t) || (raw && raw.t);
-    B = { id, text: t ? isText(t) : true, r: null, tomb: false, k: seq, edited: false, refused: false, removedFrom: null, unechoed: [], timer: null };
-    if (B.text) {
-      B.r = createReplay(raw ? strip(raw) : null, { seq, epoch: epochNow(), me });
-      B.r.tomb = tombOf(value, id);
-      if (B.r.tomb) B.r.S = null;
-    } else B.tomb = tombOf(value, id);
-    blocks.set(id, B);
-    return B;
-  }
-  for (const id of Object.keys(store.authoritative?.blocks ?? {})) ensure(id, store.authoritative);
-
-  const plugin = new pmState.Plugin({
-    // A pasted copy of a block gets a new id from identityPlugin (model.js),
-    // which knows the original from the transaction's mapping. Clearing ids in
-    // transformPasted would be wrong: ProseMirror runs it on a drag that moves
-    // a block too, before it knows the drop is a move.
-    props: {
-      handleDOMEvents: {
-        compositionstart() { composing = true; return false; },
-        compositionend() { composing = false; setTimer(releaseAll, 0); return false; },
-      },
-    },
-    // A block that comes back under its tombstone's id (undo of a delete, a
-    // paste of a deleted block) is a new block.
-    appendTransaction(trs, old, next) {
-      if (!trs.some((tr) => tr.docChanged && !tr.getMeta(REMOTE))) return null;
-      const had = new Set();
-      old.doc.forEach((node) => had.add(node.attrs.id));
-      const tr = next.tr;
-      next.doc.forEach((node, offset) => {
-        const id = node.attrs.id;
-        if (id && !had.has(id) && tombOf(store.value, id)) tr.setNodeMarkup(offset, null, { ...node.attrs, id: newId("b") });
-      });
-      return tr.docChanged ? tr : null;
-    },
-  });
-
-  // ---- local side ----------------------------------------------------------
-
-  function dispatch(tr) {
-    const prev = view.state;
-    const { state, transactions } = prev.applyTransaction(tr);
-    view.updateState(state);
-    const local = transactions.filter((t) => !t.getMeta(REMOTE));
-    if (local.some((t) => t.docChanged) && !transactions.some((t) => t.getMeta(REMOTE))) commit(prev.doc, state.doc, local);
-  }
-
-  function commit(prevDoc, nextDoc, trs) {
-    const index = (doc) => {
-      const map = new Map();
-      doc.forEach((node) => { if (node.attrs.id) map.set(node.attrs.id, node); });
-      return map;
-    };
-    const was = index(prevDoc), now = index(nextDoc);
-    const ranges = touchedRanges(trs, nextDoc);
-    const writes = [];
-    for (const [id, node] of was) if (!now.has(id)) writes.push({ id, del: true, text: node.textContent });
-    for (const [id, node] of now) {
-      const old = was.get(id);
-      if (old === node) continue;
-      const value = blockJson(node);
-      if (!old) { writes.push({ id, value }); continue; }
-      const prevJson = blockJson(old);
-      if (hashOf(prevJson) === hashOf(value)) continue;
-      const B = blocks.get(id);
-      if (!B || !B.text || !node.isTextblock || !old.isTextblock) { writes.push({ id, value }); continue; }
-      const sp = spliceFrom({ c: prevJson.c, m: flatten(old.content).m }, { c: value.c, m: flatten(node.content).m }, ranges.get(id));
-      const w = { a: me, e: epochNow(), k: B.k, s: [sp ?? [0, 0, "", prevJson.c.length]], f: changedFields(prevJson, value) };
-      writes.push({ id, value: { ...value, w } });
-    }
-    if (!writes.length) return;
-    const mark = store.mark;
-    store.handle.update((d) => {
-      if (!d.blocks) d.blocks = {};
-      for (const x of writes) {
-        if (x.del) {
-          delete d.blocks[x.id];
-          if (d.deleted) d.deleted[x.id] = true;
-          else d.deleted = { [x.id]: true };
-        } else d.blocks[x.id] = x.value;
-      }
-    });
-    for (const x of writes) {
-      const B = ensure(x.id, null, x.value);
-      B.edited = true;
-      if (x.del) B.removedFrom = x.text;
-    }
-    sent(mark);
-    stats.writes++;
-    checkpointWithin(1500);
-  }
-
-  // The store ops made since mark: which block each is for, and the text
-  // writes the stream has not brought back yet.
-  function sent(mark) {
-    for (const e of store.pendingEntries()) {
-      if (e.id <= mark) continue;
-      const id = blockOf(e.op);
-      if (id === null) continue;
-      opBlock.set(e.id, id);
-      const B = blocks.get(id);
-      if (B && B.text && e.op.op === "set" && e.op.path.length === 2 && e.op.path[0] === "blocks") B.unechoed.push({ id: e.id, json: JSON.stringify(e.op.value), value: e.op.value, seq: null });
-    }
-  }
-
-  function send(B, value) {
-    const mark = store.mark;
-    if (value === null) store.handle.delete(["blocks", B.id]);
-    else store.handle.set(["blocks", B.id], value);
-    sent(mark);
-  }
-
-  // Blocks with a write in flight ("*": an op on the whole map holds them all).
-  function heldIds() {
-    const out = new Set();
-    for (const e of store.pendingEntries()) out.add(blockOf(e.op) ?? "*");
-    return out;
-  }
-
-  // ---- remote side ---------------------------------------------------------
-
-  store.onDelivery((ev) => {
-    if ((ev.phase === "landed" || ev.phase === "echoed") && Number.isInteger(ev.seq)) {
-      for (const B of blocks.values()) for (const u of B.unechoed) if (u.seq === null && u.id <= ev.through) u.seq = ev.seq;
-    }
-    if (ev.phase === "refused" || ev.phase === "undone") {
-      for (const [opId, id] of opBlock) if (opId <= ev.through) { const B = blocks.get(id); if (B) { B.refused = true; dirty.add(id); } }
-    }
-  });
-
-  function echoed(B, X) {
-    const json = JSON.stringify(X);
-    const i = B.unechoed.findIndex((u) => u.json === json);
-    if (i >= 0) B.unechoed.splice(0, i + 1);
-  }
-
-  function replayOps(ops, at, prev, next) {
-    for (const op of blockOps(ops, prev, next)) {
-      const B = ensure(op.id, prev, op.X);
-      dirty.add(op.id);
-      if (op.tombstone) {
-        if (B.text) tombstone(B.r, at);
-        else B.tomb = true;
-        continue;
-      }
-      if (!B.text) continue;
-      const X = op.X && Array.isArray(op.X.c) ? { ...blockJson(nodeFromBlock(schema, op.id, op.X)), ...(op.X.w ? { w: op.X.w } : {}) } : op.X;
-      if (X && X.w && X.w.a === me) echoed(B, X);
-      step(B.r, X, at);
-    }
-    advance(at);
-  }
-
-  // Every replay knows its block through the stream's seq, so a write's k (its
-  // release seq) means the same in every tab. A block with nothing left to
-  // release shows its value as of this seq too.
-  function advance(at) {
-    seq = Math.max(seq, at);
-    for (const B of blocks.values()) {
-      if (B.text) B.r.seq = Math.max(B.r.seq, at);
-      if (!dirty.has(B.id) && B.k !== null) B.k = Math.max(B.k, at);
-    }
-  }
-
-  store.onRebase(({ frame, room, prev, next }) => {
-    if (frame) {
-      replayOps(frame.ops, frame.seq, prev, next);
-      checkpointWithin(1500);
-    } else if (room && room.fresh) onEpoch(room, next);
-    else if (room && Array.isArray(room.moves)) {
-      for (const mv of room.moves) if (mv.seq > seq) replayOps(mv.ops, mv.seq, prev, next);
-    } else if (room) {
-      const ids = new Set([...blocks.keys(), ...Object.keys(next?.blocks ?? {})]);
-      for (const id of ids) {
-        const B = ensure(id, next);
-        dirty.add(id);
-        if (!B.text) { B.tomb = tombOf(next, id); continue; }
-        if (room.seq !== B.r.seq || !same(rawOf(next, id), B.r.S)) join(B.r, rawOf(next, id), room.seq, { tomb: tombOf(next, id) });
-        // Writes the joined value already holds never come back one by one.
-        B.unechoed = B.unechoed.filter((u) => u.seq === null || u.seq > room.seq);
-      }
-    }
-    if (room) advance(room.seq);
-    for (const B of blocks.values()) if (B.unechoed.length || B.refused) dirty.add(B.id);
-    for (const opId of opBlock.keys()) if (!store.pendingEntries().some((e) => e.id === opId)) opBlock.delete(opId);
-    queueMicrotask(releaseAll);
-    for (const fn of [...waiters]) fn();
-  });
-
-  // A room's state for an epoch this tab was not in: its first join, or a room
-  // restarted from the file after a loss. On a restart, every text block heals:
-  // its agreed value from the lost room, plus this tab's writes the stream never
-  // brought back, goes to the new room as one heal (replay.js).
-  function onEpoch(room, next) {
-    const now = lane.status.epoch;
-    const moves = (room.moves ?? []).flatMap((mv) => blockOps(mv.ops, null, next).map((op) => ({ seq: mv.seq, ...op })));
-    const first = epoch === null;
-    epoch = now;
-    seq = room.seq;
-    const pending = new Set(store.pendingEntries().map((e) => e.id));
-    const ids = new Set([...blocks.keys(), ...Object.keys(next?.blocks ?? {}), ...moves.map((mv) => mv.id)]);
-    for (const id of ids) {
-      const B = ensure(id, next, moves.find((mv) => mv.id === id)?.X);
-      dirty.add(id);
-      const mine = moves.filter((mv) => mv.id === id);
-      if (!B.text) {
-        B.tomb = tombOf(next, id);
-        continue;
-      }
-      const r = B.r;
-      const lost = B.unechoed;
-      B.unechoed = lost.filter((u) => pending.has(u.id));
-      const oldSeq = r.seq;
-      const chain = [], u = [];
-      if (!first) {
-        for (const x of lost) {
-          if (!x.value || !x.value.w || x.value.w.g !== undefined) continue;
-          step(r, x.value, r.seq);
-          for (const sp of r.log[r.log.length - 1].applied) { chain.push(sp.slice(0, 3).concat([sp[3]], sp[4] && sp[4].some(Boolean) ? [sp[4]] : [])); u.push(x.seq); }
-        }
-      }
-      const healed = first ? null : r.S;
-      join(r, rawOf(next, id), room.seq, { epoch: now, moves: room.moves ? mine : null, since: 0, tomb: tombOf(next, id) && !mine.some((mv) => mv.tombstone) });
-      B.k = null;
-      if (healed && !r.tomb && !same(healed, r.S)) {
-        stats.heals++;
-        const value = { ...strip(healed), w: { a: me, e: now, h: oldSeq, s: chain, u } };
-        queueMicrotask(() => send(B, value));
-      }
-    }
-  }
-
-  // Show every changed block whose writes have all landed, in one transaction.
-  function releaseAll() {
-    if (!view || composing || view.composing) return;
-    const held = heldIds();
-    if (held.has("*")) return;
-    const ids = [...dirty].filter((id) => !held.has(id));
-    if (!ids.length) return;
-    const tr = view.state.tr;
-    const sel = view.state.selection;
-    const at = (pos) => {
-      const $p = view.state.doc.resolve(pos);
-      if ($p.depth < 1) return null;
-      return { id: $p.node(1).attrs.id, off: pos - $p.start(1) };
-    };
-    const text = sel instanceof TextSelection;
-    const head = text ? at(sel.head) : null, anchor = text ? at(sel.anchor) : null;
-    const carets = new Map();
-    const order = [];
-    for (const id of ids) {
-      dirty.delete(id);
-      const B = blocks.get(id);
-      if (!B) continue;
-      const S = agreedOf(B);
-      const found = findBlock(tr.doc, id);
-      if (!S) {
-        if (found) remove(tr, B, found);
-      } else if (!found) order.push(B);
-      else {
-        if (B.text && found.node.isTextblock && isText(S.t)) {
-          const E = flatten(found.node.content);
-          if (B.refused) for (const g of regions(E.c, S.c)) if (g.to > g.from && E.c.slice(g.from, g.to).trim()) notice({ kind: "refused", id, lost: E.c.slice(g.from, g.to) });
-          const k = B.k;
-          carets.set(id, (off) => mapCaret(B.r, me, k, off, E.c));
-          textSteps(tr, B, found, E, S);
-        } else if (hashOf(blockJson(found.node)) !== hashOf(S)) tr.replaceWith(found.pos, found.pos + found.node.nodeSize, nodeFromBlock(schema, id, S));
-        order.push(B);
-      }
-      B.k = B.text ? B.r.seq : seq;
-      B.refused = false;
-      stats.releases++;
-    }
-    for (const B of order) place(tr, B);
-    if (tr.docChanged) {
-      const placeCaret = (x) => {
-        if (!x || !x.id) return null;
-        const f = findBlock(tr.doc, x.id);
-        if (!f) return null;
-        const off = carets.has(x.id) ? carets.get(x.id)(x.off) : x.off;
-        return f.pos + 1 + Math.max(0, Math.min(off, f.node.content.size));
-      };
-      const h = placeCaret(head), a = placeCaret(anchor);
-      if (h !== null && a !== null) tr.setSelection(TextSelection.create(tr.doc, a, h));
-      tr.setMeta(REMOTE, true).setMeta("addToHistory", false).setMeta("rebased", 0);
-      view.dispatch(tr);
-    }
-    for (const id of ids) if (blocks.has(id)) settle(blocks.get(id));
-  }
-
-  // A block a peer deleted leaves the editor. This tab's text in it is kept in
-  // a notice, unless the replay already has one for this tab's writes there.
-  function remove(tr, B, found) {
-    const text = found.node.textContent;
-    const noted = B.r && B.r.conflicts.some((n) => n.kind === "removed" && n.by === me);
-    if (B.edited && !noted && text.trim() && text !== B.removedFrom) notice({ kind: "removed", id: B.id, lost: text, by: me, block: blockJson(found.node) });
-    if (tr.doc.childCount === 1) tr.replaceWith(found.pos, found.pos + found.node.nodeSize, schema.nodes.paragraph.create());
-    else tr.delete(found.pos, found.pos + found.node.nodeSize);
-  }
-
-  // The editor's block E becomes S: text by a diff, then marks where the text
-  // did not change, then the node's type and attrs.
-  function textSteps(tr, B, found, E, S) {
-    const start = found.pos + 1;
-    const type = found.node.type;
-    let delta = 0;
-    const gs = regions(E.c, S.c).map((g) => { const s = g.from + delta; delta += g.t.length - (g.to - g.from); return { ...g, s }; });
-    for (const g of gs.reverse()) {
-      const nodes = g.t ? unflatten(schema, g.t, (S.m ?? []).slice(g.s, g.s + g.t.length), type) : [];
-      if (g.to > g.from) tr.replaceWith(start + g.from, start + g.to, nodes);
-      else if (nodes.length) tr.insert(start + g.from, nodes);
-    }
-    const now = flatten(tr.doc.nodeAt(found.pos).content);
-    for (let i = 0; i < S.c.length;) {
-      if (keyAt(now.m, i) === keyAt(S.m, i)) { i++; continue; }
-      let j = i + 1;
-      while (j < S.c.length && keyAt(now.m, j) !== keyAt(S.m, j) && keyAt(S.m, j) === keyAt(S.m, i)) j++;
-      if (keyAt(S.m, i)[0] === "@" || keyAt(now.m, i)[0] === "@") tr.replaceWith(start + i, start + j, unflatten(schema, S.c.slice(i, j), (S.m ?? []).slice(i, j), type));
-      else {
-        tr.removeMark(start + i, start + j, null);
-        for (const mark of marksOf(schema, keyAt(S.m, i))) if (type.allowsMarkType(mark.type)) tr.addMark(start + i, start + j, mark);
-      }
-      i = j;
-    }
-    const target = schema.nodes[S.t];
-    const node = tr.doc.nodeAt(found.pos);
-    const attrs = {};
-    for (const [name, spec] of Object.entries(target.spec.attrs ?? {})) attrs[name] = name === "id" ? B.id : name in S ? S[name] : spec.default ?? null;
-    if (target !== node.type || JSON.stringify(attrs) !== JSON.stringify(node.attrs)) {
-      if (target.validContent(node.content)) tr.setNodeMarkup(found.pos, target, attrs);
-      else tr.replaceWith(found.pos, found.pos + node.nodeSize, nodeFromBlock(schema, B.id, S));
-    }
-  }
-
-  // Put block B where its (pos, id) says, inserting it when the editor has none.
-  function place(tr, B) {
-    const S = agreedOf(B);
-    if (!S) return;
-    const key = orderKey(S.pos, B.id);
-    let found = findBlock(tr.doc, B.id);
-    if (found) {
-      const prev = found.index > 0 ? tr.doc.child(found.index - 1) : null;
-      const next = found.index + 1 < tr.doc.childCount ? tr.doc.child(found.index + 1) : null;
-      const ok = (!prev || !prev.attrs.id || before(orderKey(prev.attrs.pos, prev.attrs.id), key)) && (!next || !next.attrs.id || before(key, orderKey(next.attrs.pos, next.attrs.id)));
-      if (ok) return;
-      tr.delete(found.pos, found.pos + found.node.nodeSize);
-    }
-    const node = found ? found.node : nodeFromBlock(schema, B.id, S);
-    let at = tr.doc.content.size;
-    let set = false;
-    tr.doc.forEach((child, offset) => {
-      if (set || !child.attrs.id) return;
-      if (before(key, orderKey(child.attrs.pos, child.attrs.id))) { at = offset; set = true; }
-    });
-    tr.insert(at, node);
-    // The empty block a page keeps when every block was deleted goes once one comes back.
-    const empty = [];
-    tr.doc.forEach((child, offset) => { if (!child.attrs.id && child.content.size === 0) empty.push(offset); });
-    if (tr.doc.childCount > empty.length) for (const offset of empty.reverse()) tr.delete(offset, offset + tr.doc.nodeAt(offset).nodeSize);
-  }
-
-  function notice(n) {
-    own.push(n);
-    onNotice(n);
-  }
-
-  // ---- repair, follow ------------------------------------------------------
-
-  // The writer repairs the room's value after a short quiet spell. A tab that
-  // refused a repair it could not place follows the room after a long one, and
-  // so does one that sees a block under its tombstone: every tab agrees it is
-  // gone, so any tab may delete it again.
-  function settle(B) {
-    clearTimer(B.timer);
-    B.timer = null;
-    const raw = rawOf(store.authoritative, B.id);
-    const S = agreedOf(B);
-    if (same(raw, S)) { if (B.r) B.r.behind = false; return; }
-    const writer = lane.isWriter();
-    const tomb = B.text ? B.r.tomb : B.tomb;
-    if (!writer && !(B.r && B.r.behind) && !tomb) return;
-    B.timer = setTimer(() => (lane.isWriter() ? repair(B) : follow(B)), writer ? quiet : quiet * 4);
-  }
-
-  function repair(B) {
-    if (heldIds().has(B.id) || composing || dirty.has(B.id)) return;
-    const raw = rawOf(store.authoritative, B.id);
-    const S = agreedOf(B);
-    if (same(raw, S)) return;
-    stats.repairs++;
-    if (!S) send(B, null);
-    else if (B.text) send(B, { ...S, w: { a: me, e: epochNow(), g: B.r.seq } });
-  }
-
-  function follow(B) {
-    if (heldIds().has(B.id) || composing) return;
-    const tomb = B.text ? B.r.tomb : B.tomb;
-    if (tomb && rawOf(store.authoritative, B.id)) { stats.repairs++; send(B, null); return; }
-    if (!B.text || !B.r.behind) return;
-    stats.follows++;
-    join(B.r, rawOf(store.authoritative, B.id), B.r.seq, { tomb: tombOf(store.authoritative, B.id) });
-    dirty.add(B.id);
-    releaseAll();
-  }
-
-  // ---- pending and flush ---------------------------------------------------
-
-  // Resolves { ok: true } once every write this tab has made landed and, with
-  // requestCheckpoint, once the file holds it.
-  function flush({ timeoutMs = 10_000 } = {}) {
-    return new Promise((resolve) => {
-      let timer = null;
-      const check = () => {
-        if (store.pending.length) return;
-        waiters.delete(check);
-        clearTimer(timer);
-        resolve(requestCheckpoint ? requestCheckpoint({ timeoutMs }) : { ok: true });
-      };
-      timer = setTimer(() => { waiters.delete(check); resolve({ ok: false, code: "timeout" }); }, timeoutMs);
-      waiters.add(check);
-      check();
-    });
-  }
-  const unsaved = registerUnsavedState({ id: "page:live", isPending: () => store.pending.length > 0, flush });
-  const unsavedHeld = registerUnsavedState({ id: "page:held", isPending: () => composing });
-
-  return {
-    plugin,
-    stats,
-    blocks,
-    dispatch,
-    flush,
-    doc: () => docFromRecord(schema, store.value),
-    attach(v) { view = v; },
-    writerChanged() {
-      queueMicrotask(() => {
-        releaseAll();
-        for (const B of blocks.values()) settle(B);
-      });
-    },
-    // Every notice, as data: the replays' (inexact, merge, removed, repair,
-    // heal, joined, replaced) and this binding's (removed, refused).
-    // A block's writes under its tombstone come as one notice per author: its
-    // latest write, which holds the text of the ones before.
-    notices() {
-      const out = [];
-      for (const B of blocks.values()) {
-        if (!B.r) continue;
-        const last = new Map();
-        for (const n of B.r.conflicts) if (n.kind === "removed") last.set(n.by, n);
-        for (const n of B.r.conflicts) if (n.kind !== "removed" || last.get(n.by) === n) out.push({ ...n, id: B.id });
-      }
-      return [...out, ...own];
-    },
-    dispose() {
-      unsaved.dispose();
-      unsavedHeld.dispose();
-      for (const B of blocks.values()) clearTimer(B.timer);
-      view = null;
-    },
-  };
-}