edytor 2.0.0 → 4.0.0

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

@@ -1,10 +1,10 @@
-import { type BlockId } from '../../placement/model.js';
-import type { IndexAnchored } from './anchored.js';
+import type { BlockId } from '../../placement/model.js';
 import type { IndexClaims } from './claims.js';
 import type { IndexPlacement } from './placement.js';
 import type { IndexState } from './state.js';
+import type { IndexStreams } from './streams.js';
 /** The block records of one doc's index. */
-export declare const indexRecords: (ix: IndexState & IndexClaims & IndexAnchored & IndexPlacement) => {
+export declare const indexRecords: (ix: IndexState & IndexClaims & IndexStreams & IndexPlacement) => {
     kept: (item: unknown) => boolean;
     updateBlockRec: (id: BlockId) => void;
     ensureRec: (id: BlockId) => void;

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

@@ -6,14 +6,12 @@
 import { readData } from '../../data.js';
 import { Y } from '../../engine.js';
 import { baseIdOf, incarnationNode, incarnationsOf, isIncarnationId } from '../../incarnations.js';
-import { candidatesOf } from '../../placement/model.js';
 import { engineOps } from '../../structs.js';
-import { CLAIMS, CONTENT, NONCE, hasDeleteMark, hasWithdrawMark, isNodeLike } from '../../schema.js';
-import { readClaims } from '../model.js';
-import { dropFrom, sameShape, typeAttr } from './shared.js';
+import { CONTENT, NONCE, hasDeleteMark, hasWithdrawMark, isNodeLike } from '../../schema.js';
+import { sameShape, typeAttr } from './shared.js';
 /** The block records of one doc's index. */
 export const indexRecords = (ix) => {
-    const { registry, blocks, shells, attachOf, foreignOf, retargets, reclaim, byArgParent, placementSeeds, stateSeeds, incarnations, noteClaims, effectiveClaims, noteKind, argParent, noteCands } = ix;
+    const { registry, blocks, shells, reclaim, rawOrder, placementSeeds, stateSeeds, incarnations, noteClaims, claimsOf, noteKind, homeFor, reslot } = ix;
     // ── records ──────────────────────────────────────────────────────
     /** Fork patch YP14's predicate: the registry values the engine keeps. */
     const kept = engineOps(Y).isKeptReplaced;
@@ -25,10 +23,7 @@ export const indexRecords = (ix) => {
         return incarnationNode(registry, id, kept) ?? undefined;
     };
     const buildRec = (id, node) => {
-        const list = node.getAttr(CLAIMS);
-        const claimsNode = isNodeLike(list) ? list : undefined;
         const content = node.getAttr(CONTENT);
-        const own = readClaims(claimsNode);
         const derived = isIncarnationId(id);
         // A losing incarnation lives and dies with its key's block: hidden by its
         // own delete mark or while that block is deleted (a withdrawn one included).
@@ -39,10 +34,8 @@ export const indexRecords = (ix) => {
             ? []
             : incarnationsOf(registry, id, kept).map((x, i) => ({
                 m: x.id,
-                stamp: { c: -1, k: -1 - i },
-                seqIndex: -1
+                stamp: { c: -1, k: -1 - i }
             }));
-        const listClaims = implicit.length === 0 ? own : [...implicit, ...own];
         return {
             id,
             node,
@@ -51,44 +44,44 @@ export const indexRecords = (ix) => {
             n: node.getAttr(NONCE),
             deleted: hasDeleteMark(node) || keyDeleted,
             content: isNodeLike(content) ? content : undefined,
-            claimsNode,
-            listClaims,
-            // Until the next retarget pass its own claims stay with it (`merge.claim.anchor`).
-            claims: effectiveClaims(id, listClaims),
-            cands: candidatesOf(node)
+            implicit,
+            // Read from its stream once the record is in (`claimsOf`), again after the fold's texts.
+            claims: [],
+            home: homeFor(id)
         };
     };
     /**
      * 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, its placement — and, when its entry came or
-     * went, the placements of the blocks whose candidate names it.
+     * went, the placements of the blocks whose display edge it holds.
      */
     const updateBlockRec = (id) => {
         const old = blocks.get(id);
         const node = nodeAt(id);
-        // Its list may change: its claims stay its own until the retarget pass.
-        for (const t of attachOf.get(id) ?? []) {
-            if (t === id)
-                continue;
-            dropFrom(foreignOf, t, id);
-            reclaim.add(t);
-        }
-        attachOf.delete(id);
-        retargets.add(id);
         if (!isNodeLike(node))
             blocks.delete(id);
-        else
-            blocks.set(id, buildRec(id, node));
+        else {
+            const rec = buildRec(id, node);
+            blocks.set(id, rec);
+            rec.claims = claimsOf(id);
+            reclaim.add(id);
+        }
         const rec = blocks.get(id);
+        // Another node now stands for `id` (or none): its sequence's slots change owner.
+        if (old?.node !== rec?.node) {
+            if (old !== undefined)
+                reslot(old.node);
+            if (rec !== undefined)
+                reslot(rec.node);
+        }
         noteShell(id);
         noteClaims(id, old?.claims ?? [], rec?.claims ?? []);
-        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);
+            for (const c of rawOrder.get(id) ?? [])
+                placementSeeds.add(c.id);
         }
         if (old?.type !== rec?.type) {
             noteKind(id);

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

@@ -9,13 +9,21 @@ import type { SelfChecks } from './state.js';
 export declare const ENTRY_FACET = "";
 /** The facet name of a write to a block's `content` attr itself (a streamless block's own text). */
 export declare const CONTENT_ATTR = "#content";
+/**
+ * The facet name of a write to a block's sequence (fork patch YP22): its
+ * children's home slots, its data arrays' item slots and its move records.
+ */
+export declare const SEQ_FACET = "#seq";
+/** The facet the fold adds when a sequence write changed the block's data (its arrays' items). */
+export declare const DATA_SEQ_FACET = "#data";
 /**
  * Facets of a block node that can change derived state: `content` (a
  * sequence edit of the block's own text), `structure` (claims, delete marks,
- * the nonce, the `content` attr, unknown attrs), `at` (placement candidates —
- * placements and order only) and `meta` (type/data — metadata only).
+ * the nonce, the `content` attr, unknown attrs), `seq` (its sequence: slots
+ * and records — placements and order, or its arrays' items) and `meta`
+ * (type/data — metadata only).
  */
-export type Facet = 'content' | 'structure' | 'at' | 'meta' | 'ignore';
+export type Facet = 'content' | 'structure' | 'seq' | 'meta' | 'ignore';
 export declare const facetOf: (attr: string) => Facet;
 /** A record's `data` as the projection publishes it: a total JSON clone, `undefined` when absent. */
 export declare const dataOf: (rec: BlockRec) => Record<string, unknown> | undefined;

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

@@ -4,7 +4,7 @@
  * and the self-check switch.
  */
 import { cloneJsonSafe } from '../../../utils/json.js';
-import { AT, CONTENT, DATA, DATA_LEAF_PREFIX, ID, LAST_CHANGED_ATTR, TYPE } from '../../schema.js';
+import { CONTENT, DATA, DATA_LEAF_PREFIX, ID, LAST_CHANGED_ATTR, TYPE } from '../../schema.js';
 /**
  * The facet name of a block's registry entry itself (inserted or removed) —
  * every other facet is named by the block attr it entered through.
@@ -12,11 +12,20 @@ import { AT, CONTENT, DATA, DATA_LEAF_PREFIX, ID, LAST_CHANGED_ATTR, TYPE } from
 export const ENTRY_FACET = '';
 /** The facet name of a write to a block's `content` attr itself (a streamless block's own text). */
 export const CONTENT_ATTR = '#content';
+/**
+ * The facet name of a write to a block's sequence (fork patch YP22): its
+ * children's home slots, its data arrays' item slots and its move records.
+ */
+export const SEQ_FACET = '#seq';
+/** The facet the fold adds when a sequence write changed the block's data (its arrays' items). */
+export const DATA_SEQ_FACET = '#data';
 export const facetOf = (attr) => {
     if (attr === CONTENT)
         return 'content';
-    if (attr === AT)
-        return 'at';
+    if (attr === SEQ_FACET)
+        return 'seq';
+    if (attr === DATA_SEQ_FACET)
+        return 'ignore';
     if (attr === ID || attr === TYPE || attr === DATA || attr.startsWith(DATA_LEAF_PREFIX))
         return 'meta';
     // The `l` lastChangedBy stamp is attribution bookkeeping only.

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

@@ -6,7 +6,7 @@
  * What one part alone keeps stays in that part.
  */
 import type { EngineDoc, EngineTransaction } from '../../engine-api.js';
-import { type BlockId, type BlockRec, type ChildSlot, type ResolvedPlacement } from '../../placement/model.js';
+import { type BlockId, type BlockRec, type ChildSlot, type Edge, type ResolvedPlacement, type SlotRef } from '../../placement/model.js';
 import type { IdSetLike } from '../../structs.js';
 import type { LiveRow, RowItem } from '../rows.js';
 import type { ContentRun, DisplayRoles, Folded } from '../runs.js';
@@ -47,7 +47,7 @@ export type Slot = {
 export type Placed = {
     head: BlockId | null;
     keys: string[];
-    blocks: BlockId[];
+    blocks: (BlockId | null)[];
 };
 /** The tree the change report last published. */
 export type Published = {
@@ -68,6 +68,10 @@ 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[];
 };
 /** The index's self-checks (`indexChecks`), run after each fold and each report. */
 export type SelfChecks = {
@@ -102,16 +106,7 @@ export declare const indexState: (doc: EngineDoc) => {
     placed: Map<string, Placed>;
     /** Each row's text → its home (rows are keyed by home). */
     homeOfText: WeakMap<object, string>;
-    /** Each holder's list claims' effective claimers, by list index (absent: all its own). */
-    attachOf: Map<string, string[]>;
-    /** An effective claimer → the holders whose claims moved to it. */
-    foreignOf: Map<string, Set<string>>;
-    /** A row's home → the holders with an anchored claim in its text. */
-    anchoredIn: Map<string, Set<string>>;
-    /** Holders whose targets the next pass re-decides, and blocks whose claims it re-reads. */
-    retargets: Set<string>;
-    /** Holders with an anchored claim and no stream yet: any re-placed row may resolve them. */
-    unresolved: Set<string>;
+    /** Blocks whose claims (implicit, then their stream's claim items) the next pass re-reads. */
     reclaim: Set<string>;
     /** The role table the display reads; `null` → none. */
     roles: DisplayRoles | null;
@@ -121,10 +116,18 @@ export declare const indexState: (doc: EngineDoc) => {
     dissolved: Set<string>;
     /** Resolved placements. */
     placementsMap: Map<string, ResolvedPlacement>;
-    /** The texts whose pieces' order is re-decided at the next pass (`order.split.text`). */
-    regroup: Set<string>;
-    /** A block's argmax candidate parent → the blocks naming it (its entry decides theirs). */
-    byArgParent: Map<string, Set<string>>;
+    /** Counts the folds that changed a sequence (a slot or record written or removed): a slot map read before one is stale. */
+    seqEpoch: number;
+    /** Every block slot by the id it names (`{ b }`, fork patch YP22), kept from the folds; a block's home is `homeFor`. */
+    slotsByBlock: Map<string, SlotRef[]>;
+    /** Each sequence owner's blocks (every block whose display edge it holds), sorted by key. */
+    rawOrder: Map<string | null, ChildSlot[]>;
+    /** Each block's display edge as accepted, or its strongest when none is (`null`: no slot). */
+    edges: Map<string, Edge | null>;
+    /** The blocks shown below their strongest edge: a cycle dropped a later move, they are back where they stood. */
+    fallen: Set<string>;
+    /** The blocks at the root's tail: every edge closes a cycle, or no slot. */
+    rejected: Set<string>;
     /** The children index without the layout rules (what they read), and with them. */
     kids0: Map<string | null, ChildSlot[]>;
     slots0: Map<string, Slot>;
@@ -146,7 +149,7 @@ export declare const indexState: (doc: EngineDoc) => {
     allListsDirty: boolean;
     /** The next pass rebuilds everything (first build, roles, an irregular state). */
     placementFull: boolean;
-    /** Blocks whose candidates or record changed, whose display state changed. */
+    /** Blocks whose slot, record or mover changed; blocks whose display state changed. */
     placementSeeds: Set<string>;
     stateSeeds: Set<string>;
     /**
@@ -182,6 +185,7 @@ export declare const indexState: (doc: EngineDoc) => {
         folds: number;
         pairs: number;
         structs: number;
+        placed: number;
     };
     /** Frames tracking the folds (the write funnel's `track()`), and the report's candidates. */
     frames: Set<Folded>;

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

@@ -32,17 +32,7 @@ export const indexState = (doc) => {
         placed: new Map(),
         /** Each row's text → its home (rows are keyed by home). */
         homeOfText: new WeakMap(),
-        // ── anchored merge claims (`anchored.ts`)
-        /** Each holder's list claims' effective claimers, by list index (absent: all its own). */
-        attachOf: new Map(),
-        /** An effective claimer → the holders whose claims moved to it. */
-        foreignOf: new Map(),
-        /** A row's home → the holders with an anchored claim in its text. */
-        anchoredIn: new Map(),
-        /** Holders whose targets the next pass re-decides, and blocks whose claims it re-reads. */
-        retargets: new Set(),
-        /** Holders with an anchored claim and no stream yet: any re-placed row may resolve them. */
-        unresolved: new Set(),
+        /** Blocks whose claims (implicit, then their stream's claim items) the next pass re-reads. */
         reclaim: new Set(),
         // ── roles
         /** The role table the display reads; `null` → none. */
@@ -54,10 +44,18 @@ export const indexState = (doc) => {
         dissolved: new Set(),
         /** Resolved placements. */
         placementsMap: new Map(),
-        /** The texts whose pieces' order is re-decided at the next pass (`order.split.text`). */
-        regroup: new Set(),
-        /** A block's argmax candidate parent → the blocks naming it (its entry decides theirs). */
-        byArgParent: new Map(),
+        /** Counts the folds that changed a sequence (a slot or record written or removed): a slot map read before one is stale. */
+        seqEpoch: 0,
+        /** Every block slot by the id it names (`{ b }`, fork patch YP22), kept from the folds; a block's home is `homeFor`. */
+        slotsByBlock: new Map(),
+        /** Each sequence owner's blocks (every block whose display edge it holds), sorted by key. */
+        rawOrder: new Map(),
+        /** Each block's display edge as accepted, or its strongest when none is (`null`: no slot). */
+        edges: new Map(),
+        /** The blocks shown below their strongest edge: a cycle dropped a later move, they are back where they stood. */
+        fallen: new Set(),
+        /** The blocks at the root's tail: every edge closes a cycle, or no slot. */
+        rejected: new Set(),
         /** The children index without the layout rules (what they read), and with them. */
         kids0,
         slots0,
@@ -79,7 +77,7 @@ export const indexState = (doc) => {
         allListsDirty: true,
         /** The next pass rebuilds everything (first build, roles, an irregular state). */
         placementFull: true,
-        /** Blocks whose candidates or record changed, whose display state changed. */
+        /** Blocks whose slot, record or mover changed; blocks whose display state changed. */
         placementSeeds: new Set(),
         stateSeeds: new Set(),
         /**
@@ -106,7 +104,7 @@ export const indexState = (doc) => {
         /** The index version (`RunView.version`). */
         version: 0,
         /** The fold counters `debug` exposes read-only. */
-        foldStats: { folds: 0, pairs: 0, structs: 0 },
+        foldStats: { folds: 0, pairs: 0, structs: 0, placed: 0 },
         // ── the fold (`fold.ts`) and the report (`report.ts`)
         /** Frames tracking the folds (the write funnel's `track()`), and the report's candidates. */
         frames: new Set(),

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

@@ -1,13 +1,15 @@
 /**
  * The stream table: one maintained row per backing text, the
- * delimiting boundary of each block, and each block's segment.
+ * delimiting boundary of each block, each block's segment, and each
+ * block's claims (the claim items of its segment).
  */
 import type { BlockId } from '../../placement/model.js';
-import { type Stream } from '../model.js';
+import { type Claim, type Stream } from '../model.js';
 import { type LiveRow } from '../rows.js';
-import type { IndexState } from './state.js';
-/** The stream table of one doc's index, over its state. */
-export declare const indexStreams: (ix: IndexState) => {
+import type { IndexClaims } from './claims.js';
+import type { FoldCtx, IndexState } from './state.js';
+/** The stream table of one doc's index, over its state and claim graph. */
+export declare const indexStreams: (ix: IndexState & IndexClaims) => {
     streamOf: (b: BlockId) => Stream | undefined;
     streamsIn: (home: BlockId) => Stream[];
     streamAt: (home: BlockId, i: number) => Stream | undefined;
@@ -16,5 +18,8 @@ export declare const indexStreams: (ix: IndexState) => {
     refreshDelims: (named: Iterable<BlockId>, homes: Set<BlockId>) => void;
     placeHome: (home: BlockId, invalidated: Set<BlockId>) => void;
     rebuildTable: (invalidated: Set<BlockId>) => void;
+    sameClaims: (x: readonly Claim[], y: readonly Claim[]) => boolean;
+    claimsOf: (b: BlockId) => Claim[];
+    applyReclaims: (ctx: FoldCtx | null) => void;
 };
 export type IndexStreams = ReturnType<typeof indexStreams>;

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

@@ -1,8 +1,9 @@
-import { byId, scanText } from '../model.js';
-import { headOf, placeRow, rowOf, segmentAt, segmentOfCut, streamOfSegment } from '../rows.js';
-/** The stream table of one doc's index, over its state. */
+import { byId, cmpStamp, scanText } from '../model.js';
+import { removedKeys } from '../streams.js';
+import { headOf, placeRow, rowOf, segmentAt, segmentClaims, segmentOfCut, streamOfSegment } from '../rows.js';
+/** The stream table of one doc's index, over its state and claim graph. */
 export const indexStreams = (ix) => {
-    const { blocks, listConsumers, rows, streamIx, placed, homeOfText, anchoredIn, retargets, unresolved, regroup } = ix;
+    const { registry, blocks, listConsumers, rows, streamIx, placed, homeOfText, reclaim, noteClaims, invalidateBlock } = ix;
     // ── the stream table ────────────────────────────────────
     // One maintained row per backing text (keyed by its home block): its
     // live boundaries and the units between them (`text/rows.ts`), the
@@ -54,7 +55,7 @@ export const indexStreams = (ix) => {
         if (old?.key === row?.key)
             return;
         for (const b of old?.bounds ?? []) {
-            if (row?.keyIndex.has(b.key))
+            if (b.m !== undefined || row?.keyIndex.has(b.key))
                 continue;
             const by = boundsBy.get(b.s);
             // A text can change homes (a key's node becomes a losing incarnation,
@@ -66,7 +67,7 @@ export const indexStreams = (ix) => {
             named.add(b.s);
         }
         for (const b of row?.bounds ?? []) {
-            if (old?.keyIndex.has(b.key))
+            if (b.m !== undefined || old?.keyIndex.has(b.key))
                 continue;
             let by = boundsBy.get(b.s);
             if (by === undefined)
@@ -80,18 +81,27 @@ export const indexStreams = (ix) => {
         const text = blocks.get(home)?.content;
         return text === undefined ? undefined : rowOf(scanText(home, text));
     };
+    /** A removed block's key (`room.purge.what`): its boundary delimits nobody's stretch. */
+    const removed = removedKeys(registry);
+    /** A cut's stretch is nobody's when it names no block (a removed one). */
+    const nobody = (s) => !blocks.has(s);
     /** 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;
+            const rec = blocks.get(s);
+            const gone = rec === undefined && removed(s);
             let best;
-            if (blocks.has(s))
+            if (rec !== undefined || gone)
                 for (const [key, b] of boundsBy.get(s) ?? [])
-                    if (b.n === n && (best === undefined || byId(key, best) < 0))
+                    if ((gone || b.n === rec.n) && (best === undefined || byId(key, best) < 0))
                         best = key;
             const old = ix.delim.get(s);
-            if (old === best)
+            if (old === best) {
+                // The cut stays, and the block it opens may have come or gone (removed).
+                if (best !== undefined)
+                    homes.add(boundsBy.get(s).get(best).home);
                 continue;
+            }
             if (best === undefined)
                 ix.delim.delete(s);
             else
@@ -116,33 +126,34 @@ export const indexStreams = (ix) => {
         const before = placed.get(home) ?? { head: null, keys: [], blocks: [] };
         const now = { head: null, keys: [], blocks: [] };
         if (row !== undefined) {
-            placeRow(row, ix.delim);
+            placeRow(row, ix.delim, nobody);
             now.head = row.head;
-            for (const j of row.cuts) {
+            row.cuts.forEach((j, k) => {
                 now.keys.push(row.bounds[j].key);
-                now.blocks.push(row.bounds[j].s);
-            }
+                now.blocks.push(row.heads[k]);
+            });
         }
         if (row === undefined)
             placed.delete(home);
         else
             placed.set(home, now);
-        // Its cuts may move the claims anchored in its text (`merge.claim.anchor`).
-        for (const h of anchoredIn.get(home) ?? [])
-            retargets.add(h);
-        for (const h of unresolved)
-            retargets.add(h);
-        // A change of the text's segments re-decides its pieces' order.
-        if (before.head !== now.head ||
-            before.blocks.length !== now.blocks.length ||
-            before.blocks.some((b, i) => now.blocks[i] !== b))
-            regroup.add(home);
+        // Its segments' claim items may have changed, or gone to other blocks.
+        for (const x of [before, now]) {
+            if (x.head !== null)
+                reclaim.add(x.head);
+            for (const b of x.blocks)
+                if (b !== null)
+                    reclaim.add(b);
+        }
         const [a, b] = [before.keys, now.keys];
+        // A cut is the same when its boundary and the block it opens are (a
+        // removed block's cut opens nobody's stretch).
+        const same = (i, j) => a[i] === b[j] && before.blocks[i] === now.blocks[j];
         let p = 0;
-        while (p < a.length && p < b.length && a[p] === b[p])
+        while (p < a.length && p < b.length && same(p, p))
             p++;
         let q = 0;
-        while (q < a.length - p && q < b.length - p && a[a.length - 1 - q] === b[b.length - 1 - q])
+        while (q < a.length - p && q < b.length - p && same(a.length - 1 - q, 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;
@@ -173,6 +184,8 @@ export const indexStreams = (ix) => {
         boundsBy.clear();
         for (const [home, row] of rows)
             for (const b of row.bounds) {
+                if (b.m !== undefined)
+                    continue;
                 let by = boundsBy.get(b.s);
                 if (by === undefined)
                     boundsBy.set(b.s, (by = new Map()));
@@ -184,6 +197,41 @@ export const indexStreams = (ix) => {
         for (const home of homes)
             placeHome(home, invalidated);
     };
+    // ── claims ──────────────────────────────────────────────
+    // A block's claims are its implicit ones (`id.same.concurrent`), then
+    // the claim items of its segment, in text order (fork patch YP21:
+    // YATA placed each one, so a split its writer did not see leaves it in
+    // the piece that ends its holder's region, `merge.claim.anchor`). They
+    // change with the record (its implicit claims) and with its row's bounds
+    // or cuts: re-read after each fold's texts for the blocks queued.
+    const sameClaims = (x, y) => x.length === y.length &&
+        x.every((c, i) => c.m === y[i].m && cmpStamp(c.stamp, y[i].stamp) === 0);
+    /** `b`'s claims now: its implicit ones, then its segment's claim items. */
+    const claimsOf = (b) => {
+        const at = streamIx.get(b);
+        const row = at && rows.get(at.home);
+        const k = row === undefined ? -1 : segmentOfCut(row, at.cut);
+        const items = k < 0 ? [] : segmentClaims(row, k);
+        const implicit = blocks.get(b)?.implicit ?? [];
+        return implicit.length === 0 ? items : [...implicit, ...items];
+    };
+    /** Re-read the claims of the blocks queued; a change is a structural change of the block. */
+    const applyReclaims = (ctx) => {
+        for (const b of reclaim) {
+            const rec = blocks.get(b);
+            if (rec === undefined)
+                continue;
+            const before = rec.claims;
+            const after = claimsOf(b);
+            if (sameClaims(before, after))
+                continue;
+            rec.claims = after;
+            noteClaims(b, before, after);
+            if (ctx !== null)
+                invalidateBlock(b, ctx, before);
+        }
+        reclaim.clear();
+    };
     return {
         streamOf,
         streamsIn,
@@ -192,6 +240,9 @@ export const indexStreams = (ix) => {
         scanRow,
         refreshDelims,
         placeHome,
-        rebuildTable
+        rebuildTable,
+        sameClaims,
+        claimsOf,
+        applyReclaims
     };
 };

package/dist/crdt/text/items.d.ts

@@ -1,8 +1,15 @@
 /**
- * The guards of a backing text's items: a boundary item's payload, and a
- * node's first item for sequence walks.
+ * The guards of a backing text's items: a boundary item's payload, a merge
+ * claim item's, and a node's first item for sequence walks.
  */
 import type { EngineNode } from '../engine-api.js';
-import type { Boundary, SeqItem } from './model.js';
+import type { Boundary, MergeClaim, SeqItem } from './model.js';
 export declare const isBoundary: (v: unknown) => v is Boundary;
+/**
+ * A merge claim item `{m}` (fork patch YP21: the engine sorts it after the
+ * content and boundaries of its origin, and keeps it on collection).
+ */
+export declare const isClaimItem: (v: unknown) => v is MergeClaim;
+/** A unit a row tracks and no read displays: a boundary or a claim item. */
+export declare const isRowMark: (v: unknown) => boolean;
 export declare const nodeStart: (node: EngineNode) => SeqItem | null;

package/dist/crdt/text/items.js

@@ -1,3 +1,10 @@
 import { firstItem } from '../structs.js';
 export const isBoundary = (v) => v != null && typeof v === 'object' && typeof v.s === 'string' && 'n' in v;
+/**
+ * A merge claim item `{m}` (fork patch YP21: the engine sorts it after the
+ * content and boundaries of its origin, and keeps it on collection).
+ */
+export const isClaimItem = (v) => v != null && typeof v === 'object' && typeof v.m === 'string';
+/** A unit a row tracks and no read displays: a boundary or a claim item. */
+export const isRowMark = (v) => isBoundary(v) || isClaimItem(v);
 export const nodeStart = (node) => firstItem(node);