edytor 6.0.0 → 7.0.0

package/dist/crdt/restore.d.ts

@@ -35,6 +35,8 @@ export type Unit = {
 };
 /** `items` one unit each (a character with its marks, or an atom), keyed for comparison. */
 export declare const unitsOf: (items: readonly ContentItem[]) => Unit[];
+/** Units back to runs: consecutive characters with the same marks joined. */
+export declare const runsOf: (units: readonly Unit[]) => ContentItem[];
 /** The one changed stretch from `x` to `y`: `x[p, e)` became `mid`. */
 export declare const hunk: (x: readonly Unit[], y: readonly Unit[]) => {
     p: number;
@@ -76,9 +78,19 @@ export type RestoreFacade<Plan> = Partial<SuggestFacade> & {
         patchData(target: null, ops: DataPatch[]): Plan;
     };
 };
+/** How a restore writes content, and whether it rejects the pending suggestions. */
+export type RestoreOptions<Plan> = {
+    /**
+     * The content rewrite of a block that differs (default `rewriteContent`).
+     * Another one edits through the display, so the block keeps its claims.
+     */
+    rewrite?: (facade: RestoreFacade<Plan>, id: BlockId, have: readonly Unit[], want: readonly Unit[]) => boolean;
+    /** `keep`: the pending suggestions stay (a re-seed's rebase writes as one more writer). */
+    suggestions?: 'reject' | 'keep';
+};
 /**
  * Make the visible document `doc` (through `facade`, the facade over it)
  * equal `json`. Runs inside the caller's transaction; the writer is
  * `doc.clientID`. See the module comment for what it writes.
  */
-export declare const restoreDocument: <Plan>(doc: EngineDoc, facade: RestoreFacade<Plan>, json: JSONDoc) => RestoreReport;
+export declare const restoreDocument: <Plan>(doc: EngineDoc, facade: RestoreFacade<Plan>, json: JSONDoc, { rewrite, suggestions }?: RestoreOptions<Plan>) => RestoreReport;

package/dist/crdt/restore.js

@@ -24,7 +24,7 @@ export const unitsOf = (items) => {
     return out;
 };
 /** Units back to runs: consecutive characters with the same marks joined. */
-const runsOf = (units) => {
+export const runsOf = (units) => {
     const out = [];
     let tag = null;
     for (const { key, item } of units) {
@@ -98,7 +98,7 @@ const walk = (specs, parent, into) => {
  * equal `json`. Runs inside the caller's transaction; the writer is
  * `doc.clientID`. See the module comment for what it writes.
  */
-export const restoreDocument = (doc, facade, json) => {
+export const restoreDocument = (doc, facade, json, { rewrite, suggestions = 'reject' } = {}) => {
     const report = { revived: 0, moved: 0, rewritten: 0, created: 0, deleted: 0 };
     const specs = json.children.map((block) => toBlockSpec(block));
     const all = walk(specs, null, new Map());
@@ -170,6 +170,11 @@ export const restoreDocument = (doc, facade, json) => {
         if (have.length === want.length && have.every((u, i) => u.key === want[i].key))
             continue;
         const claims = modelView(doc).blocks.get(id)?.claims ?? [];
+        if (rewrite) {
+            rewrite(facade, id, have, want);
+            report.rewritten++;
+            continue;
+        }
         if (claims.some((c) => c.stamp.c >= 0)) {
             deleteClaims(doc, claims);
             have = unitsOf(facade.contentItems(id));
@@ -202,7 +207,7 @@ export const restoreDocument = (doc, facade, json) => {
     // their proposals — is rejected, in the restore's step (its undo brings
     // them back).
     // (Built over the facade, its shared suggestions: `doc/suggest.ts`.)
-    const suggest = facade.part && suggestionsOf(facade);
+    const suggest = suggestions === 'reject' && facade.part && suggestionsOf(facade);
     if (suggest)
         suggest.run(suggest.decide(suggest.changes(), false));
     return report;

package/dist/crdt/schema.d.ts

@@ -98,6 +98,12 @@ export declare const hasWithdrawMark: (node: {
 /** The per-block `lastChangedBy` LWW attr (`SCHEMA.blockAttrs.lastChanged`). */
 export declare const LAST_CHANGED_ATTR = "l";
 export declare const CONTENT = "content";
+/**
+ * The epoch a re-seed wrote (`room.reseed.protocol`): the root `epoch`, its
+ * attr `n` (none before the first re-seed). Apart from `meta`, whose keys
+ * are the schema stamp's alone.
+ */
+export declare const EPOCH_ROOT = "epoch";
 /** The schema generation stamped on the `meta` root (`v`) and its manifest name (`schema`). */
 export declare const SCHEMA: {
     readonly version: 11;

package/dist/crdt/schema.js

@@ -87,6 +87,12 @@ export const hasWithdrawMark = (node) => [...node.attrKeys()].some((key) => key.
 /** The per-block `lastChangedBy` LWW attr (`SCHEMA.blockAttrs.lastChanged`). */
 export const LAST_CHANGED_ATTR = 'l';
 export const CONTENT = 'content';
+/**
+ * The epoch a re-seed wrote (`room.reseed.protocol`): the root `epoch`, its
+ * attr `n` (none before the first re-seed). Apart from `meta`, whose keys
+ * are the schema stamp's alone.
+ */
+export const EPOCH_ROOT = 'epoch';
 /** The schema generation stamped on the `meta` root (`v`) and its manifest name (`schema`). */
 export const SCHEMA = {
     // 7: a text delete is a hold record (fork patch YP20) on the wire and in

package/dist/crdt/structs.d.ts

@@ -64,17 +64,14 @@ export declare const clientsOf: (doc: EngineDoc) => Map<number, StoreStruct[]>;
  */
 export declare const structAt: (Y: EngineApi, structs: readonly StoreStruct[], clock: number) => StoreStruct | null;
 /**
- * Walk every struct an IdSet covers, in (client, clock) order: `fn(struct,
- * from, to)` gets the struct and the clock range `[from, to)` of it the set
- * covers (a struct can reach past a range a diff of two id sets cut). The
- * walk never splits a struct; `fn` returning `false` halts it.
- *
- * Returns `false` when coverage was INCOMPLETE — a client's struct list
- * was missing or a range start could not be located — so the caller can
- * fall back to an all-consumers/opaque answer instead of trusting a
- * partial walk. `clientsOf` throws first when the store itself is absent.
- */
-export declare const walkIdSet: (Y: EngineApi, doc: EngineDoc, idSet: IdSetLike, fn: (struct: StoreStruct, from: number, to: number) => boolean | void) => boolean;
+ * Walk every struct the range `client:clock`, `len` units, covers, in clock
+ * order: `fn(struct, from, to)` gets the struct and the clock range `[from,
+ * to)` of it the range covers (a struct can reach past it). The walk never
+ * splits a struct; a client or a clock the store lacks walks nothing.
+ */
+export declare const walkRange: (Y: EngineApi, doc: EngineDoc, client: number, clock: number, len: number, fn: (struct: StoreStruct, from: number, to: number) => void) => void;
+/** Walk every struct an IdSet covers, in (client, clock) order (`walkRange` over each range). */
+export declare const walkIdSet: (Y: EngineApi, doc: EngineDoc, idSet: IdSetLike, fn: (struct: StoreStruct, from: number, to: number) => void) => void;
 /**
  * The id the local `redone` chain leads `id` to: the copy an undo or redo
  * on THIS replica re-created of a deleted item (redo copies chain), or `id`

package/dist/crdt/structs.js

@@ -50,51 +50,32 @@ export const structAt = (Y, structs, clock) => {
     }
 };
 /**
- * Walk every struct an IdSet covers, in (client, clock) order: `fn(struct,
- * from, to)` gets the struct and the clock range `[from, to)` of it the set
- * covers (a struct can reach past a range a diff of two id sets cut). The
- * walk never splits a struct; `fn` returning `false` halts it.
- *
- * Returns `false` when coverage was INCOMPLETE — a client's struct list
- * was missing or a range start could not be located — so the caller can
- * fall back to an all-consumers/opaque answer instead of trusting a
- * partial walk. `clientsOf` throws first when the store itself is absent.
- */
-export const walkIdSet = (Y, doc, idSet, fn) => {
-    const clients = clientsOf(doc);
-    let complete = true;
-    let stopped = false;
-    idSet.clients.forEach((ranges, client) => {
-        if (stopped)
-            return;
-        const structs = clients.get(client);
-        if (structs === undefined) {
-            complete = false;
-            return;
-        }
-        for (const r of ranges.getIds()) {
-            const end = r.clock + r.len;
-            let i;
-            try {
-                i = Y.findIndexSS(structs, r.clock);
-            }
-            catch {
-                complete = false;
-                continue;
-            }
-            for (; i < structs.length; i++) {
-                const s = structs[i];
-                if (s.id.clock >= end)
-                    break;
-                if (fn(s, Math.max(r.clock, s.id.clock), Math.min(end, s.id.clock + s.length)) === false) {
-                    stopped = true;
-                    return;
-                }
-            }
-        }
-    });
-    return complete;
+ * Walk every struct the range `client:clock`, `len` units, covers, in clock
+ * order: `fn(struct, from, to)` gets the struct and the clock range `[from,
+ * to)` of it the range covers (a struct can reach past it). The walk never
+ * splits a struct; a client or a clock the store lacks walks nothing.
+ */
+export const walkRange = (Y, doc, client, clock, len, fn) => {
+    const structs = clientsOf(doc).get(client) ?? [];
+    const end = clock + len;
+    let i = structs.length;
+    try {
+        if (clock < end)
+            i = Y.findIndexSS(structs, clock);
+    }
+    catch {
+        // past the client's clock: nothing to walk
+    }
+    for (; i < structs.length && structs[i].id.clock < end; i++) {
+        const s = structs[i];
+        fn(s, Math.max(clock, s.id.clock), Math.min(end, s.id.clock + s.length));
+    }
 };
+/** Walk every struct an IdSet covers, in (client, clock) order (`walkRange` over each range). */
+export const walkIdSet = (Y, doc, idSet, fn) => idSet.clients.forEach((ranges, client) => {
+    for (const r of ranges.getIds())
+        walkRange(Y, doc, client, r.clock, r.len, fn);
+});
 /**
  * The id the local `redone` chain leads `id` to: the copy an undo or redo
  * on THIS replica re-created of a deleted item (redo copies chain), or `id`

package/dist/crdt/text/index/build.d.ts

@@ -10,7 +10,6 @@
  */
 import type { EngineDoc, EngineNode, EngineTransaction } from '../../engine-api.js';
 import { type BlockId, type BlockRec, type ChildSlot, type DisplayOwnership, type ResolvedPlacement } from '../../placement/model.js';
-import { type IdSetLike } from '../../structs.js';
 import { type LiveRow, type RowItem } from '../rows.js';
 import type { ContentRun, RunView } from '../runs.js';
 import { type Cached } from './shared.js';
@@ -18,8 +17,7 @@ import { type Claim, type Owner, type Stream } from '../model.js';
 import { type Edge, type SlotRef } from '../../placement/resolve.js';
 export type TextEdit = {
     item: RowItem;
-    len: number;
-    del: boolean;
+    n: number;
 };
 export type TextEdits = {
     edits: TextEdit[];
@@ -70,13 +68,9 @@ export type Published = {
 };
 /** A transaction as the fold reads it. */
 export type Tx = {
-    insertSet?: IdSetLike;
-    deleteSet?: IdSetLike;
     changed?: EngineTransaction['changed'];
-    /** The visibility changes hold records made, in order (fork patch YP20). */
-    holds?: number[];
-    /** The units whose mover changed, in order (fork patch YP22). */
-    moves?: number[];
+    /** What the transaction did to items, in order: per item `kind, client, clock, len` (fork patch YP33). */
+    log?: number[];
 };
 /** The index's self-checks (`indexChecks`), run after each fold and each report. */
 export type SelfChecks = {

package/dist/crdt/text/index/build.js

@@ -1,6 +1,6 @@
 import { bySlot, childrenIndex, displaySlotOf, documentOrder, REGISTRY_KEY } from '../../placement/model.js';
 import { CONTENT, CONTENT_NODE, DOC_DATA_ROOT, hasDeleteMark, hasWithdrawMark, isNodeLike, NONCE } from '../../schema.js';
-import { changedUnder, clientsOf, engineOps, firstItem, itemOf, queuedTransactions, sequenceLength, structAt, walkIdSet } from '../../structs.js';
+import { changedUnder, engineOps, firstItem, itemOf, queuedTransactions, sequenceLength, walkRange } from '../../structs.js';
 import { gapOfItem, headOf, placeRow, rowLength, rowOf, segmentAt, segmentClaims, segmentOfCut, segmentOfGap, shiftGap, streamOfSegment } from '../rows.js';
 import { addTo, CONTENT_ATTR, DATA_SEQ_FACET, dataOf, dropFrom, EMPTY_IDS, EMPTY_RUNS, ENTRY_FACET, facetOf, indexChecks, keyOf, runEquals, sameShape, SEQ_FACET, typeAttr } from './shared.js';
 import { cloneJsonSafe, sameIds } from '../../../utils/json.js';
@@ -1782,7 +1782,6 @@ const buildIndex = (doc) => {
     // THE fold: one pass over a transaction's changed `(type, parentSub)` pairs
     // into the index, once at commit and, for read-your-writes, over the
     // pending part of every transaction whose commit fold has not run.
-    const ops = engineOps(Y);
     const NO_EDITS = Object.freeze({
         edits: [],
         scan: false,
@@ -1797,26 +1796,28 @@ const buildIndex = (doc) => {
                 return true;
         return false;
     };
-    /** The struct holding id `client:clock` (unsplit), `null` when the store holds none. */
-    const structOf = (client, clock) => structAt(Y, clientsOf(doc).get(client) ?? [], clock);
     /**
-     * The edits the id sets `ins`/`del`, the hold log `log` and the move log
-     * `moves` (what the fold has not folded yet) hold: per text, its edits
-     * (a log entry is a unit a hold record hid or showed, fork patch YP20:
-     * `client, clock, ±len`, in order); per sequence, what changed in it
-     * (`seq`): the slots written and removed, the records written and
-     * removed and the units whose mover changed name the blocks to re-place.
-     * Reading the sequences writes the slot map (the slots written and
-     * removed, `putSlot`) and lists the ids whose home to read again
-     * (`rehome`).
+     * What a transaction's log past a read's cursor did (fork patch YP33:
+     * per run of items `kind, client, clock, len`, in order), in one pass: per text
+     * (`texts`), its edits (the units each item showed or hid, in order); per
+     * sequence (`seqs`), what changed in it: the slots written and removed, the
+     * records written and removed and the units whose mover changed name
+     * the blocks to re-place; with `pairs` (a read's fold), the `(type, key)`
+     * pairs it changed, and the structs it named (`structs`). Reading the sequences writes the
+     * slot map (the slots written and removed, `putSlot`) and lists the ids
+     * whose home to read again (`rehome`).
      */
-    const makeEditIndex = (ins, del, log = [], moves = []) => {
-        let seqs;
+    const makeEditIndex = (log, [from, seen], pairs) => {
+        const texts = new Map();
+        const seqs = new Map();
         const rehome = new Set();
-        const seqOf = (node) => {
-            return getOr(seqs, node, () => ({ blocks: new Set(), data: false }));
+        let structs = 0;
+        const seqOf = (node) => getOr(seqs, node, () => ({ blocks: new Set(), data: false }));
+        const note = (s) => {
+            if (pairs && isNodeLike(s.parent))
+                getOr(pairs, s.parent, () => new Set()).add(s.parentSub);
         };
-        /** Note unit `c:k` (`value`) of the sequence of `node`: a block slot names its block, a data slot its data. */
+        /** Note unit `c:k` (`value`) of a sequence: a block slot names its block, a data slot its data. */
         const noteUnit = (e, owner, value, c, k, inserted) => {
             if (isBlockSlot(value)) {
                 e.blocks.add(slotOwner(registry, kept, value.b, c));
@@ -1828,102 +1829,58 @@ const buildIndex = (doc) => {
             else if (isDataSlot(value))
                 e.data = true;
         };
-        const visitSeq = (s, from, to, inserted) => {
-            const parent = s.parent;
-            if (s.parentSub !== null || !isNodeLike(parent) || parent.name === CONTENT_NODE)
-                return;
-            const e = seqOf(parent);
-            const owner = ownerOfNode(registry, kept, parent);
-            const it = s;
-            if (it.content === undefined)
-                return;
-            if (isRecord(it)) {
-                const ids = it.content.ids;
-                for (let i = 0; i < ids.length; i += 3)
-                    for (let j = 0; j < ids[i + 2]; j++) {
-                        const u = unitOf(doc, { c: ids[i], k: ids[i + 1] + j });
-                        if (u !== null)
-                            noteUnit(e, owner, u.value, ids[i], ids[i + 1] + j, null);
-                    }
-            }
-            else if (it.content.arr !== undefined)
-                for (let k = from; k < to; k++)
-                    noteUnit(e, owner, it.content.arr[k - s.id.clock], s.id.client, k, inserted);
-        };
-        const buildSeqs = () => {
-            if (seqs !== undefined)
-                return seqs;
-            seqs = new Map();
-            if (ins === undefined || del === undefined)
-                return seqs;
-            walkIdSet(Y, doc, ins, (s, from, to) => visitSeq(s, from, to, true));
-            walkIdSet(Y, doc, del, (s, from, to) => visitSeq(s, from, to, false));
-            for (let i = 0; i < moves.length; i += 3) {
-                const s = structOf(moves[i], moves[i + 1]);
-                if (s === null)
-                    continue;
-                visitSeq(s, moves[i + 1], moves[i + 1] + moves[i + 2], null);
-                // Where the unit shows now: that sequence changed too.
+        /** Walk `n` units of entry `i` from clock `k` (`n`'s sign is the entry's). */
+        const run = (i, k, n) => {
+            const kind = log[i];
+            walkRange(Y, doc, log[i + 1], k, Math.abs(n), (s, a, b) => {
+                structs++;
+                note(s);
+                // A unit a record moved: where it shows now changed too.
                 const mover = s.mover;
-                if (mover)
+                if (mover) {
+                    note(mover);
                     seqOf(mover.parent);
-            }
-            return seqs;
-        };
-        let built;
-        const build = () => {
-            if (built !== undefined)
-                return built;
-            if (ins === undefined || del === undefined)
-                return (built = null);
-            const out = new Map();
-            const edit = (s, from, to, deleted) => {
+                }
                 const parent = s.parent;
-                if (s.parentSub !== null || !isNodeLike(parent))
+                const it = s;
+                if (s.parentSub !== null || !isNodeLike(parent) || it.content === undefined)
+                    return;
+                if (parent.name === CONTENT_NODE) {
+                    if (kind > 1)
+                        return;
+                    const e = getOr(texts, parent, () => ({ edits: [], scan: false, opaque: false }));
+                    // A format marker moves no unit; its effect reaches past the edit.
+                    if (s.countable !== true)
+                        e.opaque = true;
+                    else if (holdsBoundary(s, a, b))
+                        e.scan = true;
+                    else
+                        e.edits.push({ item: s, n: n < 0 ? a - b : b - a });
                     return;
-                const e = getOr(out, parent, () => ({ 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);
-                if (holdsBoundary(s, from, to))
-                    return void (e.scan = true);
-                e.edits.push({ item: s, len: to - from, del: deleted });
-            };
-            const visit = (idSet, deleted) => walkIdSet(Y, doc, idSet, (s, from, to) => {
-                // Written and removed (or held) within the fold: nothing moved.
-                if (!(deleted ? ins.has(s.id.client, from) : s.deleted))
-                    edit(s, from, to, deleted);
-            });
-            // In order, after the inserts and before the deletes (each gap then
-            // holds what an edit takes); a unit written within the fold shows or
-            // not as its insert says.
-            const held = () => {
-                for (let i = 0; i < log.length; i += 3) {
-                    const s = structOf(log[i], log[i + 1]);
-                    if (s === null)
-                        return false;
-                    const n = log[i + 2];
-                    if (!ins.has(log[i], log[i + 1]))
-                        edit(s, log[i + 1], log[i + 1] + Math.abs(n), n < 0);
                 }
-                return true;
-            };
-            built = visit(ins, false) && held() && visit(del, true) ? out : null;
-            return built;
-        };
-        return {
-            /** `node`'s edits (`null`: unknown — rescan, every consumer recomputes). */
-            text: (node) => {
-                const map = build();
-                return map === null ? null : (map.get(node) ?? NO_EDITS);
-            },
-            /** What changed in `node`'s sequence (`undefined`: nothing). */
-            seq: (node) => buildSeqs().get(node),
-            /** The sequences the fold changed. */
-            seqNodes: () => buildSeqs().keys(),
-            /** The ids whose home to read again (their slots changed). */
-            rehome
+                const e = seqOf(parent);
+                const owner = ownerOfNode(registry, kept, parent);
+                const inserted = kind > 1 ? null : n > 0;
+                if (isRecord(it)) {
+                    const ids = it.content.ids;
+                    for (let i = 0; i < ids.length; i += 3)
+                        for (let j = 0; j < ids[i + 2]; j++) {
+                            const u = unitOf(doc, { c: ids[i], k: ids[i + 1] + j });
+                            if (u !== null)
+                                noteUnit(e, owner, u.value, ids[i], ids[i + 1] + j, null);
+                        }
+                }
+                else if (it.content.arr !== undefined)
+                    for (let k = a; k < b; k++)
+                        noteUnit(e, owner, it.content.arr[k - s.id.clock], s.id.client, k, inserted);
+            });
         };
+        // The units the engine added to the entry a read folded last (`seen`: its length then), then the rest.
+        if (from > 0 && log[from - 1] !== seen)
+            run(from - 4, log[from - 2] + Math.abs(seen), log[from - 1] - seen);
+        for (let i = from; i < log.length; i += 4)
+            run(i, log[i + 2], log[i + 3]);
+        return { texts, seqs, structs, rehome };
     };
     const runs = (b) => {
         // Read-your-writes: fold the open transaction's pending writes first.
@@ -1986,7 +1943,7 @@ const buildIndex = (doc) => {
             ensureRec(id);
             const rec = blocks.get(id);
             // A data slot in the block's sequence: its arrays' items changed (the seq pass seeded the blocks).
-            if (kinds.has('seq') && rec && editsOf.seq(rec.node)?.data)
+            if (kinds.has('seq') && rec && editsOf.seqs.get(rec.node)?.data)
                 kinds.add('meta');
             if (kinds.has('meta') && rec) {
                 const was = rec.type;
@@ -2040,7 +1997,7 @@ const buildIndex = (doc) => {
             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)) {
+                    if (gap < 0 || !shiftGap(row, gap, e.n)) {
                         fresh = true;
                         break;
                     }
@@ -2219,7 +2176,7 @@ const buildIndex = (doc) => {
                     continue;
                 // A sequence edit of the block's own text, or a change inside one of its atoms.
                 const list = getOr(edits, id, () => []);
-                list.push(seq ? editsOf.text(type) : null);
+                list.push(seq ? (editsOf.texts.get(type) ?? NO_EDITS) : null);
             }
         }
         const ctx = {
@@ -2230,8 +2187,7 @@ const buildIndex = (doc) => {
             parents: new Set()
         };
         // The sequences (the root's, the blocks'): their slots index the blocks' homes, their changes seed the placements.
-        for (const node of editsOf.seqNodes()) {
-            const ch = editsOf.seq(node);
+        for (const [node, ch] of editsOf.seqs) {
             seqEpoch++;
             for (const b of ch.blocks)
                 placementSeeds.add(b);
@@ -2289,71 +2245,31 @@ const buildIndex = (doc) => {
         }
         return touched;
     };
-    /** Each transaction's folded part: copies of its id sets, the hold and move logs' folded lengths, and the watermark. */
+    /** Each transaction's folded part (`Cursor`). */
     const cursors = new WeakMap();
+    const NONE = [0];
+    /** Whether `log` holds entries or units past `cursor`. */
+    const past = (log, [from, seen]) => log.length !== from || log[from - 1] !== seen;
     /** The transactions whose commit fold ran. */
     const committed = new WeakSet();
-    const lengthOf = (set) => {
-        let n = 0;
-        set.clients.forEach((ranges) => {
-            for (const r of ranges.getIds())
-                n += r.len;
-        });
-        return n;
-    };
-    /** How much a transaction wrote so far: its id sets' lengths and its hold and move logs'. */
-    const watermark = (tr) => lengthOf(tr.insertSet) +
-        lengthOf(tr.deleteSet) +
-        (tr.holds?.length ?? 0) +
-        (tr.moves?.length ?? 0);
     /**
-     * Fold the pending part of `tr` — the structs its insert/delete sets
-     * gained since the last fold — before a read inside it (read-your-
-     * writes; `transaction.changed` does not grow on a second edit to an
+     * Fold the pending part of `tr` — the entries its log gained since the
+     * last fold — before a read inside it (read-your-writes;
+     * `transaction.changed` does not grow on a second edit to an
      * already-changed type).
      */
     const syncPending = (tr) => {
-        if (tr?.insertSet === undefined || tr.deleteSet === undefined)
-            return false;
-        let cursor = cursors.get(tr);
-        if (cursor === undefined)
-            cursors.set(tr, (cursor = { ins: ops.idSet(), del: ops.idSet(), holds: 0, moves: 0, mark: 0 }));
-        const mark = watermark(tr);
-        if (mark === cursor.mark)
+        const log = tr?.log;
+        const cursor = cursors.get(tr) ?? NONE;
+        if (log === undefined || !past(log, cursor))
             return false;
-        const ins = ops.diff(tr.insertSet, cursor.ins);
-        const del = ops.diff(tr.deleteSet, cursor.del);
-        const log = (tr.holds ?? []).slice(cursor.holds);
-        const moves = (tr.moves ?? []).slice(cursor.moves);
-        ops.insertInto(cursor.ins, ins);
-        ops.insertInto(cursor.del, del);
-        cursor.holds += log.length;
-        cursor.moves += moves.length;
-        cursor.mark = mark;
+        cursors.set(tr, [log.length, log[log.length - 1]]);
         for (const f of frames)
             f.wrote = true;
-        const changed = new Map();
-        const note = (s) => {
-            foldStats.structs++;
-            if (!isNodeLike(s.parent))
-                return;
-            const subs = getOr(changed, s.parent, () => new Set());
-            subs.add(s.parentSub);
-        };
-        walkIdSet(Y, doc, ins, note);
-        walkIdSet(Y, doc, del, note);
-        for (const l of [log, moves])
-            for (let i = 0; i < l.length; i += 3) {
-                const s = structOf(l[i], l[i + 1]);
-                if (s === null)
-                    continue;
-                note(s);
-                // A unit a record moved: where it shows now changed too (a held unit has no mover).
-                const mover = s.mover;
-                if (mover)
-                    note(mover);
-            }
-        fold(changed, makeEditIndex(ins, del, log, moves));
+        const pairs = new Map();
+        const edits = makeEditIndex(log, cursor, pairs);
+        foldStats.structs += edits.structs;
+        fold(pairs, edits);
         return true;
     };
     const openTx = () => doc._transaction;
@@ -2371,10 +2287,7 @@ const buildIndex = (doc) => {
                 syncPending(tr);
     };
     /** Some queued transaction holds writes no fold has seen. */
-    const unfolded = () => queuedTransactions(doc).some((tr) => !committed.has(tr) &&
-        tr.insertSet !== undefined &&
-        tr.deleteSet !== undefined &&
-        watermark(tr) !== (cursors.get(tr)?.mark ?? 0));
+    const unfolded = () => queuedTransactions(doc).some((tr) => !committed.has(tr) && tr.log !== undefined && past(tr.log, cursors.get(tr) ?? NONE));
     /**
      * The commit of a transaction that changed the registry or a node under
      * it: fold `transaction.changed` once (the report publishes from `update`).
@@ -2382,19 +2295,12 @@ const buildIndex = (doc) => {
     const onCommit = (tr) => {
         if (!changedUnder(tr, [registry]))
             return;
-        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 = ops.diff(ins, cursor.ins);
-            del = ops.diff(del, cursor.del);
-        }
-        const log = (tr.holds ?? []).slice(cursor?.holds ?? 0);
-        const moves = (tr.moves ?? []).slice(cursor?.moves ?? 0);
+        const cursor = cursors.get(tr) ?? NONE;
         cursors.delete(tr);
         committed.add(tr);
-        fold(tr.changed ?? new Map(), makeEditIndex(ins, del, log, moves));
+        fold(tr.changed ?? new Map(), makeEditIndex(tr.log ?? [], cursor));
     };
     // ══ The change report ═══════════════════════════════════════════
     // The change report: the fold against the last published index, one per