edytor 0.1.0-next.21 → 0.1.0-next.23

package/dist/crdt/text/runs.js

@@ -1,7 +1,8 @@
-import { candidatesOf, childrenIndex, displayIndex, documentOrder, REGISTRY_KEY, resolvePlacements } from '../placement/model.js';
-import { bindText, canonKey, claimGraph, DEAD, deepFreeze, delimiters, displayOf, placeText, protectItems, readClaims, scanText } from './model.js';
+import { candidatesOf, bySlot, childrenIndex, displayIndex, displaySlotOf, documentOrder, REGISTRY_KEY, resolvePlacements } from '../placement/model.js';
+import { bindText, byId, canonKey, claimGraph, cmpStamp, DEAD, deepFreeze, delimiters, displayOf, isBoundary, placeText, protectItems, readClaims, scanText } from './model.js';
+import { gapOfItem, headOf, placeRow, rowLength, rowOf, sameRow, segmentAt, segmentOfCut, segmentOfGap, shiftGap, streamOfSegment } from './rows.js';
 import { AT, CLAIMS, CONTENT, DATA, DATA_LEAF_PREFIX, DOC_DATA_ROOT, hasDeleteMark, hasWithdrawMark, ID, isNodeLike, LAST_CHANGED_ATTR, NONCE, TYPE } from '../schema.js';
-import { walkIdSetStructs } from '../structs.js';
+import { queuedTransactions, walkIdSetRanges, walkIdSetStructs } from '../structs.js';
 import { cloneJsonSafe, sameIds } from '../../utils/json.js';
 import { readData } from '../data.js';
 import { callEach } from '../protocols/observable.js';
@@ -70,6 +71,15 @@ const sameShape = (roles, a, b) => {
 };
 /** One index per engine doc, shared by every binding (the doc's lifetime). */
 const indexes = new WeakMap();
+/**
+ * Test lanes turn this on (`globalThis.__EDYTOR_INDEX_CHECKS__`, set before
+ * the index loads): after every fold the index checks each fact it keeps
+ * incrementally against a rebuild from the replicated state and throws on
+ * the first difference. Off in production.
+ */
+export const indexChecks = {
+    on: globalThis.__EDYTOR_INDEX_CHECKS__ === true
+};
 export const bindRuns = (Y) => {
     const T = bindText(Y);
     /** The doc's index — built on first use, torn down when the doc is destroyed. */
@@ -85,38 +95,54 @@ export const bindRuns = (Y) => {
         const dataRoot = doc.get(DOC_DATA_ROOT);
         const docData = () => cloneJsonSafe(readData(dataRoot) ?? {});
         let dataChanged = false;
-        const makeExtentIndex = (tr) => {
+        const NO_EDITS = Object.freeze({
+            edits: [],
+            scan: false,
+            opaque: false
+        });
+        const holdsBoundary = (s, from, to) => {
+            const arr = s.content?.arr;
+            if (arr === undefined)
+                return false;
+            for (let k = from - s.id.clock; k < to - s.id.clock; k++)
+                if (isBoundary(arr[k]))
+                    return true;
+            return false;
+        };
+        /** The edits the id sets `ins`/`del` (what the fold has not folded yet) hold, per text. */
+        const makeEditIndex = (ins, del) => {
             let built;
             const build = () => {
                 if (built !== undefined)
                     return built;
-                const tx = tr;
-                if (tx?.insertSet === undefined || tx.deleteSet === undefined)
+                if (ins === undefined || del === undefined)
                     return (built = null);
                 const out = new Map();
-                const visit = (idSet, deleted) => walkIdSetStructs(Y, doc, idSet, (s) => {
+                const visit = (idSet, deleted) => walkIdSetRanges(Y, doc, idSet, (s, from, to) => {
                     const parent = s.parent;
                     if (s.parentSub !== null || !isNodeLike(parent))
                         return;
-                    const typeId = parent._item?.id;
-                    const abs = deleted || s.countable !== true || typeId === undefined
-                        ? null
-                        : Y.createAbsolutePositionFromRelativePosition(Y.createRelativePositionFromJSON({
-                            type: { client: typeId.client, clock: typeId.clock },
-                            item: { client: s.id.client, clock: s.id.clock },
-                            assoc: 0
-                        }), doc, false);
-                    const spans = out.get(parent);
-                    if (abs === null)
-                        out.set(parent, null);
-                    else if (spans !== null) {
-                        out.set(parent, [...(spans ?? []), [abs.index, abs.index + s.length]]);
-                    }
+                    let e = out.get(parent);
+                    if (e === undefined)
+                        out.set(parent, (e = { edits: [], scan: false, opaque: false }));
+                    // A format marker moves no unit; its effect reaches past the edit.
+                    if (s.countable !== true)
+                        return void (e.opaque = true);
+                    // Written and removed within the fold: nothing moved.
+                    if (deleted ? ins.has(s.id.client, from) : s.deleted)
+                        return;
+                    if (holdsBoundary(s, from, to))
+                        return void (e.scan = true);
+                    e.edits.push({ item: s, len: to - from, del: deleted });
                 });
-                built = visit(tx.insertSet, false) && visit(tx.deleteSet, true) ? out : null;
+                built = visit(ins, false) && visit(del, true) ? out : null;
                 return built;
             };
-            return (node) => build()?.get(node) ?? undefined;
+            /** `node`'s edits (`null`: unknown — rescan, every consumer recomputes). */
+            return (node) => {
+                const map = build();
+                return map === null ? null : (map.get(node) ?? NO_EDITS);
+            };
         };
         // ── the replicated-state index ──────────────────────────────────
         const blocks = new Map();
@@ -127,78 +153,349 @@ export const bindRuns = (Y) => {
         /** Forward dependencies of cached runs: backing text (by home) / walked block → consumers. */
         const textConsumers = new Map();
         const listConsumers = new Map();
-        // ── the claim graph (lazy, per structure version) ─────────────────
-        let owners = new Map();
-        let tops = new Map();
-        /** `-1` forces the first build (structureVersion starts at 0). */
-        let ownersVersion = -1;
-        let structureVersion = 0;
+        // ── the claim graph (P3: maintained) ─────────────────────────────
+        // `top(m)` is the max-stamp claim on `m` held by a live block; each
+        // block's owner follows `top` up (`claimGraph`). A structural change
+        // of a block (its claims, its delete mark, its record) re-decides the
+        // `top` of the blocks it claims (before and after) and the owners of
+        // those blocks and of every block whose `top` chain reaches them —
+        // never the whole graph.
+        const owners = new Map();
+        const topOf = new Map();
+        /** Claimer → the blocks it tops. */
+        const topInv = new Map();
+        /** Claimed block → the blocks whose claims list names it (live or not). */
+        const claimersOf = new Map();
+        /** Owner → the blocks it displays (itself included while it owns itself). */
+        const displaysMap = new Map();
+        /** Blocks whose claims, delete mark or record changed since the last owner pass. */
+        const ownerSeeds = new Set();
+        /** Blocks whose owner changed since the last placement pass. */
+        const ownerChanged = new Set();
+        let ownersBuilt = false;
+        const addTo = (index, key, value) => {
+            let set = index.get(key);
+            if (set === undefined)
+                index.set(key, (set = new Set()));
+            set.add(value);
+        };
+        const dropFrom = (index, key, value) => {
+            const set = index.get(key);
+            set?.delete(value);
+            if (set?.size === 0)
+                index.delete(key);
+        };
+        /** The max-stamp claim on `m` held by a live block. */
+        const topClaim = (m) => {
+            let best;
+            for (const holder of claimersOf.get(m) ?? []) {
+                const rec = blocks.get(holder);
+                if (rec === undefined || rec.deleted)
+                    continue;
+                for (const c of rec.claims)
+                    if (c.m === m && (best === undefined || cmpStamp(c.stamp, best.stamp) > 0))
+                        best = { claimer: holder, stamp: c.stamp };
+            }
+            return best;
+        };
+        const setTop = (m, t) => {
+            const old = topOf.get(m);
+            if (old?.claimer === t?.claimer && (old === undefined || cmpStamp(old.stamp, t.stamp) === 0))
+                return false;
+            if (old !== undefined)
+                dropFrom(topInv, old.claimer, m);
+            if (t === undefined)
+                topOf.delete(m);
+            else {
+                topOf.set(m, t);
+                addTo(topInv, t.claimer, m);
+            }
+            return true;
+        };
+        /** `owner(b)` along `top` (`claimGraph`'s walk), memoized into `owners`. */
+        const walkOwner = (b) => {
+            const path = [];
+            let cur = b;
+            let result;
+            for (;;) {
+                const known = owners.get(cur);
+                if (known !== undefined) {
+                    result = known;
+                    break;
+                }
+                const rec = blocks.get(cur);
+                if (!rec || rec.deleted) {
+                    result = DEAD;
+                    break;
+                }
+                const at = path.indexOf(cur);
+                if (at >= 0) {
+                    let best = topOf.get(path[at]);
+                    for (const member of path.slice(at)) {
+                        const t = topOf.get(member);
+                        if (cmpStamp(t.stamp, best.stamp) > 0)
+                            best = t;
+                    }
+                    result = best.claimer;
+                    break;
+                }
+                const t = topOf.get(cur);
+                if (t === undefined) {
+                    result = cur;
+                    break;
+                }
+                path.push(cur);
+                cur = t.claimer;
+            }
+            if (blocks.has(cur))
+                owners.set(cur, result);
+            for (const x of path)
+                owners.set(x, result);
+        };
+        const setDisplay = (b, from, to) => {
+            if (typeof from === 'string')
+                dropFrom(displaysMap, from, b);
+            if (typeof to === 'string')
+                addTo(displaysMap, to, b);
+        };
         const ensureOwners = () => {
-            if (ownersVersion >= structureVersion)
+            if (!ownersBuilt) {
+                ownersBuilt = true;
+                ownerSeeds.clear();
+                const graph = claimGraph(blocks);
+                owners.clear();
+                for (const [b, o] of graph.owners)
+                    if (blocks.has(b))
+                        owners.set(b, o);
+                topOf.clear();
+                topInv.clear();
+                claimersOf.clear();
+                for (const [holder, rec] of blocks)
+                    for (const c of rec.claims)
+                        addTo(claimersOf, c.m, holder);
+                for (const m of claimersOf.keys())
+                    setTop(m, topClaim(m));
+                displaysMap.clear();
+                for (const b of blocks.keys())
+                    setDisplay(b, undefined, owners.get(b));
+                return;
+            }
+            if (ownerSeeds.size === 0)
                 return;
-            ({ owners, top: tops } = claimGraph(blocks));
-            ownersVersion = structureVersion;
+            // The tops a seed's claims (now, and those it dropped: noted in `claimersOf` changes) decide.
+            const affected = new Set();
+            const stack = [];
+            for (const x of ownerSeeds) {
+                stack.push(x);
+                for (const m of claimTargets.get(x) ?? [])
+                    if (setTop(m, topClaim(m)))
+                        stack.push(m);
+                for (const c of blocks.get(x)?.claims ?? [])
+                    if (setTop(c.m, topClaim(c.m)))
+                        stack.push(c.m);
+            }
+            ownerSeeds.clear();
+            claimTargets.clear();
+            for (let x = stack.pop(); x !== undefined; x = stack.pop()) {
+                if (affected.has(x))
+                    continue;
+                affected.add(x);
+                for (const m of topInv.get(x) ?? [])
+                    stack.push(m);
+            }
+            const before = new Map();
+            for (const x of affected) {
+                before.set(x, owners.get(x));
+                owners.delete(x);
+            }
+            for (const x of affected)
+                if (blocks.has(x))
+                    walkOwner(x);
+            for (const [x, was] of before) {
+                const now = owners.get(x);
+                if (now === was)
+                    continue;
+                setDisplay(x, was, now);
+                ownerChanged.add(x);
+            }
         };
+        /** The claims each seed held before its record changed (their tops are re-decided too). */
+        const claimTargets = new Map();
         const ownerOf = (b) => {
             ensureOwners();
             return owners.get(b) ?? DEAD;
         };
-        // ── the stream table (R2) ────────────────────────────────────────
-        // One scanned row per backing text (keyed by its home block), the
-        // delimiting boundary of each block, and the streams per text. A
-        // text's rows are rescanned when the fold sees it edited; the table
-        // is rebuilt only when a boundary set, a nonce or a registry entry
-        // changed — otherwise only the edited text's stream offsets move.
+        // ── the stream table (R2, P1) ────────────────────────────────────
+        // One maintained row per backing text (keyed by its home block): its
+        // live boundaries and the units between them (`text/rows.ts`), the
+        // delimiting boundary of each block, and each block's segment. An edit
+        // that writes or removes no boundary moves its row by its units
+        // (`shiftGap`); a row is rescanned only when its boundary set (or its
+        // text) changed, and only the delimiters of the blocks its boundaries
+        // name are re-decided, so only the rows those delimiters cut re-place.
         const rows = new Map();
         let delim = new Map();
-        const streams = new Map();
-        const inText = new Map();
-        /** A stream's identity (text and delimiting boundary) — what a rebuild compares. */
-        const streamKey = (b) => {
-            const s = streams.get(b);
-            return s && `${s.home}|${delim.get(b) ?? ''}`;
-        };
-        const place = (home) => {
-            for (const s of inText.get(home) ?? [])
-                if (streams.get(s.block) === s)
-                    streams.delete(s.block);
+        /** Every live boundary naming a block, by block: key → its row and nonce. */
+        const boundsBy = new Map();
+        /** Each block's segment: its row and the cut that opens it (`null`: the row's segment 0). */
+        const streamIx = new Map();
+        const placed = new Map();
+        const streamOf = (b) => {
+            const at = streamIx.get(b);
+            const row = at && rows.get(at.home);
+            if (row === undefined)
+                return undefined;
+            const k = segmentOfCut(row, at.cut);
+            return k < 0 ? undefined : streamOfSegment(row, k, b);
+        };
+        const streamsIn = (home) => {
             const row = rows.get(home);
-            const list = row === undefined ? [] : placeText(row, delim);
-            if (list.length === 0)
-                inText.delete(home);
-            else
-                inText.set(home, list);
-            for (const s of list)
-                streams.set(s.block, s);
+            const out = [];
+            for (let k = 0; row !== undefined && k <= row.cuts.length; k++) {
+                const b = headOf(row, k);
+                if (b !== null)
+                    out.push(streamOfSegment(row, k, b));
+            }
+            return out;
+        };
+        const streamAt = (home, i) => {
+            const row = rows.get(home);
+            if (row === undefined)
+                return undefined;
+            const k = segmentAt(row, i);
+            const b = headOf(row, k);
+            if (b === null)
+                return undefined;
+            const st = streamOfSegment(row, k, b);
+            return st.start <= i && i <= st.end ? st : undefined;
         };
-        /** Rescan `home`'s text; `true` when its boundary set (or the text itself) changed. */
-        const rescan = (home) => {
+        /** Record `home`'s new row (or none); the blocks its boundary set change names join `named`. */
+        const setRow = (home, row, named) => {
             const old = rows.get(home);
-            const text = blocks.get(home)?.content;
-            if (text === undefined) {
+            if (row === undefined)
                 rows.delete(home);
-                return old !== undefined;
+            else
+                rows.set(home, row);
+            if (old?.key === row?.key)
+                return;
+            for (const b of old?.bounds ?? []) {
+                if (row?.keyIndex.has(b.key))
+                    continue;
+                const by = boundsBy.get(b.s);
+                by?.delete(b.key);
+                if (by?.size === 0)
+                    boundsBy.delete(b.s);
+                named.add(b.s);
+            }
+            for (const b of row?.bounds ?? []) {
+                if (old?.keyIndex.has(b.key))
+                    continue;
+                let by = boundsBy.get(b.s);
+                if (by === undefined)
+                    boundsBy.set(b.s, (by = new Map()));
+                by.set(b.key, { home, n: b.n });
+                named.add(b.s);
             }
-            const row = scanText(home, text);
-            rows.set(home, row);
-            return old === undefined || old.text !== text || old.key !== row.key;
         };
-        /** Rebuild delimiters and every stream; invalidate the blocks whose stream changed. */
-        const rebuildTable = (invalidated) => {
-            const before = new Map([...streams.keys()].map((b) => [b, streamKey(b)]));
-            delim = delimiters(blocks, rows.values());
-            streams.clear();
-            inText.clear();
-            for (const home of rows.keys())
-                place(home);
-            for (const b of new Set([...before.keys(), ...streams.keys()])) {
-                if (before.get(b) === streamKey(b))
+        /** A fresh row of `home`'s text (none without one). */
+        const scanRow = (home) => {
+            const text = blocks.get(home)?.content;
+            return text === undefined ? undefined : rowOf(scanText(home, text));
+        };
+        /** Re-decide the delimiting boundary of each block in `named`; the rows a change cuts join `homes`. */
+        const refreshDelims = (named, homes) => {
+            for (const s of named) {
+                const n = blocks.get(s)?.n;
+                let best;
+                if (blocks.has(s))
+                    for (const [key, b] of boundsBy.get(s) ?? [])
+                        if (b.n === n && (best === undefined || byId(key, best) < 0))
+                            best = key;
+                const old = delim.get(s);
+                if (old === best)
                     continue;
-                invalidated.add(b);
-                for (const c of listConsumers.get(b) ?? [])
+                if (best === undefined)
+                    delim.delete(s);
+                else
+                    delim.set(s, best);
+                const was = old === undefined ? undefined : boundsBy.get(s)?.get(old)?.home;
+                if (was !== undefined)
+                    homes.add(was);
+                if (best !== undefined)
+                    homes.add(boundsBy.get(s).get(best).home);
+                if (rows.has(s) || placed.has(s))
+                    homes.add(s);
+            }
+        };
+        /**
+         * Place `home`'s row; invalidate the blocks whose segment changed (or
+         * appeared, or went). A segment is its two delimiting cuts, so only the
+         * segments between the longest common prefix and suffix of the old and
+         * new cut lists can differ: the others keep their entries untouched.
+         */
+        const placeHome = (home, invalidated) => {
+            const row = rows.get(home);
+            const before = placed.get(home) ?? { head: null, keys: [], blocks: [] };
+            const now = { head: null, keys: [], blocks: [] };
+            if (row !== undefined) {
+                placeRow(row, delim);
+                now.head = row.head;
+                for (const j of row.cuts) {
+                    now.keys.push(row.bounds[j].key);
+                    now.blocks.push(row.bounds[j].s);
+                }
+            }
+            if (row === undefined)
+                placed.delete(home);
+            else
+                placed.set(home, now);
+            const [a, b] = [before.keys, now.keys];
+            let p = 0;
+            while (p < a.length && p < b.length && a[p] === b[p])
+                p++;
+            let q = 0;
+            while (q < a.length - p && q < b.length - p && a[a.length - 1 - q] === b[b.length - 1 - q])
+                q++;
+            // Segment k ends at cut k: it changed iff k lies in [p, n - q] (segment 0 also with its block).
+            const from = before.head === now.head ? p : 0;
+            const changed = (blk) => {
+                if (blk === null)
+                    return;
+                invalidated.add(blk);
+                for (const c of listConsumers.get(blk) ?? [])
                     invalidated.add(c);
+            };
+            const blockOf = (x, k) => (k === 0 ? x.head : x.blocks[k - 1]);
+            for (let k = from; k <= a.length - q; k++) {
+                const blk = blockOf(before, k);
+                if (blk !== null && streamIx.get(blk)?.home === home)
+                    streamIx.delete(blk);
+                changed(blk);
+            }
+            for (let k = from; k <= b.length - q; k++) {
+                const blk = blockOf(now, k);
+                if (blk === null)
+                    continue;
+                streamIx.set(blk, { home, cut: k === 0 ? null : b[k - 1] });
+                changed(blk);
             }
         };
+        /** Rebuild the delimiters and every row's segments (the first build). */
+        const rebuildTable = (invalidated) => {
+            boundsBy.clear();
+            for (const [home, row] of rows)
+                for (const b of row.bounds) {
+                    let by = boundsBy.get(b.s);
+                    if (by === undefined)
+                        boundsBy.set(b.s, (by = new Map()));
+                    by.set(b.key, { home, n: b.n });
+                }
+            delim = new Map();
+            const homes = new Set([...rows.keys(), ...placed.keys()]);
+            refreshDelims(boundsBy.keys(), homes);
+            for (const home of homes)
+                placeHome(home, invalidated);
+        };
         /** The role table the display reads; `null` → none. */
         let roles = null;
         /** A stored kind changed since the last report: derived kinds may follow it (XW-08). */
@@ -228,31 +525,43 @@ export const bindRuns = (Y) => {
             },
             top: (m) => {
                 ensureOwners();
-                return tops.get(m);
+                return topOf.get(m)?.claimer;
             },
-            streamOf: (b) => streams.get(b),
-            streamsIn: (home) => inText.get(home) ?? [],
+            streamOf,
+            streamsIn,
+            streamAt,
             display: (b) => displayOf(b, blocks, ownShim)
         };
-        /** Owner → displayed blocks, rebuilt lazily with `owners` (the delete step's marks). */
-        let displaysMap = new Map();
-        let displaysAt = -1;
+        /** The blocks `owner` displays (the delete step's marks). */
         const displays = (owner) => {
             ensureOwners();
-            if (displaysAt !== ownersVersion) {
-                displaysMap = displayIndex(blocks, ownerOf);
-                displaysAt = ownersVersion;
-            }
-            return displaysMap.get(owner) ?? [];
-        };
-        // ── lazily-maintained placement / children-index facets ───────────
-        // They rebuild only on `at` writes, delete marks, claim churn (the
-        // display edge is `owner(parent)`) and registry entry churn; a
-        // keystroke keeps the resolved placements and children index verbatim.
-        let placementsMap = null;
-        let kidsMap = null;
-        /** Each visible block's display parent, and the island it displays out of (`reset`). */
-        let slots = new Map();
+            return [...(displaysMap.get(owner) ?? [])];
+        };
+        // ── placements and the children index (P3: maintained) ────────────
+        // A structural change re-decides only what it can change: the winning
+        // placement of the blocks whose candidates (or whose parent's
+        // registry entry) changed, and the display slot of every block whose
+        // slot walk (`displaySlotOf`) reads one that changed — its stored
+        // subtree, through the blocks it displays — patched into the parents'
+        // child lists. While every block shows its winning candidate (no
+        // cycle rejected, none rehomed), a block's placement is its argmax
+        // (`resolvePlacements` accepts it), so only a cycle through a changed
+        // display edge needs the global resolution, which then runs whole.
+        // The layout rules re-run only on the layouts a change reaches.
+        /** Resolved placements. */
+        const placementsMap = new Map();
+        /** Resolved parent → the blocks placed under it. */
+        const kidsOf = new Map();
+        /** A block's argmax candidate parent → the blocks naming it (its entry decides theirs). */
+        const byArgParent = new Map();
+        /** The children index without the layout rules (what they read), and with them. */
+        let kids0 = new Map();
+        let slots0 = new Map();
+        let kidsMap = kids0;
+        /** Each visible block's slot (display parent, rank, the island it displays out of). */
+        let slots = slots0;
+        /** The document holds a layout or an item kind: `kids0` and `kidsMap` differ. */
+        let layoutMode = false;
         /** The line kinds the roles declare, and those of the lines islands the document holds. */
         let lineKinds = new Set();
         /**
@@ -260,106 +569,427 @@ export const bindRuns = (Y) => {
          * an island, then in a lined island or of a line kind — which the
          * report re-reads after a retype.
          */
-        let following = [];
+        const following = new Set();
         let orderCache = null;
-        let placementsBuiltAt = -1;
-        let placementVersion = 0;
-        /**
-         * The layout rules over a children index (`layout.*`): the live blocks
-         * they do not display, found in one post-order pass. A layout shows
-         * only its items (`layout.only-items`, already in the index: the
-         * layout sheds the others, `own.sheds`); an item that shows no child,
-         * or shows outside a layout, does not display and hands its children
-         * its slot (`layout.empty-item`, `layout.bare-item`); a layout showing
-         * one item or none does not display, nor does that item
-         * (`layout.single`). Each decision reads the children a node shows
-         * once its own children's were made, so one pass is the fixpoint:
-         * what a dissolve hands up is never an item (an item shows only in a
-         * layout, and a dissolving layout hands up its item's children).
-         */
-        const dissolve = (kids, items) => {
-            const out = new Set();
-            const isItem = (b) => items.has(blocks.get(b)?.type ?? '');
-            const visit = (parent, layout) => {
-                const shown = [];
-                for (const { id } of kids.get(parent) ?? []) {
-                    const own = itemKind(id) !== undefined;
-                    const sub = visit(id, own);
-                    if (own) {
-                        if (sub.length > 1)
-                            shown.push({ id, kids: [] });
-                        else {
-                            out.add(id);
-                            for (const k of sub) {
-                                out.add(k.id);
-                                shown.push(...k.kids.map((kid) => ({ id: kid, kids: [] })));
-                            }
-                        }
-                    }
-                    else if (isItem(id) && (!layout || sub.length === 0)) {
+        /** Bumps whenever a child list changes (the report compares it). */
+        let kidsVersion = 0;
+        /** The child lists patched since the last report (`all`: every list was rebuilt). */
+        const dirtyLists = new Set();
+        /** The blocks that left every list since the last report. */
+        const leftLists = new Set();
+        let allListsDirty = true;
+        /** The next pass rebuilds everything (first build, roles, an irregular state). */
+        let placementFull = true;
+        /** Some block shows no argmax candidate (a cycle rejected one, or none): passes run whole. */
+        let irregular = false;
+        /** Blocks whose candidates or record changed, whose display state changed. */
+        const placementSeeds = new Set();
+        const stateSeeds = new Set();
+        /** Per block: whether its kind is a layout, an item, a lines island (with its line kind). */
+        const kindsOf = new Map();
+        let layoutBlocks = 0;
+        let itemBlocks = 0;
+        const lineCounts = new Map();
+        /** The item kinds the roles declare. */
+        const declaredItems = () => {
+            const items = new Set();
+            for (const type of roles?.layoutKinds() ?? [])
+                items.add(roles.layout(type));
+            return items;
+        };
+        let itemKinds = new Set();
+        /** Re-count `id`'s kind facts; a fact the roles never declared forces a full pass. */
+        const noteKind = (id) => {
+            const old = kindsOf.get(id);
+            const type = blocks.get(id)?.type;
+            const now = type === undefined
+                ? undefined
+                : { layout: itemKind(id) !== undefined, item: itemKinds.has(type), line: lineKind(id) };
+            if (old?.layout)
+                layoutBlocks--;
+            if (old?.item)
+                itemBlocks--;
+            if (old?.line !== undefined)
+                lineCounts.set(old.line, lineCounts.get(old.line) - 1);
+            if (now === undefined)
+                kindsOf.delete(id);
+            else
+                kindsOf.set(id, now);
+            if (now?.layout)
+                layoutBlocks++;
+            if (now?.item)
+                itemBlocks++;
+            if (now?.line !== undefined)
+                lineCounts.set(now.line, (lineCounts.get(now.line) ?? 0) + 1);
+            const item = itemKind(id);
+            if (item !== undefined && !itemKinds.has(item))
+                placementFull = true;
+            if (now?.line !== undefined && !lineKinds.has(now.line))
+                placementFull = true;
+            if (layoutMode !== layoutBlocks + itemBlocks > 0)
+                placementFull = true;
+        };
+        /** The argmax candidate's parent (a registry entry or the root), and its index entry. */
+        const argParent = (rec) => rec?.cands[0]?.p;
+        const noteCands = (id, before) => {
+            const after = argParent(blocks.get(id));
+            if (before === after)
+                return;
+            if (typeof before === 'string')
+                dropFrom(byArgParent, before, id);
+            if (typeof after === 'string')
+                addTo(byArgParent, after, id);
+        };
+        const dissolveVisit = (kids, out, ids, layout) => {
+            const isItem = (b) => itemKinds.has(blocks.get(b)?.type ?? '');
+            const shown = [];
+            for (const id of ids) {
+                const own = itemKind(id) !== undefined;
+                const sub = dissolveVisit(kids, out, (kids.get(id) ?? []).map((k) => k.id), own);
+                if (own) {
+                    if (sub.length > 1)
+                        shown.push({ id, kids: [] });
+                    else {
                         out.add(id);
-                        shown.push(...sub);
+                        for (const k of sub) {
+                            out.add(k.id);
+                            shown.push(...k.kids.map((kid) => ({ id: kid, kids: [] })));
+                        }
                     }
-                    else
-                        shown.push({ id, kids: sub.map((k) => k.id) });
                 }
-                return shown;
+                else if (isItem(id) && (!layout || sub.length === 0)) {
+                    out.add(id);
+                    shown.push(...sub);
+                }
+                else
+                    shown.push({ id, kids: sub.map((k) => k.id) });
+            }
+            return shown;
+        };
+        const dissolve = (kids) => {
+            const out = new Set();
+            dissolveVisit(kids, out, (kids.get(null) ?? []).map((k) => k.id), false);
+            return out;
+        };
+        /** The ownership the layout rules read: none of their decisions applied. */
+        const own0 = {
+            ...ownShim,
+            hidden: (b) => ownerOf(b) !== b,
+            passes: () => false
+        };
+        /** `id`'s slot in the index `own` reads (none: hidden, or under no live parent). */
+        const slotIn = (own, id) => {
+            const pl = placementsMap.get(id);
+            if (pl === undefined || !blocks.has(id) || own.hidden(id))
+                return undefined;
+            const { parent, rank, reset } = displaySlotOf(own, placementsMap, pl, id);
+            if (parent === DEAD)
+                return undefined;
+            return reset === null ? { parent, rank } : { parent, rank, reset };
+        };
+        /** The index of the first slot of `list` not before `x`. */
+        const seek = (list, x) => {
+            let lo = 0;
+            let hi = list.length;
+            while (lo < hi) {
+                const mid = (lo + hi) >> 1;
+                if (bySlot(list[mid], x) < 0)
+                    lo = mid + 1;
+                else
+                    hi = mid;
+            }
+            return lo;
+        };
+        /**
+         * Re-decide the slots of `affected` in `kids`/`slotMap` (read through
+         * `own`), patching the child lists they leave or join (each list
+         * copied once: a list a reader holds never changes under it). Returns
+         * the blocks whose slot changed, with their parents before and after.
+         */
+        const patch = (kids, slotMap, own, affected) => {
+            const changed = new Map();
+            const copies = new Map();
+            const list = (p) => {
+                let l = copies.get(p);
+                if (l === undefined)
+                    copies.set(p, (l = [...(kids.get(p) ?? [])]));
+                return l;
             };
-            visit(null, false);
+            for (const id of affected) {
+                const old = slotMap.get(id);
+                const next = slotIn(own, id);
+                if (old?.parent === next?.parent &&
+                    old?.rank === next?.rank &&
+                    old?.reset === next?.reset &&
+                    (old === undefined) === (next === undefined))
+                    continue;
+                if (old !== undefined) {
+                    const l = list(old.parent);
+                    const at = seek(l, { id, rank: old.rank });
+                    if (l[at]?.id === id)
+                        l.splice(at, 1);
+                }
+                if (next !== undefined) {
+                    const l = list(next.parent);
+                    const slot = next.reset === undefined
+                        ? { id, rank: next.rank }
+                        : { id, rank: next.rank, reset: next.reset };
+                    l.splice(seek(l, slot), 0, slot);
+                    slotMap.set(id, next);
+                }
+                else {
+                    slotMap.delete(id);
+                    if (kids === kidsMap)
+                        leftLists.add(id);
+                }
+                changed.set(id, [old?.parent, next?.parent]);
+            }
+            for (const [p, l] of copies) {
+                if (l.length === 0)
+                    kids.delete(p);
+                else
+                    kids.set(p, l);
+                if (kids === kidsMap)
+                    dirtyLists.add(p);
+            }
+            return changed;
+        };
+        /** `seeds` and every block whose slot walk reads one of them: stored subtrees, through what each displays. */
+        const reach = (seeds) => {
+            const out = new Set();
+            const stack = [...seeds];
+            for (let x = stack.pop(); x !== undefined; x = stack.pop()) {
+                if (out.has(x))
+                    continue;
+                out.add(x);
+                for (const c of kidsOf.get(x) ?? [])
+                    stack.push(c);
+                for (const d of displaysMap.get(x) ?? [])
+                    if (d !== x)
+                        for (const c of kidsOf.get(d) ?? [])
+                            stack.push(c);
+            }
             return out;
         };
-        const ensurePlacements = () => {
-            if (placementsBuiltAt >= placementVersion)
-                return;
-            ensureOwners();
-            placementsMap = resolvePlacements(blocks, ownerOf);
-            dissolved = new Set();
-            kidsMap = childrenIndex(placementsMap, ownShim);
-            // The layout rules, when the document holds a layout or an item kind.
-            const items = new Set();
-            for (const type of roles?.layoutKinds() ?? [])
-                items.add(roles.layout(type));
-            let layouts = false;
+        /** Whether `id` shows as its slot's kind (`following`): read from its slot and kinds. */
+        const noteFollowing = (id) => {
+            const slot = slots.get(id);
+            const follows = slot !== undefined &&
+                (slot.reset !== undefined ||
+                    (slot.parent !== null && lineKind(slot.parent) !== undefined) ||
+                    lineKinds.has(blocks.get(id)?.type ?? ''));
+            if (follows)
+                following.add(id);
+            else
+                following.delete(id);
+        };
+        /** The placement `resolvePlacements` gives `id` while every block shows its argmax. */
+        const argmaxOf = (id) => {
+            const rec = blocks.get(id);
+            if (rec === undefined)
+                return undefined;
+            const c = rec.cands[0];
+            if (c === undefined)
+                return null;
+            const p = c.p !== null && !blocks.has(c.p) ? null : c.p;
+            return { parent: p, rank: c.r };
+        };
+        /** A display edge walk from `id`'s parent reaches `id` (or loops): the argmax graph has a cycle. */
+        const cyclic = (id) => {
+            let steps = 0;
+            for (let cur = placementsMap.get(id)?.parent ?? null; cur !== null;) {
+                const o = ownerOf(cur);
+                const at = o === DEAD ? cur : o;
+                if (at === id || ++steps > blocks.size)
+                    return true;
+                const cp = placementsMap.get(at);
+                if (cp === undefined)
+                    return false;
+                cur = cp.parent;
+            }
+            return false;
+        };
+        const setPlacement = (id, pl) => {
+            const old = placementsMap.get(id);
+            if (old !== undefined)
+                dropFrom(kidsOf, old.parent, id);
+            if (pl === undefined)
+                placementsMap.delete(id);
+            else {
+                placementsMap.set(id, pl);
+                addTo(kidsOf, pl.parent, id);
+            }
+        };
+        /** Everything rebuilt from the records (the first build, roles, an irregular state). */
+        const rebuildPlacements = () => {
+            placementFull = false;
+            placementSeeds.clear();
+            stateSeeds.clear();
+            ownerChanged.clear();
+            itemKinds = declaredItems();
             for (const b of blocks.keys()) {
                 const item = itemKind(b);
-                if (item === undefined)
-                    continue;
-                items.add(item);
-                layouts = true;
-            }
-            if (!layouts)
-                for (const rec of blocks.values())
-                    if (items.has(rec.type))
-                        layouts = true;
-            if (layouts) {
-                const out = dissolve(kidsMap, items);
-                if (out.size > 0) {
-                    dissolved = out;
-                    kidsMap = childrenIndex(placementsMap, ownShim);
-                }
+                if (item !== undefined)
+                    itemKinds.add(item);
             }
-            slots = new Map();
             lineKinds = new Set(roles?.lineKinds());
-            for (const b of blocks.keys()) {
-                const line = lineKind(b);
-                if (line !== undefined)
-                    lineKinds.add(line);
+            kindsOf.clear();
+            [layoutBlocks, itemBlocks] = [0, 0];
+            lineCounts.clear();
+            for (const b of blocks.keys())
+                noteKind(b);
+            for (const line of lineCounts.keys())
+                lineKinds.add(line);
+            placementFull = false;
+            const resolved = resolvePlacements(blocks, ownerOf);
+            placementsMap.clear();
+            kidsOf.clear();
+            irregular = false;
+            for (const [id, pl] of resolved) {
+                setPlacement(id, pl);
+                const arg = argmaxOf(id);
+                if (!arg || arg.parent !== pl.parent || arg.rank !== pl.rank)
+                    irregular = true;
             }
-            const out = [];
-            const lines = [];
-            for (const [under, kids] of kidsMap) {
-                const lined = under !== null && lineKind(under) !== undefined;
-                for (const { id, reset } of kids) {
-                    slots.set(id, { under, reset });
-                    if (reset !== undefined)
-                        out.push(id);
-                    if (lined || lineKinds.has(blocks.get(id)?.type ?? ''))
-                        lines.push(id);
-                }
+            layoutMode = layoutBlocks + itemBlocks > 0;
+            dissolved = new Set();
+            const index = (own, map) => {
+                const at = new Map();
+                for (const [parent, list] of map)
+                    for (const { id, rank, reset } of list)
+                        at.set(id, reset === undefined ? { parent, rank } : { parent, rank, reset });
+                void own;
+                return at;
+            };
+            kids0 = childrenIndex(placementsMap, own0);
+            slots0 = index(own0, kids0);
+            if (layoutMode) {
+                dissolved = dissolve(kids0);
+                kidsMap = childrenIndex(placementsMap, ownShim);
+                slots = index(ownShim, kidsMap);
             }
-            following = [...out, ...lines];
+            else
+                [kidsMap, slots] = [kids0, slots0];
+            following.clear();
+            for (const id of slots.keys())
+                noteFollowing(id);
             orderCache = null;
-            placementsBuiltAt = placementVersion;
+            kidsVersion++;
+            allListsDirty = true;
+        };
+        /**
+         * Re-run the layout rules on the layouts `changed` (blocks whose slot
+         * in `kids0` changed, with their parents) and `kinds` reach: from each
+         * one up through layouts and items, the topmost such ancestor's
+         * subtree. Returns the blocks whose dissolved state flipped.
+         */
+        const redissolve = (changed, kinds) => {
+            const flips = new Set();
+            const isLayoutish = (b) => {
+                const k = kindsOf.get(b);
+                return k !== undefined && (k.layout || k.item);
+            };
+            const roots = new Set();
+            const climb = (b) => {
+                let top;
+                for (let x = b; typeof x === 'string' && isLayoutish(x); x = slots0.get(x)?.parent)
+                    top = x;
+                if (top !== undefined)
+                    roots.add(top);
+            };
+            for (const [id, [from, to]] of changed) {
+                climb(id);
+                climb(from);
+                climb(to);
+            }
+            for (const id of kinds) {
+                // Its kind decides its own rule, its parent's count and its children's (`layout`).
+                climb(id);
+                climb(slots0.get(id)?.parent);
+                for (const k of kids0.get(id) ?? [])
+                    climb(k.id);
+                // Only a layout or an item dissolves: a block that left those kinds shows again.
+                if (!isLayoutish(id) && dissolved.delete(id))
+                    flips.add(id);
+            }
+            for (const root of roots) {
+                if (!slots0.has(root))
+                    continue;
+                const parent = slots0.get(root).parent;
+                const nodes = [];
+                const stack = [root];
+                for (let x = stack.pop(); x !== undefined; x = stack.pop()) {
+                    nodes.push(x);
+                    for (const k of kids0.get(x) ?? [])
+                        stack.push(k.id);
+                }
+                const out = new Set();
+                dissolveVisit(kids0, out, [root], parent !== null && itemKind(parent) !== undefined);
+                for (const x of nodes) {
+                    if (out.has(x) === dissolved.has(x))
+                        continue;
+                    if (out.has(x))
+                        dissolved.add(x);
+                    else
+                        dissolved.delete(x);
+                    flips.add(x);
+                }
+            }
+            // A block that left the index (hidden, removed) dissolves no more.
+            for (const id of changed.keys())
+                if (!slots0.has(id) && dissolved.delete(id))
+                    flips.add(id);
+            return flips;
+        };
+        const ensurePlacements = () => {
+            ensureOwners();
+            if (placementFull || irregular) {
+                if (placementFull || placementSeeds.size + stateSeeds.size + ownerChanged.size > 0)
+                    rebuildPlacements();
+                return;
+            }
+            if (placementSeeds.size + stateSeeds.size + ownerChanged.size === 0)
+                return;
+            const moved = new Set();
+            for (const id of placementSeeds) {
+                const next = argmaxOf(id);
+                if (next === null)
+                    return rebuildPlacements();
+                const old = placementsMap.get(id);
+                if (old?.parent === next?.parent && old?.rank === next?.rank)
+                    continue;
+                setPlacement(id, next);
+                moved.add(id);
+            }
+            // A changed display edge closing a cycle needs the global resolution.
+            for (const id of moved)
+                if (cyclic(id))
+                    return rebuildPlacements();
+            for (const o of ownerChanged)
+                for (const c of kidsOf.get(o) ?? [])
+                    if (cyclic(c))
+                        return rebuildPlacements();
+            const seeds = new Set([...moved, ...stateSeeds, ...ownerChanged]);
+            const kinds = [...stateSeeds];
+            placementSeeds.clear();
+            stateSeeds.clear();
+            ownerChanged.clear();
+            const affected = reach(seeds);
+            let touched = affected;
+            const changed = patch(kids0, slots0, own0, affected);
+            let any = changed.size > 0;
+            if (layoutMode) {
+                const flips = redissolve(changed, kinds);
+                const again = flips.size > 0 ? reach([...affected, ...flips]) : affected;
+                any = patch(kidsMap, slots, ownShim, again).size > 0 || any;
+                touched = again;
+            }
+            for (const id of touched)
+                noteFollowing(id);
+            if (any) {
+                orderCache = null;
+                kidsVersion++;
+            }
         };
         /**
          * The kind `id` displays as — THE shown-kind rule, read from its slot
@@ -397,7 +1027,7 @@ export const bindRuns = (Y) => {
             const slot = slots.get(id);
             if (roles === null || slot === undefined)
                 return stored;
-            const { under, reset } = slot;
+            const { parent: under, reset } = slot;
             const line = under === null || lineKinds.size === 0 ? undefined : lineKind(under);
             if (line !== undefined)
                 return line;
@@ -411,7 +1041,7 @@ export const bindRuns = (Y) => {
             // container whose item is the document's default kind (a column) holds no
             // items of its own: a paragraph under one is no list's item.
             if (!lined && typeof from === 'string' && roles.container(from))
-                for (let u = under; u !== null; u = slots.get(u)?.under ?? null) {
+                for (let u = under; u !== null; u = slots.get(u)?.parent ?? null) {
                     const t = typeOf(u);
                     if (roles.container(t) &&
                         roles.defaultChild(t) === stored &&
@@ -487,15 +1117,48 @@ export const bindRuns = (Y) => {
             for (const c of rec?.claims ?? [])
                 fx.add(c.m);
         };
-        /** Rebuild (or create, or drop) block `id`'s record. */
+        /**
+         * Rebuild (or create, or drop) block `id`'s record, and note what the
+         * maintained facts must re-decide: its owner and the tops of the
+         * blocks it claims (P3), its placement — and, when its entry came or
+         * went, the placements of the blocks whose candidate names it.
+         */
         const updateBlockRec = (id) => {
+            const old = blocks.get(id);
             const node = registry.getAttr(id);
             if (!isNodeLike(node))
                 blocks.delete(id);
             else
                 blocks.set(id, buildRec(id, node));
-            noteEffects(id, blocks.get(id));
+            const rec = blocks.get(id);
+            noteEffects(id, rec);
             noteShell(id);
+            const was = new Set(old?.claims.map((c) => c.m));
+            const now = new Set(rec?.claims.map((c) => c.m));
+            for (const m of was)
+                if (!now.has(m)) {
+                    dropFrom(claimersOf, m, id);
+                    addTo(claimTargets, id, m);
+                }
+            for (const m of now)
+                if (!was.has(m))
+                    addTo(claimersOf, m, id);
+            ownerSeeds.add(id);
+            noteCands(id, argParent(old));
+            placementSeeds.add(id);
+            if ((old === undefined) !== (rec === undefined)) {
+                stateSeeds.add(id);
+                for (const c of byArgParent.get(id) ?? [])
+                    placementSeeds.add(c);
+            }
+            if (old?.type !== rec?.type) {
+                noteKind(id);
+                if (old === undefined ||
+                    rec === undefined ||
+                    roles === null ||
+                    !sameShape(roles, old.type, rec.type))
+                    stateSeeds.add(id);
+            }
         };
         /** A withdrawn block without a delete mark: its `deleted` is settled after each fold. */
         const noteShell = (id) => {
@@ -638,7 +1301,7 @@ export const bindRuns = (Y) => {
         };
         const runs = (b) => {
             // Read-your-writes: fold the open transaction's pending writes first.
-            syncPending(openTx());
+            syncAll();
             if (dirty.has(b) || !cache.has(b))
                 computeRuns(b);
             return cache.get(b)?.runs ?? EMPTY_RUNS;
@@ -646,7 +1309,6 @@ export const bindRuns = (Y) => {
         const parentOf = (id) => blocks.get(id)?.cands[0]?.p;
         /** A structural change of `id`: its readers, and the blocks it claims, re-read. */
         const invalidateBlock = (id, ctx, claimsBefore = []) => {
-            ctx.structure = ctx.placement = true;
             ctx.invalidated.add(id);
             for (const c of listConsumers.get(id) ?? [])
                 ctx.invalidated.add(c);
@@ -656,8 +1318,25 @@ export const bindRuns = (Y) => {
                     ctx.invalidated.add(c);
             }
         };
-        /** Fold one block's changed facets (`spans`: its text's edited spans, `null` = opaque). */
-        const foldBlock = (id, facets, spans, ctx) => {
+        /** Note edits of `id`'s own text (`null`: unknown — rescan, every reader re-reads). */
+        const noteText = (ctx, id, e) => {
+            let t = ctx.texts.get(id);
+            if (t === undefined)
+                ctx.texts.set(id, (t = { edits: [], scan: false, opaque: false, seen: new Set() }));
+            if (e === null) {
+                t.scan = t.opaque = true;
+                return;
+            }
+            if (t.seen.has(e))
+                return;
+            t.seen.add(e);
+            t.scan ||= e.scan;
+            t.opaque ||= e.opaque;
+            for (const x of e.edits)
+                t.edits.push(x);
+        };
+        /** Fold one block's changed facets (`edits`: its own text's, one per changed content node). */
+        const foldBlock = (id, facets, edits, ctx) => {
             const kinds = new Set();
             for (const f of facets)
                 kinds.add(f === ENTRY_FACET ? 'entry' : facetOf(f));
@@ -673,73 +1352,119 @@ export const bindRuns = (Y) => {
                 // A new entry, a nonce or an own text can move streams (R2).
                 if (kinds.has('entry') || facets.has(NONCE) || facets.has(CONTENT_ATTR)) {
                     ctx.table = true;
-                    ctx.texts.set(id, null);
+                    ctx.named.add(id);
+                    noteText(ctx, id, null);
                 }
                 invalidateBlock(id, ctx, claimsBefore);
             }
             else {
                 ensureRec(id);
                 const rec = blocks.get(id);
-                if (kinds.has('at')) {
-                    if (rec)
-                        rec.cands = candidatesOf(rec.node);
-                    ctx.placement = true;
+                if (kinds.has('at') && rec) {
+                    const before = argParent(rec);
+                    rec.cands = candidatesOf(rec.node);
+                    noteCands(id, before);
+                    placementSeeds.add(id);
                 }
                 if (kinds.has('meta') && rec) {
                     const was = rec.type;
                     rec.type = typeAttr(rec.node);
                     rec.data = readData(rec.node);
-                    if (rec.type !== was)
+                    if (rec.type !== was) {
                         retyped = true;
+                        noteKind(id);
+                    }
                     // A retype that changes the kind's display shape re-parents
                     // (or re-kinds) its children.
                     if (roles !== null && !sameShape(roles, was, rec.type))
-                        ctx.placement = true;
+                        stateSeeds.add(id);
                 }
             }
             const parentAfter = parentOf(id);
             if (typeof parentAfter === 'string')
                 ctx.parents.add(parentAfter);
-            if (kinds.has('content') && ctx.texts.get(id) !== null) {
-                ctx.texts.set(id, spans === null ? null : [...(ctx.texts.get(id) ?? []), ...spans]);
-            }
+            if (kinds.has('content'))
+                for (const e of edits)
+                    noteText(ctx, id, e);
         };
-        /** Rescan the edited texts, move or rebuild the stream table, and invalidate their readers. */
+        /**
+         * Move each edited text's row by its edits (or rescan it), re-decide the
+         * delimiters a boundary change names, re-place the rows they cut, and
+         * invalidate the readers: the display owner of each edited stream (L7),
+         * the blocks whose stream changed, every reader of an opaque text.
+         */
         const foldTexts = (ctx) => {
-            const changed = new Set();
-            for (const home of ctx.texts.keys())
-                if (rescan(home))
-                    changed.add(home);
-            if (changed.size > 0)
+            const homes = new Set();
+            const gapsOf = new Map();
+            const gapsIn = (row, edits) => {
+                const gaps = [];
+                for (const e of edits) {
+                    const gap = gapOfItem(row, e.item);
+                    if (gap < 0)
+                        return null;
+                    gaps.push(gap);
+                }
+                return gaps;
+            };
+            for (const [home, t] of ctx.texts) {
+                const text = blocks.get(home)?.content;
+                const row = rows.get(home);
+                let gaps = [];
+                let fresh = t.scan || row === undefined || text === undefined || row.text !== text;
+                if (!fresh) {
+                    for (const e of t.edits) {
+                        const gap = gapOfItem(row, e.item);
+                        if (gap < 0 || !shiftGap(row, gap, e.del ? -e.len : e.len)) {
+                            fresh = true;
+                            break;
+                        }
+                        gaps.push(gap);
+                    }
+                    // The engine's own count of live units: a row that disagrees is stale.
+                    if (!fresh && rowLength(row) !== text._length)
+                        fresh = true;
+                }
+                if (fresh) {
+                    const next = scanRow(home);
+                    const same = next !== undefined && row !== undefined && next.key === row.key;
+                    if (same)
+                        [next.cuts, next.head] = [row.cuts, row.head];
+                    setRow(home, next, ctx.named);
+                    if (!same)
+                        homes.add(home);
+                    gaps = next === undefined ? [] : gapsIn(next, t.edits);
+                }
+                gapsOf.set(home, t.opaque ? null : gaps);
+            }
+            refreshDelims(ctx.named, homes);
+            if (homes.size > 0)
                 ctx.table = true;
-            if (ctx.table)
-                rebuildTable(ctx.invalidated);
-            else
-                for (const home of ctx.texts.keys())
-                    place(home);
-            for (const [home, spans] of ctx.texts) {
-                const readers = textConsumers.get(home) ?? [];
-                if (spans === null || changed.has(home) || ctx.structure) {
-                    for (const c of readers)
+            for (const home of homes)
+                placeHome(home, ctx.invalidated);
+            for (const [home, gaps] of gapsOf) {
+                if (gaps === null) {
+                    for (const c of textConsumers.get(home) ?? [])
                         ctx.invalidated.add(c);
                     continue;
                 }
-                // Only the streams the edit touched change their display (L7).
-                for (const s of inText.get(home) ?? []) {
-                    if (!spans.some(([lo, hi]) => s.start <= hi && lo <= s.end))
-                        continue;
-                    const owner = ownerOf(s.block);
+                // Only the stream each edit lies in changes its display (L7).
+                const row = rows.get(home);
+                if (row === undefined)
+                    continue;
+                for (const gap of gaps) {
+                    const b = headOf(row, segmentOfGap(row, gap));
+                    const owner = b === null ? DEAD : ownerOf(b);
                     if (typeof owner === 'string')
                         ctx.invalidated.add(owner);
                 }
             }
         };
         /** The blocks whose stream lies in a text the fold edited. */
-        const editedStreams = (ctx) => [...ctx.texts.keys()].flatMap((home) => (inText.get(home) ?? []).map((s) => s.block));
+        const editedStreams = (ctx) => [...ctx.texts.keys()].flatMap((home) => streamsIn(home).map((st) => st.block));
         /** A live unit in `id`'s stream (boundaries excepted). */
         const streamHolds = (id) => {
-            const s = streams.get(id);
-            return s !== undefined && s.end - s.start > s.inert.length;
+            const st = streamOf(id);
+            return st !== undefined && st.end - st.start > st.inert.length;
         };
         /**
          * Settle the withdrawn blocks (`hist.undo.withdraw`): a shell is deleted
@@ -788,9 +1513,9 @@ export const bindRuns = (Y) => {
                 if (rec.deleted === !alive.has(id))
                     continue;
                 rec.deleted = !alive.has(id);
+                ownerSeeds.add(id);
                 if (ctx === null)
                     continue;
-                structureVersion++;
                 invalidateBlock(id, ctx);
             }
         };
@@ -828,9 +1553,9 @@ export const bindRuns = (Y) => {
         const candidates = new Set();
         let reporting = false;
         /** THE fold: one pass over changed `(type, parentSub)` pairs, each block folded once. */
-        const fold = (changed, extentOf) => {
+        const fold = (changed, editsOf) => {
             const touched = new Map();
-            const spans = new Map();
+            const edits = new Map();
             let derived = changed.has(dataRoot);
             for (const [type, subs] of changed) {
                 for (const sub of subs) {
@@ -842,32 +1567,33 @@ export const bindRuns = (Y) => {
                     if (facets === undefined)
                         touched.set(id, (facets = new Set()));
                     facets.add(facet);
-                    if (facet !== CONTENT || spans.get(id) === null)
+                    if (facet !== CONTENT)
                         continue;
-                    const edited = seq ? extentOf(type) : undefined;
-                    spans.set(id, edited === undefined ? null : [...(spans.get(id) ?? []), ...edited]);
+                    // A sequence edit of the block's own text, or a change inside one of its atoms.
+                    let list = edits.get(id);
+                    if (list === undefined)
+                        edits.set(id, (list = []));
+                    list.push(seq ? editsOf(type) : null);
                 }
             }
             const ctx = {
                 invalidated: new Set(),
                 texts: new Map(),
+                named: new Set(),
                 table: false,
-                structure: false,
-                placement: false,
                 parents: new Set()
             };
             for (const [id, facets] of touched) {
-                foldBlock(id, facets, spans.get(id) ?? null, ctx);
+                foldBlock(id, facets, edits.get(id) ?? [], ctx);
                 derived ||= [...facets].some((f) => f === ENTRY_FACET || facetOf(f) !== 'ignore');
             }
-            if (ctx.structure)
-                structureVersion++;
             foldTexts(ctx);
-            settle(ctx.table ? shells : [...touched.keys(), ...ctx.parents, ...editedStreams(ctx)], ctx);
-            if (ctx.placement)
-                placementVersion++;
+            if (shells.size > 0)
+                settle(ctx.table ? shells : [...touched.keys(), ...ctx.parents, ...editedStreams(ctx)], ctx);
             for (const b of ctx.invalidated)
                 dirty.add(b);
+            if (indexChecks.on)
+                check();
             if (derived)
                 version++;
             if (reporting) {
@@ -888,8 +1614,94 @@ export const bindRuns = (Y) => {
             }
             return touched;
         };
-        /** The open transaction's folded part: copies of its id sets, and their lengths (the watermark). */
-        let cursor = null;
+        /** {@link indexChecks}: every incrementally maintained fact equals its rebuild. */
+        const check = () => {
+            const fail = (what) => {
+                throw new Error(`[edytor index] ${what} differs from its rebuild`);
+            };
+            const scans = new Map();
+            for (const rec of blocks.values())
+                if (rec.content)
+                    scans.set(rec.id, scanText(rec.id, rec.content));
+            for (const home of rows.keys())
+                if (!scans.has(home))
+                    fail(`row ${home}`);
+            for (const [home, scan] of scans) {
+                const row = rows.get(home);
+                if (row === undefined || row.text !== scan.text || !sameRow(row, scan))
+                    fail(`row ${home}`);
+            }
+            const want = delimiters(blocks, scans.values());
+            if (want.size !== delim.size || [...want].some(([b, k]) => delim.get(b) !== k))
+                fail('delimiters');
+            const streamSig = (st) => st && `${st.home}:${st.start}-${st.end}/${st.inert.join(',')}`;
+            const placed = new Set();
+            for (const [home, scan] of scans)
+                for (const st of placeText(scan, want)) {
+                    placed.add(st.block);
+                    if (streamSig(streamOf(st.block)) !== streamSig(st))
+                        fail(`stream of ${st.block} in ${home}`);
+                }
+            for (const b of streamIx.keys())
+                if (!placed.has(b))
+                    fail(`stream of ${b}`);
+            for (const [b, c] of cache) {
+                if (dirty.has(b))
+                    continue;
+                const fresh = computeFresh(b).fresh;
+                if (keyOf(fresh) !== keyOf(c.runs))
+                    fail(`runs of ${b}`);
+            }
+            // P3: the claim graph, placements, children index and layout rules.
+            ensurePlacements();
+            const graph = claimGraph(blocks);
+            for (const b of blocks.keys()) {
+                if (ownerOf(b) !== (graph.owners.get(b) ?? DEAD))
+                    fail(`owner of ${b}`);
+                if (ownShim.top(b) !== graph.top.get(b))
+                    fail(`top of ${b}`);
+            }
+            const shown = displayIndex(blocks, ownerOf);
+            for (const [o, list] of shown)
+                if (list.length !== (displaysMap.get(o)?.size ?? 0) ||
+                    list.some((b) => !displaysMap.get(o).has(b)))
+                    fail(`displays of ${o}`);
+            for (const o of displaysMap.keys())
+                if (!shown.has(o))
+                    fail(`displays of ${o}`);
+            const resolved = resolvePlacements(blocks, ownerOf);
+            if (resolved.size !== placementsMap.size)
+                fail('placements');
+            for (const [b, pl] of resolved) {
+                const mine = placementsMap.get(b);
+                if (mine?.parent !== pl.parent || mine.rank !== pl.rank)
+                    fail(`placement of ${b}`);
+            }
+            const same = (x, y) => x.size === y.size && [...x].every(([p, l]) => keyOf(l) === keyOf(y.get(p) ?? null));
+            const k0 = childrenIndex(placementsMap, own0);
+            if (!same(k0, kids0))
+                fail('children index (before the layout rules)');
+            const out = dissolve(k0);
+            if (out.size !== dissolved.size || [...out].some((b) => !dissolved.has(b)))
+                fail('dissolved');
+            if (!same(childrenIndex(placementsMap, ownShim), kidsMap))
+                fail('children index');
+            for (const [p, l] of kidsMap)
+                for (const { id, rank, reset } of l) {
+                    const slot = slots.get(id);
+                    if (slot?.parent !== p || slot.rank !== rank || slot.reset !== reset)
+                        fail(`slot of ${id}`);
+                }
+            const follow = new Set(following);
+            for (const id of slots.keys())
+                noteFollowing(id);
+            if (follow.size !== following.size || [...follow].some((b) => !following.has(b)))
+                fail('following');
+        };
+        /** Each transaction's folded part: copies of its id sets, and their lengths (the watermark). */
+        const cursors = new WeakMap();
+        /** The transactions whose commit fold ran. */
+        const committed = new WeakSet();
         const lengthOf = (set) => {
             let n = 0;
             set.clients.forEach((ranges) => {
@@ -907,9 +1719,9 @@ export const bindRuns = (Y) => {
         const syncPending = (tr) => {
             if (tr?.insertSet === undefined || tr.deleteSet === undefined)
                 return false;
-            if (cursor?.tr !== tr) {
-                cursor = { tr, ins: Y.createIdSet(), del: Y.createIdSet(), mark: 0 };
-            }
+            let cursor = cursors.get(tr);
+            if (cursor === undefined)
+                cursors.set(tr, (cursor = { ins: Y.createIdSet(), del: Y.createIdSet(), mark: 0 }));
             const mark = lengthOf(tr.insertSet) + lengthOf(tr.deleteSet);
             if (mark === cursor.mark)
                 return false;
@@ -931,16 +1743,37 @@ export const bindRuns = (Y) => {
             };
             walkIdSetStructs(Y, doc, ins, note);
             walkIdSetStructs(Y, doc, del, note);
-            fold(changed, makeExtentIndex({ insertSet: ins, deleteSet: del }));
+            fold(changed, makeEditIndex(ins, del));
             return true;
         };
         const openTx = () => doc._transaction;
+        /**
+         * Fold every transaction whose writes are in the document and whose
+         * commit fold has not run, in their order: the open one, and those a
+         * transaction's cleanup started (an observer's or an `update`
+         * listener's write runs its body at once, its observers later) — a
+         * read in between must not mix their items with an index that never
+         * saw them.
+         */
+        const syncAll = () => {
+            for (const tr of queuedTransactions(doc))
+                if (!committed.has(tr))
+                    syncPending(tr);
+        };
         /** The commit: fold `transaction.changed` once (the report publishes from `update`). */
         const onCommit = (e) => {
             const tr = e.transaction;
-            if (cursor?.tr === tr)
-                cursor = null;
-            fold(tr.changed ?? new Map(), makeExtentIndex(tr));
+            let [ins, del] = [tr.insertSet, tr.deleteSet];
+            // The writes a read folded already moved the rows: only the rest
+            // are edits now (the facets fold again, idempotent).
+            const cursor = cursors.get(tr);
+            if (cursor !== undefined && ins !== undefined && del !== undefined) {
+                ins = Y.diffIdSet(ins, cursor.ins);
+                del = Y.diffIdSet(del, cursor.del);
+            }
+            cursors.delete(tr);
+            committed.add(tr);
+            fold(tr.changed ?? new Map(), makeEditIndex(ins, del));
         };
         // ── projection ───────────────────────────────────────────────────
         /** `id`'s visible content items, canonical and frozen (R4). */
@@ -981,7 +1814,7 @@ export const bindRuns = (Y) => {
                         : { ...old, parent, index });
                 });
             }
-            return { nodes, order, kids: kidsMap };
+            return { nodes, order, kids: kidsVersion };
         };
         const keyOf = (v) => {
             try {
@@ -991,6 +1824,126 @@ export const bindRuns = (Y) => {
                 return JSON.stringify(cloneJsonSafe(v ?? null));
             }
         };
+        /**
+         * The report's structural part from the child lists patched since the
+         * last report (P3), advancing the published tree in place — what
+         * `reachable` would give, without walking the lists nothing changed:
+         * a published block no longer shown leaves (a root when its parent
+         * stays), its still-shown descendants staying; each patched list's
+         * new order is news, a block in it at a new parent or index moved, one
+         * not published before is added with its subtree.
+         */
+        const advance = (pub, r, covered, reparented) => {
+            const { nodes, order } = pub;
+            const shown = (x) => {
+                for (let c = x; c !== null;) {
+                    const slot = slots.get(c);
+                    if (slot === undefined)
+                        return false;
+                    c = slot.parent;
+                }
+                return true;
+            };
+            const lists = [...dirtyLists];
+            // Leaving: a published block of a patched list that no longer shows.
+            const drop = (id) => {
+                const ks = order.get(id);
+                if (ks !== undefined) {
+                    order.delete(id);
+                    r.order.set(id, EMPTY_IDS);
+                    for (const k of ks)
+                        if (!shown(k))
+                            drop(k);
+                }
+                nodes.delete(id);
+            };
+            for (const id of leftLists) {
+                const o = nodes.get(id);
+                if (o === undefined || shown(id))
+                    continue;
+                if (o.parent === null || shown(o.parent))
+                    r.removed.add(id);
+                drop(id);
+            }
+            // Each patched list that shows: its order, its moved and new blocks.
+            const fresh = new Map();
+            for (const p of lists) {
+                if (p !== null && !shown(p))
+                    continue;
+                const ks = kidsMap.get(p) ?? [];
+                const prev = order.get(p);
+                if (ks.length === 0) {
+                    if (prev !== undefined) {
+                        order.delete(p);
+                        r.order.set(p, EMPTY_IDS);
+                    }
+                    continue;
+                }
+                const ids = ks.map((k) => k.id);
+                if (prev === undefined || !sameIds(prev, ids)) {
+                    const frozen = Object.freeze(ids);
+                    order.set(p, frozen);
+                    r.order.set(p, frozen);
+                }
+                ks.forEach(({ id }, index) => {
+                    const n = nodes.get(id);
+                    if (n === undefined)
+                        fresh.set(id, { parent: p, index });
+                    else if (n.parent !== p || n.index !== index) {
+                        r.moved.add(id);
+                        if (n.parent !== p)
+                            reparented.add(id);
+                        n.parent = p;
+                        n.index = index;
+                    }
+                });
+            }
+            // New roots (no new ancestor) bring their subtree.
+            const add = (b, parent, index) => {
+                if (!nodes.has(b.id)) {
+                    covered.add(b.id);
+                    const rec = blocks.get(b.id);
+                    nodes.set(b.id, { parent, index, type: typeOf(b.id), data: rec.data, runs: runs(b.id) });
+                }
+                if (b.children.length > 0 && !order.has(b.id)) {
+                    const ids = Object.freeze(b.children.map((c) => c.id));
+                    order.set(b.id, ids);
+                    r.order.set(b.id, ids);
+                }
+                b.children.forEach((c, i) => add(c, b.id, i));
+            };
+            for (const [id, at] of fresh) {
+                let under = false;
+                for (let c = slots.get(id)?.parent ?? null; c !== null && !under; c = slots.get(c)?.parent ?? null)
+                    under = fresh.has(c);
+                if (under || covered.has(id))
+                    continue;
+                const b = projectBlock(id);
+                r.added.set(id, b);
+                add(b, at.parent, at.index);
+            }
+        };
+        /** {@link indexChecks}: the published tree the report advanced equals a fresh walk. */
+        const checkPublished = () => {
+            const pub = published;
+            // Payloads from the published nodes: the check reads no runs.
+            const want = reachable(pub.nodes);
+            const fail = (what) => {
+                throw new Error(`[edytor index] published ${what} differs from its rebuild`);
+            };
+            if (want.order.size !== pub.order.size)
+                fail('lists');
+            for (const [p, ids] of want.order)
+                if (!sameIds(ids, pub.order.get(p) ?? []))
+                    fail(`list of ${p}`);
+            if (want.nodes.size !== pub.nodes.size)
+                fail('blocks');
+            for (const [id, n] of want.nodes) {
+                const m = pub.nodes.get(id);
+                if (m?.parent !== n.parent || m.index !== n.index)
+                    fail(`slot of ${id}`);
+            }
+        };
         /** The blocks whose shown kind followed their slot at the last report. */
         let followingBefore = [];
         /** The document data's key at the last report. */
@@ -1015,14 +1968,19 @@ export const bindRuns = (Y) => {
                 if (key !== dataKey)
                     [r.data, dataKey] = [data, key];
             }
-            if (kidsMap === before.kids && candidates.size === 0)
+            if (kidsVersion === before.kids && candidates.size === 0)
                 return r.data ? r : null;
-            const after = kidsMap === before.kids ? before : reachable(before.nodes);
             // Added subtrees carry their new descendants. A descendant that was
             // visible before is reported like any visible block (moved, retyped,
             // edited against its published baseline), so consumers keep it (K7).
             const covered = new Set();
-            if (after !== before) {
+            /** Moved to another display parent: only those can show another kind (an index never does). */
+            const reparented = new Set();
+            const lists = kidsVersion !== before.kids && !allListsDirty;
+            const after = kidsVersion === before.kids || lists ? before : reachable(before.nodes);
+            if (lists)
+                advance(before, r, covered, reparented);
+            else if (after !== before) {
                 for (const [parent, ids] of after.order) {
                     const prev = before.order.get(parent);
                     if (prev === undefined || !sameIds(prev, ids))
@@ -1049,6 +2007,8 @@ export const bindRuns = (Y) => {
                         const o = before.nodes.get(id);
                         if (o.parent !== n.parent || o.index !== n.index)
                             r.moved.add(id);
+                        if (o.parent !== n.parent)
+                            reparented.add(id);
                     }
                 }
                 // Removed subtree ROOTS: a removed id whose before-parent stays
@@ -1090,13 +2050,14 @@ export const bindRuns = (Y) => {
             // changes a shown kind — the retyped block's (a candidate) and the
             // kinds derived from it: a promoted or stray line shows its display
             // parent's default child (XW-08).
-            if (after !== before || retyped) {
-                for (const id of [...r.moved, ...following, ...followingBefore]) {
+            if (after !== before || lists || retyped) {
+                const now = [...following];
+                for (const id of [...reparented, ...now, ...followingBefore]) {
                     const n = after.nodes.get(id);
                     if (n !== undefined && !candidates.has(id) && !covered.has(id) && typeOf(id) !== n.type)
                         meta(id, n);
                 }
-                followingBefore = following;
+                followingBefore = now;
             }
             // A plain block directly in a list shows as its item (`itemOf`, AW-04):
             // a block whose shown kind changed re-reads its children's (a worklist:
@@ -1110,6 +2071,12 @@ export const bindRuns = (Y) => {
             retyped = false;
             candidates.clear();
             published = after;
+            after.kids = kidsVersion;
+            dirtyLists.clear();
+            leftLists.clear();
+            allListsDirty = false;
+            if (indexChecks.on)
+                checkPublished();
             const empty = r.added.size + r.removed.size + r.moved.size + r.meta.size + r.content.size + r.order.size;
             return empty === 0 && !r.data ? null : r;
         };
@@ -1129,7 +2096,9 @@ export const bindRuns = (Y) => {
             if (!isNodeLike(v))
                 return;
             updateBlockRec(id);
-            rescan(id);
+            const row = scanRow(id);
+            if (row !== undefined)
+                rows.set(id, row);
         });
         rebuildTable(new Set());
         settle(shells, null);
@@ -1146,12 +2115,12 @@ export const bindRuns = (Y) => {
         // ── public surface ───────────────────────────────────────────────
         const view = {
             version: () => {
-                syncPending(openTx());
+                syncAll();
                 return version;
             },
             runs,
             contentItems: (b) => {
-                syncPending(openTx());
+                syncAll();
                 return blocks.get(b)?.deleted === false ? itemsOf(b) : [];
             },
             // Inline atoms always carry `data` (`{}` when absent) — the public
@@ -1160,24 +2129,26 @@ export const bindRuns = (Y) => {
                 ? { text: r.text, ...(r.marks !== undefined && { marks: cloneJsonSafe(r.marks) }) }
                 : { id: r.id, type: r.type, data: r.data === undefined ? {} : cloneJsonSafe(r.data) }),
             view: (tr) => {
-                syncPending(tr ?? openTx());
+                syncAll();
+                if (tr !== undefined && !committed.has(tr))
+                    syncPending(tr);
                 return ctx;
             },
             displayType: (id) => {
                 if (roles === null)
                     return undefined;
-                syncPending(openTx());
+                syncAll();
                 ensurePlacements();
                 const shown = blocks.has(id) ? typeOf(id) : undefined;
                 return shown === blocks.get(id)?.type ? undefined : shown;
             },
             dissolved: (id) => {
-                syncPending(openTx());
+                syncAll();
                 ensurePlacements();
                 return dissolved.has(id);
             },
             project: (root) => {
-                syncPending(openTx());
+                syncAll();
                 ensurePlacements();
                 return root === undefined
                     ? (kidsMap.get(null) ?? []).map((k) => projectBlock(k.id))
@@ -1185,7 +2156,7 @@ export const bindRuns = (Y) => {
             },
             roles: (next) => {
                 roles = next;
-                placementVersion++;
+                placementFull = true;
                 version++;
                 // No commit carries a role change: report it now (not inside a
                 // transaction, whose commit reports it), so every view follows.
@@ -1193,12 +2164,12 @@ export const bindRuns = (Y) => {
                     publish(null, false);
             },
             track: () => {
-                syncPending(openTx());
+                syncAll();
                 const f = { touched: new Map(), wrote: false };
                 frames.add(f);
                 return {
                     end: () => {
-                        syncPending(openTx());
+                        syncAll();
                         frames.delete(f);
                         return f;
                     }
@@ -1206,7 +2177,7 @@ export const bindRuns = (Y) => {
             },
             onReport: (cb) => {
                 if (reportSubs.size === 0) {
-                    syncPending(openTx());
+                    syncAll();
                     published = reachable();
                     dataKey = keyOf(docData());
                     candidates.clear();