edytor 2.0.0 → 4.0.0

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

@@ -6,15 +6,16 @@
 import { readData } from '../../data.js';
 import { Y } from '../../engine.js';
 import { LIVE_WRITERS, baseIdOf, incarnationId } from '../../incarnations.js';
-import { candidatesOf } from '../../placement/model.js';
-import { CONTENT, NONCE, hasDeleteMark, isNodeLike } from '../../schema.js';
-import { changedUnder, engineOps, itemOf, queuedTransactions, sequenceLength, walkIdSet } from '../../structs.js';
-import { DEAD, isBoundary } from '../model.js';
+import { ownerOfNode, slotOwner } from '../../placement/resolve.js';
+import { isBlockSlot, isDataSlot, isRecord, unitOf } from '../../placement/slots.js';
+import { CONTENT, CONTENT_NODE, NONCE, hasDeleteMark, isNodeLike } from '../../schema.js';
+import { changedUnder, clientsOf, engineOps, itemOf, queuedTransactions, sequenceLength, structAt, walkIdSet } from '../../structs.js';
+import { DEAD, isRowMark } from '../model.js';
 import { gapOfItem, headOf, rowLength, segmentOfGap, shiftGap } from '../rows.js';
-import { CONTENT_ATTR, EMPTY_RUNS, ENTRY_FACET, facetOf, checksOf, indexChecks, sameShape, typeAttr } from './shared.js';
+import { CONTENT_ATTR, DATA_SEQ_FACET, EMPTY_RUNS, ENTRY_FACET, SEQ_FACET, facetOf, checksOf, indexChecks, sameShape, typeAttr } from './shared.js';
 /** The fold of one doc's index, over every part it folds into. */
 export const indexFold = (ix) => {
-    const { doc, registry, dataRoot, blocks, shells, textConsumers, ownerSeeds, rows, retargets, unresolved, reclaim, placementSeeds, stateSeeds, incarnations, cache, dirty, foldStats, frames, candidates, ownerOf, invalidateBlock, streamOf, streamsIn, setRow, scanRow, refreshDelims, placeHome, applyRetargets, noteKind, argParent, noteCands, kept, updateBlockRec, ensureRec, syncIncarnations, computeRuns, tableFacts } = ix;
+    const { doc, registry, dataRoot, blocks, shells, textConsumers, ownerSeeds, rows, reclaim, placementSeeds, stateSeeds, incarnations, cache, dirty, foldStats, frames, candidates, ownerOf, invalidateBlock, streamOf, streamsIn, setRow, scanRow, refreshDelims, placeHome, applyReclaims, noteKind, homeFor, putSlot, edgeParent, kept, updateBlockRec, ensureRec, syncIncarnations, computeRuns, tableFacts } = ix;
     const ops = engineOps(Y);
     const NO_EDITS = Object.freeze({
         edits: [],
@@ -26,12 +27,86 @@ export const indexFold = (ix) => {
         if (arr === undefined)
             return false;
         for (let k = from - s.id.clock; k < to - s.id.clock; k++)
-            if (isBoundary(arr[k]))
+            if (isRowMark(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) => {
+    /** 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`).
+     */
+    const makeEditIndex = (ins, del, log = [], moves = []) => {
+        let seqs;
+        const rehome = new Set();
+        const seqOf = (node) => {
+            let e = seqs.get(node);
+            if (e === undefined)
+                seqs.set(node, (e = { blocks: new Set(), data: false }));
+            return e;
+        };
+        /** Note unit `c:k` (`value`) of the sequence of `node`: 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));
+                if (inserted === null || (inserted && owner === undefined))
+                    return;
+                putSlot(value.b, { c, k }, inserted ? { parent: owner, c, k } : null);
+                rehome.add(value.b);
+            }
+            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.
+                const mover = s.mover;
+                if (mover)
+                    seqOf(mover.parent);
+            }
+            return seqs;
+        };
         let built;
         const build = () => {
             if (built !== undefined)
@@ -39,7 +114,7 @@ export const indexFold = (ix) => {
             if (ins === undefined || del === undefined)
                 return (built = null);
             const out = new Map();
-            const visit = (idSet, deleted) => walkIdSet(Y, doc, idSet, (s, from, to) => {
+            const edit = (s, from, to, deleted) => {
                 const parent = s.parent;
                 if (s.parentSub !== null || !isNodeLike(parent))
                     return;
@@ -49,20 +124,44 @@ export const indexFold = (ix) => {
                 // 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 });
+            };
+            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);
             });
-            built = visit(ins, false) && visit(del, true) ? out : null;
+            // 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;
         };
-        /** `node`'s edits (`null`: unknown — rescan, every consumer recomputes). */
-        return (node) => {
-            const map = build();
-            return map === null ? null : (map.get(node) ?? NO_EDITS);
+        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 runs = (b) => {
@@ -73,7 +172,8 @@ export const indexFold = (ix) => {
         return cache.get(b)?.runs ?? EMPTY_RUNS;
     };
     // ── the fold ─────────────────────────────────────────────────────
-    const parentOf = (id) => blocks.get(id)?.cands[0]?.p;
+    /** The owner of the sequence `id`'s slot shows in (its display edge's parent), as the engine stands. */
+    const parentOf = (id) => edgeParent(id);
     /** 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);
@@ -92,11 +192,12 @@ export const indexFold = (ix) => {
             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 foldBlock = (id, facets, edits, ctx, editsOf) => {
         const kinds = new Set();
         for (const f of facets)
             kinds.add(f === ENTRY_FACET ? 'entry' : facetOf(f));
-        const parentBefore = parentOf(id);
+        // The display parents a shell may flip by (`settle`): read while there are shells.
+        const parentBefore = shells.size > 0 ? parentOf(id) : undefined;
         if (typeof parentBefore === 'string')
             ctx.parents.add(parentBefore);
         if (kinds.has('entry') || kinds.has('structure')) {
@@ -123,12 +224,9 @@ export const indexFold = (ix) => {
         else {
             ensureRec(id);
             const rec = blocks.get(id);
-            if (kinds.has('at') && rec) {
-                const before = argParent(rec);
-                rec.cands = candidatesOf(rec.node);
-                noteCands(id, before);
-                placementSeeds.add(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)
+                kinds.add('meta');
             if (kinds.has('meta') && rec) {
                 const was = rec.type;
                 const facts = tableFacts(id, rec.data);
@@ -147,7 +245,7 @@ export const indexFold = (ix) => {
                     stateSeeds.add(id);
             }
         }
-        const parentAfter = parentOf(id);
+        const parentAfter = shells.size > 0 ? parentOf(id) : undefined;
         if (typeof parentAfter === 'string')
             ctx.parents.add(parentAfter);
         if (kinds.has('content'))
@@ -195,7 +293,7 @@ export const indexFold = (ix) => {
                 const next = scanRow(home);
                 const same = next !== undefined && row !== undefined && next.key === row.key;
                 if (same)
-                    [next.cuts, next.head] = [row.cuts, row.head];
+                    [next.cuts, next.heads, next.head] = [row.cuts, row.heads, row.head];
                 setRow(home, next, ctx.named);
                 if (!same)
                     homes.add(home);
@@ -269,8 +367,10 @@ export const indexFold = (ix) => {
             if (holdsUnit(id))
                 hold(id);
         for (const [id, rec] of blocks) {
-            const p = rec.cands[0]?.p;
-            if (!shells.has(id) && !rec.deleted && typeof p === 'string' && shells.has(p))
+            if (shells.has(id) || rec.deleted)
+                continue;
+            const p = parentOf(id);
+            if (typeof p === 'string' && shells.has(p))
                 hold(p);
         }
         for (let id = up.pop(); id !== undefined; id = up.pop()) {
@@ -327,8 +427,9 @@ export const indexFold = (ix) => {
                         return null;
                     id = incarnationId(id, item);
                 }
+                // The block's own sequence (its slots and records: `SEQ_FACET`), or one of its attrs.
                 if (below === null)
-                    return [id, sub === CONTENT ? CONTENT_ATTR : (sub ?? '?'), false];
+                    return [id, sub === CONTENT ? CONTENT_ATTR : sub === null ? SEQ_FACET : sub, false];
                 const facet = below._item?.parentSub ?? CONTENT;
                 return [id, facet, sub === null && below === type && facet === CONTENT];
             }
@@ -361,7 +462,7 @@ export const indexFold = (ix) => {
                 let list = edits.get(id);
                 if (list === undefined)
                     edits.set(id, (list = []));
-                list.push(seq ? editsOf(type) : null);
+                list.push(seq ? editsOf.text(type) : null);
             }
         }
         const ctx = {
@@ -371,15 +472,42 @@ export const indexFold = (ix) => {
             table: false,
             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);
+            ix.seqEpoch++;
+            for (const b of ch.blocks)
+                placementSeeds.add(b);
+            if (ch.blocks.size > 0 || ch.data)
+                derived = true;
+            const owner = ownerOfNode(registry, kept, node);
+            if (typeof owner === 'string') {
+                let facets = touched.get(owner);
+                if (facets === undefined)
+                    touched.set(owner, (facets = new Set()));
+                facets.add(SEQ_FACET);
+                if (ch.data)
+                    facets.add(DATA_SEQ_FACET);
+            }
+        }
+        // A slot's block, and its losing incarnations, re-read their home (which slot is whose).
+        for (const b of editsOf.rehome)
+            for (const id of [b, ...(incarnations.get(b) ?? [])]) {
+                const rec = blocks.get(id);
+                if (rec === undefined)
+                    continue;
+                const home = homeFor(id);
+                if (home?.c !== rec.home?.c || home?.k !== rec.home?.k)
+                    placementSeeds.add(id);
+                rec.home = home;
+            }
         for (const [id, facets] of touched) {
-            foldBlock(id, facets, edits.get(id) ?? [], ctx);
+            foldBlock(id, facets, edits.get(id) ?? [], ctx, editsOf);
             derived ||= [...facets].some((f) => f === ENTRY_FACET || facetOf(f) !== 'ignore');
         }
         foldTexts(ctx);
-        for (const h of unresolved)
-            retargets.add(h);
-        if (retargets.size > 0 || reclaim.size > 0)
-            applyRetargets(ctx);
+        if (reclaim.size > 0)
+            applyReclaims(ctx);
         if (shells.size > 0)
             settle(ctx.table ? shells : [...touched.keys(), ...ctx.parents, ...editedStreams(ctx)], ctx);
         for (const b of ctx.invalidated)
@@ -406,7 +534,7 @@ export const indexFold = (ix) => {
         }
         return touched;
     };
-    /** Each transaction's folded part: copies of its id sets, and their lengths (the watermark). */
+    /** Each transaction's folded part: copies of its id sets, the hold and move logs' folded lengths, and the watermark. */
     const cursors = new WeakMap();
     /** The transactions whose commit fold ran. */
     const committed = new WeakSet();
@@ -418,6 +546,11 @@ export const indexFold = (ix) => {
         });
         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-
@@ -429,14 +562,18 @@ export const indexFold = (ix) => {
             return false;
         let cursor = cursors.get(tr);
         if (cursor === undefined)
-            cursors.set(tr, (cursor = { ins: ops.idSet(), del: ops.idSet(), mark: 0 }));
-        const mark = lengthOf(tr.insertSet) + lengthOf(tr.deleteSet);
+            cursors.set(tr, (cursor = { ins: ops.idSet(), del: ops.idSet(), holds: 0, moves: 0, mark: 0 }));
+        const mark = watermark(tr);
         if (mark === cursor.mark)
             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;
         for (const f of frames)
             f.wrote = true;
@@ -452,7 +589,18 @@ export const indexFold = (ix) => {
         };
         walkIdSet(Y, doc, ins, note);
         walkIdSet(Y, doc, del, note);
-        fold(changed, makeEditIndex(ins, del));
+        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));
         return true;
     };
     const openTx = () => doc._transaction;
@@ -473,7 +621,7 @@ export const indexFold = (ix) => {
     const unfolded = () => queuedTransactions(doc).some((tr) => !committed.has(tr) &&
         tr.insertSet !== undefined &&
         tr.deleteSet !== undefined &&
-        lengthOf(tr.insertSet) + lengthOf(tr.deleteSet) !== (cursors.get(tr)?.mark ?? 0));
+        watermark(tr) !== (cursors.get(tr)?.mark ?? 0));
     /**
      * The commit of a transaction that changed the registry or a node under
      * it: fold `transaction.changed` once (the report publishes from `update`).
@@ -489,9 +637,11 @@ export const indexFold = (ix) => {
             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);
         cursors.delete(tr);
         committed.add(tr);
-        fold(tr.changed ?? new Map(), makeEditIndex(ins, del));
+        fold(tr.changed ?? new Map(), makeEditIndex(ins, del, log, moves));
     };
     return {
         runs,

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

@@ -1,4 +1,4 @@
-import { encodeRank, RANK_VMAX } from '../../placement/rank.js';
+import { cellKey, LAST_CELL, unlistedCellKey } from '../../placement/keys.js';
 import { listedColumns, unlistedRank } from '../../tables.js';
 /** The layout rules of one doc's index, over its state. */
 export const indexLayout = (ix) => {
@@ -77,8 +77,8 @@ export const indexLayout = (ix) => {
     /**
      * The rank cell `id` displays at in row `row` (`table.columns`): its
      * column's position in the table holding the row, so every row shows its
-     * cells in the table's column order whatever their placements (a rank
-     * of one segment, the position, ties by block id); a withdrawn cell of a
+     * cells in the table's column order whatever their placements (a key of
+     * the position, ties by block id); a withdrawn cell of a
      * column the table no longer lists after them, its column's place among
      * those fixed by its id (`unlistedRank`); any other cell of no listed
      * column last (it does not display, `table.cell`).
@@ -95,11 +95,8 @@ export const indexLayout = (ix) => {
         const column = columnOf(id);
         const at = column === undefined ? undefined : index.get(column);
         if (at === undefined && column !== undefined && ix.shells.has(id))
-            return encodeRank([
-                { v: RANK_VMAX - 1, t: 0 },
-                { v: unlistedRank(column), t: 0 }
-            ]);
-        return encodeRank([{ v: at ?? RANK_VMAX, t: 0 }]);
+            return unlistedCellKey(unlistedRank(column));
+        return at === undefined ? LAST_CELL : cellKey(at);
     };
     /**
      * The table rules (`table.*`), in the same pass: a cell displays only in

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

@@ -3,36 +3,44 @@
  * ownership the display reads (`ownShim`), and THE shown-kind rule
  * (`typeOf`).
  *
- * 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.
+ * A structural change re-decides only what it can change: the display
+ * edge of the blocks whose slot, record or mover changed (fork patch
+ * YP22), 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. A
+ * block's candidate edges are its live move records, strongest first, then
+ * its home slot; it shows at the first that closes no cycle through the
+ * accepted edges (`settle`): the later move wins, and the block whose edge
+ * is the oldest of a cycle falls back to its next candidate, back where it
+ * stood (its previous record, else home; the root's tail only when every
+ * candidate closes a cycle), so a cycle resolves locally: no global pass.
+ * The first build places every block the same way (their unique acyclic
+ * acceptance, whatever the order; the tests' greedy rebuild,
+ * `src/tests/oracles/placements.ts`, is what the self-checks compare). A
+ * placed block's order key is found from its sequence neighbours
+ * (`placement/keys.ts`), never by walking the parent's sequence; a rebuild
+ * keys every list once, in its sequence's order. The layout rules re-run
+ * only on the layouts a change reaches.
  */
-import { type BlockId, type BlockRec, type DisplayOwnership, type DocOrder } from '../../placement/model.js';
+import { type BlockId, type DisplayOwnership, type DocOrder } from '../../placement/model.js';
+import { homeOf, type SlotRef } from '../../placement/resolve.js';
+import { type Unit } from '../../placement/slots.js';
+import type { EngineNode } from '../../engine-api.js';
 import type { IndexClaims } from './claims.js';
 import type { IndexLayout } from './layout.js';
 import type { IndexState } from './state.js';
 import type { IndexStreams } from './streams.js';
 /** Placement maintenance of one doc's index, over its state, claims, streams and layout rules. */
 export declare const indexPlacement: (ix: IndexState & IndexClaims & IndexStreams & IndexLayout) => {
-    ranker: {
-        rank: (id: BlockId, parent: BlockId | null, rank: string) => string;
-        regroup: (home: BlockId) => Set<BlockId>;
-        forget: (home?: BlockId) => void;
-    };
     ownShim: DisplayOwnership;
     own0: DisplayOwnership;
     noteKind: (id: BlockId) => void;
-    argParent: (rec: BlockRec | undefined) => BlockId | null | undefined;
-    noteCands: (id: BlockId, before: BlockId | null | undefined) => void;
+    homeFor: (id: BlockId) => ReturnType<typeof homeOf>;
+    putSlot: (b: BlockId, u: Unit, ref: SlotRef | null) => void;
+    edgeParent: (id: BlockId) => BlockId | null | undefined;
     noteFollowing: (id: BlockId) => void;
     ensurePlacements: () => void;
+    reslot: (node: EngineNode) => void;
     typeOf: (id: BlockId) => string;
     order: () => DocOrder;
 };