edytor 3.0.0 → 5.0.0

package/dist/crdt/purge.js

@@ -1,11 +1,28 @@
-import { view as modelView } from './placement/model.js';
-import { purgeStreams } from './text/model.js';
-import { AT, BLOCK_ATTR_ROOT, DATA, DATA_LEAF_PREFIX, DEL_PREFIX, HORIZON_ATTR, HORIZON_ROOT, isNodeLike, REC_PREFIX, REGISTRY_KEY, WITHDRAW_PREFIX } from './schema.js';
-import { bindDeletes } from './text/deletes.js';
-import { deleteIndex } from './text/delete-index.js';
+import { recordsOf, registryOf, view as modelView } from './placement/model.js';
+import { removeUnit, unitOf } from './placement/slots.js';
+import { deleteClaims, purgeStreams, scanText } from './text/model.js';
+import { BLOCK_ATTR_ROOT, DATA, DATA_LEAF_PREFIX, DEL_PREFIX, HORIZON_ATTR, HORIZON_ROOT, REGISTRY_KEY, RELEASE_ROOT, SUGGEST_ROOT, TEXT_DELETES_ROOT, WITHDRAW_PREFIX } from './schema.js';
 import { baseIdOf, isIncarnationId } from './incarnations.js';
-import { attrItems, firstItem } from './structs.js';
+import { suggestionsOf } from './doc/suggest.js';
+import { attrItems, dropSearchMarkers, engineOps, firstItem, holdsIds } from './structs.js';
 const mapOf = (node) => attrItems(node);
+/** The clock a suggestion's record opened at (its writer's clocks it owns start there). */
+const clockOf = (rec) => rec.start ?? 0;
+/**
+ * The ended histories a document holds (`hist.release.end`): per writer,
+ * the clock its latest live release record ended at (what it wrote below
+ * it is released).
+ */
+export const releasesOf = (doc) => {
+    const out = new Map();
+    for (let it = firstItem(doc.get(RELEASE_ROOT)); it; it = it.right) {
+        if (it.deleted)
+            continue;
+        const { client, clock } = it.id;
+        out.set(client, Math.max(out.get(client) ?? 0, clock + it.length - 1));
+    }
+    return out;
+};
 /** The horizon a document holds (`null`: never purged). */
 export const readHorizon = (doc) => {
     const h = doc.get(HORIZON_ROOT).getAttr(HORIZON_ATTR);
@@ -14,73 +31,76 @@ export const readHorizon = (doc) => {
         : null;
 };
 export const bindPurge = (Y) => {
-    const D = bindDeletes(Y);
-    const { rootSpans, holders, dropMarks, recordsIn, copiesOf, liveRoots, forget, collect } = deleteIndex(Y);
+    const ops = engineOps(Y);
+    /** The live hold records of `doc`, one per held range. */
+    const holdsOf = (doc) => {
+        const out = [];
+        for (let it = firstItem(doc.get(TEXT_DELETES_ROOT)); it; it = it.right) {
+            const ids = it.content.ids;
+            if (it.deleted || ids === undefined)
+                continue;
+            for (let j = 0; j < ids.length; j += 3)
+                out.push({
+                    client: it.id.client,
+                    clock: it.id.clock + j / 3,
+                    c: ids[j],
+                    k: ids[j + 1],
+                    n: ids[j + 2]
+                });
+        }
+        return out;
+    };
     /**
-     * Whether every live mark holding a character of `spans` was written
-     * where `old` says (a withdrawn block's content was deleted
-     * before the horizon). Characters no mark holds count as old.
+     * Whether every live record holding an item of `spans` was written where
+     * `old` says (a withdrawn block's content was deleted before the
+     * horizon). Items no record holds count as old.
      */
-    const heldBefore = (doc, spans, old) => {
-        const s = D.state(doc);
-        return spans
-            .flatMap((sp) => rootSpans(s, sp))
-            .every((r) => holders(s, r).every((mark) => old(mark.client, mark.clock)));
-    };
+    const heldBefore = (holds, spans, old) => holds.every((h) => old(h.client, h.clock) ||
+        !spans.some((sp) => sp.c === h.c && sp.k < h.k + h.n && h.k < sp.k + sp.n));
     /**
-     * The text's part (`room.purge.what`), inside the purge
-     * transaction: delete every text delete mark record `old` names, and
-     * every restoration record `old` names whose copies are all deleted
-     * and that no remaining mark holds; its copies are forgotten (the
-     * `gcFilter` no longer keeps them) and collected. Writes no mark.
+     * The text's part (`room.purge.what`), inside the purge transaction:
+     * every hold record `old` names is deleted with what it holds (a real
+     * delete: the engine collects it everywhere; a newer record holding the
+     * same text has nothing to show again, the older delete is past the
+     * horizon). A record whose text the room lacks (lost, coming back with
+     * its author) is kept: it holds that text when it returns.
      */
     const purgeText = (doc, old) => {
-        const s = D.state(doc);
-        const tr = s.doc._transaction;
-        if (tr === null)
+        const tr = doc._transaction;
+        if (tr == null)
             throw new Error('purge: outside a transaction');
-        const spans = [];
-        const dropped = [];
-        for (let it = firstItem(s.marks); it; it = it.right)
-            if (!it.deleted)
-                for (let j = 0; j < it.length; j++) {
-                    const r = { client: it.id.client, clock: it.id.clock + j };
-                    if (!old(r.client, r.clock))
-                        continue;
-                    dropped.push(r);
-                    const last = spans[spans.length - 1];
-                    if (last !== undefined && last.c === r.client && last.k + last.n === r.clock)
-                        last.n++;
-                    else
-                        spans.push({ c: r.client, k: r.clock, n: 1 });
-                }
-        dropMarks(s, dropped);
-        const marks = dropped.length;
-        D.remove(tr, spans);
-        const doomed = [];
-        attrItems(s.restored).forEach((it, key) => {
-            if (it.deleted || !old(it.id.client, it.id.clock))
-                return;
-            const [record, bytes] = recordsIn(it, null)[0] ?? [];
-            if (bytes === undefined)
+        const doomed = holdsOf(doc).filter((h) => old(h.client, h.clock) && holdsIds(doc, h.c, h.k, h.n));
+        const ids = (spans) => {
+            const set = ops.idSet();
+            for (const sp of spans)
+                set.add(sp.c, sp.k, sp.n);
+            return set;
+        };
+        ops.iterate(tr, ids(doomed), (it) => {
+            if (it.removed !== false)
                 return;
-            const copies = copiesOf(record, bytes);
-            const dead = copies.every((e) => liveRoots(s, { c: e.c, k: e.k, n: e.n, rk: e.k }).length === 0 &&
-                holders(s, { c: e.rc, k: e.rk, n: e.n }).length === 0);
-            if (dead)
-                doomed.push({ key, copies });
+            it.delete(tr);
+            dropSearchMarkers(it.parent);
         });
-        for (const { key, copies } of doomed) {
-            s.restored.deleteAttr(key);
-            forget(s, copies);
-            collect(s, tr, copies);
-        }
-        return { marks, records: doomed.length };
+        // The records are read first and deleted after: deleting one releases
+        // its holds, which can split items of the store the walk is reading
+        // (its writer's own text), and the walk would then visit the structs
+        // written before the record (a delete mark beside it) as if they were it.
+        const records = [];
+        ops.iterate(tr, ids(doomed.map((h) => ({ c: h.client, k: h.clock, n: 1 }))), (it) => {
+            records.push(it);
+        });
+        for (const it of records)
+            it.delete(tr);
+        return doomed.length;
     };
     /**
      * Purge from `doc` (through `facade`, the facade over it) what was
-     * deleted before `horizon`, and write the horizon record. Runs inside the
-     * caller's transaction.
+     * deleted before `horizon`, and what the sessions whose history ended
+     * deleted (`hist.release.end`), and write the horizon record. With no
+     * horizon (`null`: the room's tick found none due), only the ended
+     * sessions' deletes go, and the horizon record is left as it is. Runs
+     * inside the caller's transaction.
      */
     const purge = (doc, facade, horizon) => {
         const report = {
@@ -88,13 +108,19 @@ export const bindPurge = (Y) => {
             emptied: 0,
             marks: 0,
             records: 0,
-            candidates: 0,
             claims: 0,
-            merged: 0
+            merged: 0,
+            released: 0,
+            suggestions: 0
         };
-        const vector = Y.decodeStateVector(horizon.sv);
+        const vector = horizon === null
+            ? new Map()
+            : Y.decodeStateVector(horizon.sv);
         const old = (client, clock) => clock < (vector.get(client) ?? 0);
-        const oldItem = (item) => item !== undefined && !item.deleted && old(item.id.client, item.id.clock);
+        // A delete of an ended session is past the horizon (`hist.release.end`).
+        const releases = releasesOf(doc);
+        const freed = (client, clock) => old(client, clock) || clock < (releases.get(client) ?? 0);
+        const oldItem = (item) => item !== undefined && !item.deleted && freed(item.id.client, item.id.clock);
         const view = modelView(doc);
         const { blocks, own, placements } = view;
         const marks = (node, prefix) => [...node.attrKeys()]
@@ -120,6 +146,35 @@ export const bindPurge = (Y) => {
             }
             return out;
         };
+        /** The paired mark items of `s`'s region whose start and end both lie in it. */
+        const regionMarks = (s) => {
+            const opened = new Map();
+            const out = [];
+            let at = 0;
+            let inside = s.start === 0;
+            for (let it = firstItem(s.text); it !== null; it = it.right) {
+                const live = !it.deleted && it.countable !== false;
+                if (live && at >= s.end)
+                    break;
+                const { key, value } = it.content;
+                if (inside && !it.deleted && typeof key === 'string' && Array.isArray(value)) {
+                    const role = key.charCodeAt(0);
+                    if (role === 1)
+                        opened.set(`${value[2]}:${value[3]}`, it);
+                    else if (role === 2) {
+                        const start = opened.get(`${value[0]}:${value[1]}`);
+                        if (start !== undefined)
+                            out.push(start, it);
+                    }
+                }
+                if (live) {
+                    at += it.length;
+                    if (at === s.start)
+                        inside = true;
+                }
+            }
+            return out;
+        };
         const dead = new Set();
         const shells = [];
         for (const [id, rec] of blocks) {
@@ -136,7 +191,8 @@ export const bindPurge = (Y) => {
                 shells.push(id);
         }
         // A withdrawn block is hidden since it last held something: what its
-        // stream held was deleted, and its children left, before the horizon.
+        // stream held was deleted, and its children left (the move that took
+        // them is old), before the horizon.
         const children = new Map();
         const add = (map, key, id) => {
             const list = map.get(key);
@@ -145,23 +201,27 @@ export const bindPurge = (Y) => {
             else
                 list.push(id);
         };
-        for (const [id, rec] of blocks)
-            for (const c of rec.cands)
-                if (typeof c.p === 'string')
-                    add(children, c.p, id);
-        const winnerOld = (rec) => oldItem(mapOf(rec.node.getAttr(AT))?.get(rec.cands[0]?.key));
+        for (const [id, rec] of blocks) {
+            const p = rec.home?.parent;
+            if (typeof p === 'string')
+                add(children, p, id);
+        }
+        /** The block's display edge is old: it shows at its home slot (written with the block), or at an old record. */
+        const edgeOld = (id) => {
+            const home = blocks.get(id)?.home;
+            const r = home ? (unitOf(doc, home)?.item.mover ?? null) : null;
+            return r === null ? true : old(r.id.client, r.id.clock);
+        };
+        const holds = shells.length > 0 ? holdsOf(doc) : [];
         for (let grew = true; grew;) {
             grew = false;
             for (const id of shells) {
                 if (dead.has(id))
                     continue;
                 const s = own.streamOf(id);
-                if (s !== undefined && !heldBefore(doc, regionSpans(s), old))
+                if (s !== undefined && !heldBefore(holds, regionSpans(s), freed))
                     continue;
-                const left = (children.get(id) ?? []).every((child) => {
-                    const rec = blocks.get(child);
-                    return rec.cands[0]?.p === id ? dead.has(child) : winnerOld(rec);
-                });
+                const left = (children.get(id) ?? []).every((child) => placements.get(child)?.parent === id ? dead.has(child) : edgeOld(child));
                 if (!left)
                     continue;
                 dead.add(id);
@@ -174,8 +234,11 @@ export const bindPurge = (Y) => {
                 dead.add(id);
         // ── Which of them go whole ────────────────────────────────────────
         // A text family: the blocks with a stream in one backing text, and the
-        // block owning it. It goes whole or not at all: a stream whose
-        // delimiting block went would join the stream before it.
+        // block owning it. The block owning a text goes only with every block
+        // streaming in it (its text goes with its node). A block streaming in
+        // another's text, owning none, goes alone when one boundary names it:
+        // that boundary stays and delimits the stream the purge empties, which
+        // nobody shows (a removed key's, `text/streams.ts` `removedKeys`).
         const parent = new Map();
         const root = (id) => {
             let r = id;
@@ -205,32 +268,71 @@ export const bindPurge = (Y) => {
             if (family.every((id) => dead.has(id)))
                 for (const id of family)
                     removable.add(id);
-        // Nothing that stays may be placed under a block that goes.
+        // The live boundaries naming each block, and the keys with losing incarnations.
+        const naming = new Map();
+        for (const rec of blocks.values())
+            if (rec.content)
+                for (const b of scanText(rec.id, rec.content).bounds)
+                    if (b.m === undefined)
+                        naming.set(b.s, (naming.get(b.s) ?? 0) + 1);
+        const incarnated = new Set();
+        for (const id of blocks.keys())
+            if (isIncarnationId(id))
+                incarnated.add(baseIdOf(id));
+        const lone = new Set();
+        for (const id of dead) {
+            if (removable.has(id) || isIncarnationId(id) || incarnated.has(id))
+                continue;
+            const s = own.streamOf(id);
+            if (s === undefined || s.home === id || blocks.get(id).content !== undefined)
+                continue;
+            if (naming.get(id) !== 1)
+                continue;
+            lone.add(id);
+            removable.add(id);
+        }
+        // Nothing that stays may be placed under a block that goes, or keep its
+        // home slot in the sequence of one (the slot goes with the node).
         for (let shrank = true; shrank;) {
             shrank = false;
-            for (const [id, pl] of placements) {
-                if (removable.has(id) || typeof pl.parent !== 'string' || !removable.has(pl.parent))
+            for (const [id, rec] of blocks) {
+                if (removable.has(id))
                     continue;
-                for (const member of families.get(root(pl.parent)) ?? [])
-                    removable.delete(member);
-                shrank = true;
+                for (const p of [placements.get(id)?.parent, rec.home?.parent]) {
+                    if (typeof p !== 'string' || !removable.has(p))
+                        continue;
+                    for (const member of lone.has(p) ? [p] : (families.get(root(p)) ?? [])) {
+                        removable.delete(member);
+                        lone.delete(member);
+                    }
+                    shrank = true;
+                }
             }
         }
         // ── The writes ────────────────────────────────────────────────────
         // A deleted block that stays: its stream's text (boundaries kept), its
-        // data leaves and its claims.
+        // data leaves and its claims; a block that goes alone: its stream's
+        // text and its claims (the rest goes with its node).
         const emptied = [...dead].filter((id) => !removable.has(id));
-        purgeStreams(emptied.flatMap((id) => {
+        const purged = [...emptied, ...lone].flatMap((id) => {
             const s = own.streamOf(id);
-            return s === undefined || s.end - s.start <= s.inert.length ? [] : [s];
-        }));
+            return s === undefined ? [] : [s];
+        });
+        // Their marks format nothing any reader shows: each pair whose start and
+        // end lie in one of these streams goes (collected, it keeps its class).
+        const tr = doc._transaction;
+        for (const s of purged)
+            for (const item of regionMarks(s))
+                item.delete(tr);
+        purgeStreams(purged.filter((s) => s.end - s.start > s.inert.length));
+        for (const id of lone)
+            deleteClaims(doc, blocks.get(id).claims);
         for (const id of emptied) {
             const rec = blocks.get(id);
             for (const key of [...rec.node.attrKeys()])
                 if (key === DATA || key.startsWith(DATA_LEAF_PREFIX))
                     rec.node.deleteAttr(key);
-            if (rec.claimsNode !== undefined && rec.claimsNode.length > 0)
-                rec.claimsNode.delete(0, rec.claimsNode.length);
+            deleteClaims(doc, rec.claims);
             report.emptied++;
         }
         // The blocks that go whole: their entries, attribution records and the claims naming them.
@@ -238,18 +340,17 @@ export const bindPurge = (Y) => {
         const attribution = doc.get(BLOCK_ATTR_ROOT);
         for (const [id, rec] of blocks) {
             // An emptied block's claims are gone already (above).
-            if (removable.has(id) || dead.has(id) || rec.claimsNode === undefined)
+            if (removable.has(id) || dead.has(id))
                 continue;
-            // The claims its list stores (an anchor may show one in another block).
-            const named = (rec.listClaims ?? rec.claims)
-                .filter((c) => removable.has(c.m))
-                .map((c) => c.seqIndex)
-                .filter((at) => at >= 0);
-            for (const at of named.sort((a, b) => b - a))
-                rec.claimsNode.delete(at, 1);
+            const named = rec.claims.filter((c) => c.stamp.c >= 0 && removable.has(c.m));
+            deleteClaims(doc, named);
             report.claims += named.length;
         }
         for (const id of removable) {
+            // Its home slot goes with it: nothing shows it any more.
+            const home = blocks.get(id)?.home;
+            if (home)
+                removeUnit(doc, home);
             if (isIncarnationId(id)) {
                 // A losing incarnation is no registry value: its subtree goes.
                 // Its node is a deleted value, which the node API writes nothing to:
@@ -264,8 +365,8 @@ export const bindPurge = (Y) => {
                 continue;
             }
             registry.deleteAttr(id);
-            if (attribution.getAttr(`${REC_PREFIX}${id}`) !== undefined)
-                attribution.deleteAttr(`${REC_PREFIX}${id}`);
+            if (attribution.getAttr(id) !== undefined)
+                attribution.deleteAttr(id);
             report.removed++;
         }
         // Blocks merged away before the horizon (`room.purge.merged`): live,
@@ -273,10 +374,10 @@ export const bindPurge = (Y) => {
         // own attribution records go (no history reaches a step below the
         // horizon to split them out again); their registry entries stay.
         const claimsOn = new Map();
-        for (const [holder, rec] of blocks) {
+        for (const rec of blocks.values()) {
             if (rec.deleted)
                 continue;
-            for (const c of own.claimsOf?.(holder) ?? rec.claims) {
+            for (const c of rec.claims) {
                 const list = claimsOn.get(c.m);
                 if (list === undefined)
                     claimsOn.set(c.m, [c]);
@@ -284,40 +385,79 @@ export const bindPurge = (Y) => {
                     list.push(c);
             }
         }
-        const claimedOld = (id) => (claimsOn.get(id) ?? []).every((c) => c.seqIndex >= 0 && old(c.stamp.c, c.stamp.k));
+        const claimedOld = (id) => (claimsOn.get(id) ?? []).every((c) => c.stamp.c >= 0 && old(c.stamp.c, c.stamp.k));
         for (const [id, rec] of blocks) {
             if (rec.deleted || removable.has(id) || dead.has(id) || isIncarnationId(id))
                 continue;
             const owner = own.ownerOf(id);
             if (owner === id || typeof owner !== 'string' || !claimedOld(id))
                 continue;
-            if (attribution.getAttr(`${REC_PREFIX}${id}`) === undefined)
+            if (attribution.getAttr(id) === undefined)
                 continue;
-            attribution.deleteAttr(`${REC_PREFIX}${id}`);
+            attribution.deleteAttr(id);
             report.merged++;
         }
-        // Runner-up candidates of an old winner that stands.
-        for (const [id, rec] of blocks) {
-            if (removable.has(id) || rec.cands.length < 2)
-                continue;
-            const winner = rec.cands[0];
-            const at = rec.node.getAttr(AT);
-            if (!isNodeLike(at) || !oldItem(mapOf(at).get(winner.key)))
-                continue;
-            const pl = placements.get(id);
-            const p = winner.p !== null && !blocks.has(winner.p) ? null : winner.p;
-            if (pl === undefined || pl.parent !== p || pl.rank !== winner.r)
-                continue;
-            for (const c of rec.cands.slice(1))
-                at.deleteAttr(c.key);
-            report.candidates += rec.cands.length - 1;
+        // Old move records no block shows at (lost to a newer move, or their blocks
+        // removed): no undo below the horizon can make them movers again.
+        const sequences = [registryOf(doc)];
+        for (const [id, rec] of blocks)
+            if (!removable.has(id))
+                sequences.push(rec.node);
+        // A record a block shows at stays, though it is no unit's mover (a cycle
+        // sent the block back to it): it is read before any record goes.
+        const shownNow = modelView(doc);
+        const listed = sequences.map((node) => [node, recordsOf(doc, node, shownNow)]);
+        doc.transact((tr) => {
+            for (const [node, records] of listed)
+                for (const r of records) {
+                    if (r.wins || !old(r.item.id.client, r.item.id.clock))
+                        continue;
+                    ops.remove(tr, r.item);
+                    dropSearchMarkers(node);
+                    report.records++;
+                }
+        });
+        // Text hold records past the horizon, with what they hold.
+        report.marks = purgeText(doc, freed);
+        // Release records the horizon covers: what they released is past it.
+        {
+            const tr = doc._transaction;
+            for (let it = firstItem(doc.get(RELEASE_ROOT)); it; it = it.right) {
+                if (it.deleted || !old(it.id.client, it.id.clock + it.length - 1))
+                    continue;
+                it.delete(tr);
+                report.released++;
+            }
+        }
+        // Suggestions decided before the horizon (`sugg.purge`): the decision
+        // trail goes with them. A writer's oldest record first, so no record's
+        // clocks pass to another.
+        const suggest = facade.part && suggestionsOf(facade);
+        const records = suggest?.records() ?? [];
+        if (records.length > 0) {
+            const pending = new Set(suggest.changes().map((c) => c.suggestion));
+            const root = doc.get(SUGGEST_ROOT);
+            const seen = new Set();
+            for (const rec of [...records].sort((a, b) => clockOf(a) - clockOf(b))) {
+                if (seen.has(rec.writer))
+                    continue;
+                seen.add(rec.writer);
+                const node = root.getAttr(rec.id);
+                const items = [node._item];
+                for (let it = firstItem(node); it; it = it.right)
+                    if (!it.deleted)
+                        items.push(it);
+                if (pending.has(rec.id) ||
+                    !items.every((it) => old(it.id.client, it.id.clock + it.length - 1)))
+                    continue;
+                root.deleteAttr(rec.id);
+                seen.delete(rec.writer);
+                report.suggestions++;
+            }
         }
-        // Text delete marks and restoration records past the horizon.
-        const text = purgeText(doc, old);
-        report.marks = text.marks;
-        report.records = text.records;
         // The horizon record, last.
-        doc.get(HORIZON_ROOT).setAttr(HORIZON_ATTR, { at: horizon.at, sv: horizon.sv });
+        if (horizon !== null)
+            doc.get(HORIZON_ROOT).setAttr(HORIZON_ATTR, { at: horizon.at, sv: horizon.sv });
         return report;
     };
     return { purge };

package/dist/crdt/restore.d.ts

@@ -14,8 +14,8 @@
  * 2. its type and data, per leaf, where they differ;
  * 3. its place: under its snapshot parent, in the snapshot's order (the
  *    longest run of that parent's children already in order stays; each
- *    other block gets a placement candidate between its neighbours); a
- *    snapshot block the registry no longer holds is created there;
+ *    other block is moved after the one before it); a snapshot block the
+ *    registry no longer holds is created there;
  * 4. its content, where it differs: its own claims removed, then its
  *    stream's text replaced through the facade's per-stream delete and
  *    insert, the common prefix and suffix kept;
@@ -26,6 +26,7 @@
 import type { EngineDoc } from './engine-api.js';
 import { type BlockId, type ContentItem, type InlineSpec, type PlacementModel } from './placement/model.js';
 import type { DataPatch } from './data.js';
+import { type SuggestFacade } from './doc/suggest.js';
 import type { JSONDoc } from '../utils/json.js';
 /** One display unit: a character (a code point) with its marks, or an inline atom, keyed for comparison. */
 export type Unit = {
@@ -60,7 +61,7 @@ export type RestoreReport = {
     deleted: number;
 };
 /** What a restore reads and writes through: the facade over the document (structurally). */
-export type RestoreFacade<Plan> = {
+export type RestoreFacade<Plan> = Partial<SuggestFacade> & {
     model: PlacementModel;
     childSlots(parent: BlockId | null): readonly {
         id: BlockId;