edytor 3.0.0 → 5.0.0

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

@@ -13,15 +13,21 @@
  * - It ends at the next delimiting boundary of the same text, or at the text
  *   end. A boundary whose nonce matches no record is inert: skipped by reads,
  *   never a delimiter.
- * - `display(b)` = `stream(b)`, then `display(m)` for each merge claim `{m}`
- *   on `b`'s `claims` list whose max-stamp live claimer is `b`. Owner
- *   resolution over claims (`claimGraph`: max-stamp claim, cycles, claims held
- *   by deleted blocks are inert) is unchanged.
+ * - A merge writes one CLAIM ITEM `{m}` (one countable unit, never
+ *   displayed) at the end of the gap at the end of the holder's stream (fork
+ *   patch YP21: among the items of one origin it sorts after content and
+ *   boundaries, so YATA decides which piece of a concurrent split keeps it).
+ *   A block's claims are the claim items of its stream, in text order.
+ * - `display(b)` = `stream(b)`, then `display(m)` for each claim `{m}` of `b`
+ *   whose max-stamp live claimer is `b`. Owner resolution over claims
+ *   (`claimGraph`: max-stamp claim, cycles, claims held by deleted blocks are
+ *   inert) is unchanged.
  *
  * Every position therefore lies in exactly one stream: the block that displays
  * it is a pure function of replicated items and is never repaired. Typing at a
  * stream's start inserts after its boundary, at its end before the next one;
- * the per-stream delete never removes a boundary; every read skips them.
+ * the per-stream delete never removes a boundary or a claim; every read skips
+ * them.
  *
  * Anchors are `{b, a}`: `b` the home block of the backing text, `a` an
  * engine relative position (`i` the bound item, `a` the side: `< 0` left). A
@@ -36,9 +42,9 @@
  */
 import type { EngineApi, EngineDoc, EngineNode } from '../engine-api.js';
 import { type IdSetOf } from '../structs.js';
-export { isBoundary, nodeStart } from './items.js';
+export { isBoundary, isClaimItem, isRowMark, nodeStart } from './items.js';
 export { canonKey, deepFreeze, inlineItemOf, protectItems, readRange } from './ranges.js';
-export { byId, delimiters, displayOf, locate, ownedLength, pieces, placeText, scanText } from './streams.js';
+export { byId, claimsIn, delimiters, displayOf, locate, ownedLength, pieces, placeText, removedKeys, scanText } from './streams.js';
 export type BlockId = string;
 /** A serialized relative position inside a backing text (`i: null`: a text end). */
 export type Anchor = {
@@ -48,26 +54,15 @@ export type Anchor = {
     } | null;
     a: number;
 };
-/** An engine item id as a claim payload stores it. */
-export type ItemRef = {
-    c: number;
-    k: number;
-};
 /**
- * Merge-claim payload: "this block's display continues with block `m`'s".
- * `a` and `r` (since 0.1.0-next.26, `merge.claim.anchor`) anchor it to the
- * end of the holder's stream as the claim's writer saw it: `a` the last
- * unit of that stream (its opening boundary when empty; absent at the start
- * of an own text) and `r` the item right after it (the next stream's
- * boundary; `null` at the text's end). A split the writer did not see moves
- * the claim to the piece that ends the region between them.
+ * A claim item's payload: "the display of the block whose stream holds me
+ * continues with block `m`'s" (`merge.claim.anchor`: YATA places it, so a
+ * split its writer did not see leaves it in the piece that ends the
+ * holder's region).
  */
 export type MergeClaim = {
     m: BlockId;
-    a?: ItemRef;
-    r?: ItemRef | null;
 };
-export declare const isMergeClaim: (v: unknown) => v is MergeClaim;
 /** Deterministic claim stamp = engine item id (client-major order). */
 export type Stamp = {
     c: number;
@@ -75,19 +70,13 @@ export type Stamp = {
 };
 export declare const cmpStamp: (a: Stamp, b: Stamp) => number;
 /**
- * One live merge claim: `seqIndex` is its live index in the list that
- * stores it — its holder's, or `holder`'s when its anchor moved it to
- * another block (`merge.claim.anchor`); `-1` for an implicit claim, which
- * no list stores (`id.same.concurrent`). `a`/`r`: its anchor (see
- * {@link MergeClaim}).
+ * One live merge claim: its stamp is its claim item's id; an implicit
+ * claim, which no item stores (`id.same.concurrent`), stamps below every
+ * item (`stamp.c < 0`).
  */
 export type Claim = {
     m: BlockId;
     stamp: Stamp;
-    seqIndex: number;
-    a?: ItemRef;
-    r?: ItemRef | null;
-    holder?: BlockId;
 };
 /** Boundary-item payload in a backing text. */
 export type Boundary = {
@@ -111,8 +100,6 @@ export type SeqItem = {
         type?: EngineNode;
     };
 };
-/** The live merge claims of a `claims` list, with their stamps. */
-export declare const readClaims: (node: EngineNode | undefined) => Claim[];
 /** One emitted range-read element — the `ContentItem` shape. */
 export type RangeItem = {
     kind: 'text';
@@ -164,16 +151,10 @@ export type TextBlockRec = {
     n: unknown;
     /** The block's own backing text, when it has one. */
     content: EngineNode | undefined;
-    /** The `claims` list node (write handle). */
-    claimsNode: EngineNode | undefined;
-    /**
-     * Its effective merge claims (`merge.claim.anchor`): its list's claims
-     * that stay with it, in list order, then those other holders' anchors
-     * moved to it (each with its `holder`), by stamp.
-     */
+    /** Its merge claims: its implicit ones, then the claim items of its stream, in text order. */
     claims: Claim[];
-    /** Its list's live claims, in list order (absent: `claims` is the list). */
-    listClaims?: Claim[];
+    /** Its implicit claims (`id.same.concurrent`), which no item stores. */
+    implicit?: Claim[];
 };
 /** The internal "no display owner" verdict — a symbol, never a block id. */
 export declare const DEAD: unique symbol;
@@ -191,12 +172,23 @@ export declare const claimGraph: (blocks: ReadonlyMap<BlockId, TextBlockRec>) =>
 };
 /** `owner(b)` for every block (see {@link claimGraph}). */
 export declare const computeOwners: (blocks: ReadonlyMap<BlockId, TextBlockRec>) => Map<BlockId, Owner>;
-/** A live boundary at live index `at` of its text; `key` is its item id. */
-export type Bound = Boundary & {
+/**
+ * A unit a row tracks at live index `at` of its text (`key`: its item id): a
+ * live boundary, or a live claim item (`m`, with its stamp), which never
+ * delimits.
+ */
+export type Bound = {
     at: number;
     key: string;
-};
-/** One scanned backing text: its live boundaries in order and its live length. */
+} & ((Boundary & {
+    m?: undefined;
+}) | {
+    m: BlockId;
+    stamp: Stamp;
+    s?: undefined;
+    n?: undefined;
+});
+/** One scanned backing text: its live boundaries and claim items in order, and its live length. */
 export type TextRow = {
     home: BlockId;
     text: EngineNode;
@@ -204,7 +196,7 @@ export type TextRow = {
     len: number;
     key: string;
 };
-/** One stream: `[start, end)` of `home`'s text, minus the inert boundaries at `inert`. */
+/** One stream: `[start, end)` of `home`'s text, minus the inert boundaries and claim items at `inert`. */
 export type Stream = {
     block: BlockId;
     home: BlockId;
@@ -232,6 +224,8 @@ export type Ownership = {
     hidden: (b: BlockId) => boolean;
     /** The claimed block's max-stamp live claimer. */
     top: (m: BlockId) => BlockId | undefined;
+    /** The position of `m` among `holder`'s claims (`-1`: none): the order the claimed blocks' children show in. */
+    claimIndex: (holder: BlockId, m: BlockId) => number;
     streamOf: (b: BlockId) => Stream | undefined;
     /** The streams of `home`'s text, in text order. */
     streamsIn: (home: BlockId) => readonly Stream[];
@@ -239,8 +233,6 @@ export type Ownership = {
     streamAt: (home: BlockId, i: number) => Stream | undefined;
     /** `display(b)` as boundary-free pieces in reading order; `null` when hidden or dead. */
     display: (b: BlockId) => Seg[] | null;
-    /** `b`'s effective claims (`merge.claim.anchor`), when the context computed them. */
-    claimsOf?: (b: BlockId) => readonly Claim[];
 };
 /** Construct a detached v14 node, viewed through the structural interface. */
 export declare const newNode: (name: string) => EngineNode;
@@ -257,6 +249,11 @@ export declare const openRangeCursor: (text: EngineNode) => RangeCursor;
 export declare const itemsOfRange: (text: EngineNode, i0: number, i1: number) => RangeItem[];
 /** The items of `segs`, one cursor per backing text. */
 export declare const readSegs: (segs: readonly Seg[], stats?: RangeReadStats) => RangeItem[];
+/**
+ * A from-scratch ownership context over `given` (every text scanned; the
+ * index's oracle): each block's claims are its implicit ones, then the claim
+ * items of its stream.
+ */
 export declare const computeOwnership: (doc: EngineDoc, given: ReadonlyMap<BlockId, TextBlockRec>) => Ownership;
 /** `b`'s display pieces (`[]` when hidden or streamless and claimless). */
 export declare const flatten: (b: BlockId, blocks: unknown, own: Ownership) => Seg[];
@@ -271,8 +268,25 @@ export declare const blockTextOf: (b: BlockId, blocks: unknown, own: Ownership)
  * `marks` (an operation for each mark its gap gave it otherwise).
  */
 export declare const insertIntoText: (doc: EngineDoc, blocks: unknown, own: Ownership, b: BlockId, offset: number, payload: string | EngineNode, marks?: Record<string, unknown>) => void;
-/** The per-stream delete: each range lies inside one stream's pieces, so no boundary is ever removed. */
+/**
+ * The per-stream delete: each range lies inside one stream's pieces, so no
+ * boundary is ever removed. The text is held by this writer's record (fork
+ * patch YP20, root `textdel`, in the history's scope): an undo deletes the
+ * record and the text shows again where it was, unless another writer's
+ * record holds it. Text the open undo step inserted is removed instead, so
+ * that step's undo still changes nothing.
+ */
 export declare const deleteRange: (doc: EngineDoc, blocks: unknown, own: Ownership, b: BlockId, offset: number, length: number) => void;
+/**
+ * A suggestion's plan being written on a doc (`doc/suggest.ts`): its text
+ * deletes propose (fork patch YP32) into its record, `sort` telling each
+ * unit's lot (`1` its author's own: held; `2` proposed; `3` already
+ * proposed: stepped over).
+ */
+export declare const proposing: WeakMap<EngineDoc, {
+    into: EngineNode;
+    sort: (client: number, clock: number) => number;
+}>;
 export declare const formatRangeIn: (doc: EngineDoc, blocks: unknown, own: Ownership, b: BlockId, offset: number, length: number, formats: Record<string, unknown>) => void;
 /**
  * Delete the content of streams `streams` (the room's purge of a
@@ -290,19 +304,25 @@ export declare const findAtom: (own: Ownership, b: BlockId, inlineId: string) =>
 } | null;
 /**
  * Split `b`'s display at `offset` for the new block `newId` (incarnation
- * `n`): one boundary through fork patch YP7 at the end of the gap, and the claims that
- * follow the split point — every claim of the stream's own block, then each
- * holder's claims after the one that led down — returned for re-insertion
- * on the new block and deleted from their holders. No text is copied.
+ * `n`): one boundary through fork patch YP7 at the end of the gap. The
+ * claims that follow the split point — every claim of the stream's own
+ * block, then each holder's claims after the one that led down — are
+ * written again, in that order, at the end of the new block's stream, and
+ * their items deleted (an implicit claim is written on the new block, whose
+ * claim outranks it). No text is copied.
  */
-export declare const splitAt: (blocks: ReadonlyMap<BlockId, TextBlockRec>, own: Ownership, b: BlockId, offset: number, newId: BlockId, n: number) => MergeClaim[];
+export declare const splitAt: (doc: EngineDoc, blocks: ReadonlyMap<BlockId, TextBlockRec>, own: Ownership, b: BlockId, offset: number, newId: BlockId, n: number) => void;
 /**
- * Append a merge claim `{m: from}` to `into`'s claims list, anchored to
- * the end of `into`'s stream (`merge.claim.anchor`): its last unit (its
- * opening boundary when empty; none at an own text's start) and the item
- * after it.
+ * Merge `from` into `into`: one claim item `{m: from}` at the end of the gap
+ * at the end of `into`'s stream (fork patch YP7; YP21 sorts it after the
+ * content and boundaries a concurrent writer puts at its origin, so a split
+ * the merge's writer did not see leaves it in the piece that ends `into`'s
+ * region: `merge.claim.anchor`). `into` has a stream: the caller gives a
+ * streamless block its own text first.
  */
-export declare const claimInto: (blocks: ReadonlyMap<BlockId, TextBlockRec>, own: Pick<Ownership, "streamOf">, from: BlockId, into: BlockId) => void;
+export declare const claimInto: (own: Pick<Ownership, "streamOf">, from: BlockId, into: BlockId) => void;
+/** Delete the items of `claims` (an implicit claim has none). */
+export declare const deleteClaims: (doc: EngineDoc, claims: readonly Claim[]) => void;
 /**
  * Give streamless block `rec` its own text and re-mint its nonce, so a late
  * copy of its old boundary is inert. Both writes carry a writer id
@@ -340,8 +360,8 @@ export declare const bindText: (_Y: EngineApi) => {
         at: number;
         node: EngineNode;
     } | null;
-    splitAt: (blocks: ReadonlyMap<BlockId, TextBlockRec>, own: Ownership, b: BlockId, offset: number, newId: BlockId, n: number) => MergeClaim[];
-    claimInto: (blocks: ReadonlyMap<BlockId, TextBlockRec>, own: Pick<Ownership, "streamOf">, from: BlockId, into: BlockId) => void;
+    splitAt: (doc: EngineDoc, blocks: ReadonlyMap<BlockId, TextBlockRec>, own: Ownership, b: BlockId, offset: number, newId: BlockId, n: number) => void;
+    claimInto: (own: Pick<Ownership, "streamOf">, from: BlockId, into: BlockId) => void;
     ownText: (doc: EngineDoc, rec: TextBlockRec) => {
         from: unknown;
         to: number;
@@ -353,4 +373,9 @@ export declare const bindText: (_Y: EngineApi) => {
  * typing and keeps the text every replica shares.
  */
 export declare const ownTextIds: WeakMap<EngineDoc, IdSetOf>;
+/**
+ * Each history's open step on a doc (`doc/history.ts` registers them): what
+ * the step still capturing inserted, `null` when none is open.
+ */
+export declare const openSteps: WeakMap<EngineDoc, Set<() => IdSetOf | null>>;
 export type TextEngine = ReturnType<typeof bindText>;

package/dist/crdt/text/model.js

@@ -1,45 +1,16 @@
 import { Y } from '../engine.js';
 import { asYDoc, asYNode, attrItems, engineOps, newNode as makeNode, rangeCursorOf, storeOf } from '../structs.js';
-import { CONTENT, CONTENT_NODE, ID, NONCE, SCHEMA } from '../schema.js';
+import { CONTENT, CONTENT_NODE, ID, NONCE, SCHEMA, TEXT_DELETES_ROOT } from '../schema.js';
 import { DEV } from 'esm-env';
 import { hash32, hash53 } from '../rand.js';
-import { bindDeletes } from './deletes.js';
 import { fitMarks, writeMarks } from './marks.js';
 import { nodeStart } from './items.js';
 import { readRange } from './ranges.js';
-import { delimiters, displayOf, locate, ownedLength, pieces, placeText, rangesOf, scanText } from './streams.js';
-export { isBoundary, nodeStart } from './items.js';
+import { claimsIn, delimiters, displayOf, locate, ownedLength, pieces, placeText, rangesOf, removedKeys, scanText } from './streams.js';
+export { isBoundary, isClaimItem, isRowMark, nodeStart } from './items.js';
 export { canonKey, deepFreeze, inlineItemOf, protectItems, readRange } from './ranges.js';
-export { byId, delimiters, displayOf, locate, ownedLength, pieces, placeText, scanText } from './streams.js';
-const isItemRef = (v) => v != null &&
-    typeof v === 'object' &&
-    Number.isInteger(v.c) &&
-    Number.isInteger(v.k);
-export const isMergeClaim = (v) => v != null && typeof v === 'object' && typeof v.m === 'string';
+export { byId, claimsIn, delimiters, displayOf, locate, ownedLength, pieces, placeText, removedKeys, scanText } from './streams.js';
 export const cmpStamp = (a, b) => a.c - b.c || a.k - b.k;
-/** The live merge claims of a `claims` list, with their stamps. */
-export const readClaims = (node) => {
-    const out = [];
-    let seqIndex = 0;
-    for (let it = node ? nodeStart(node) : null; it !== null; it = it.right) {
-        if (it.deleted || it.countable === false)
-            continue;
-        const arr = it.content.getContent();
-        for (let j = 0; j < it.length; j++) {
-            const p = arr[j];
-            if (isMergeClaim(p)) {
-                const claim = { m: p.m, stamp: { c: it.id.client, k: it.id.clock + j }, seqIndex };
-                if (isItemRef(p.a)) {
-                    claim.a = p.a;
-                    claim.r = isItemRef(p.r) ? p.r : null;
-                }
-                out.push(claim);
-            }
-            seqIndex++;
-        }
-    }
-    return out;
-};
 /** The internal "no display owner" verdict — a symbol, never a block id. */
 export const DEAD = Symbol('edytor.crdt.dead');
 /**
@@ -106,7 +77,6 @@ export const claimGraph = (blocks) => {
 };
 /** `owner(b)` for every block (see {@link claimGraph}). */
 export const computeOwners = (blocks) => claimGraph(blocks).owners;
-const D = bindDeletes(Y);
 const ops = engineOps(Y);
 /** Construct a detached v14 node, viewed through the structural interface. */
 export const newNode = (name) => makeNode(Y, name);
@@ -144,116 +114,44 @@ export const readSegs = (segs, stats) => {
     }
     return out;
 };
-/** A from-scratch ownership context over `blocks` (every text scanned). */
 /**
- * The effective claims of every block, from scratch (`merge.claim.anchor`;
- * the index keeps them incrementally, `text/runs.ts`): an anchored claim
- * goes to the block of the segment just before its `r` (the text's last
- * segment when `r` is null) in the row of its holder's stream, when that
- * segment is the holder's or a later one.
+ * A from-scratch ownership context over `given` (every text scanned; the
+ * index's oracle): each block's claims are its implicit ones, then the claim
+ * items of its stream.
  */
-const effectiveClaims = (doc, blocks, rows, delim, streams) => {
-    /** Live index of unit `ref` (assoc 0) in `text`, or `null` when it is not `text`'s. */
-    const indexIn = (text, ref) => {
-        if (!text._item?.id)
-            return null;
-        const abs = Y.indexOfId(asYDoc(doc), Y.createID(ref.c, ref.k));
-        return abs === null || abs.type !== text ? null : abs.index;
-    };
-    const targetOf = (holder, c) => {
-        if (c.a === undefined)
-            return holder;
-        const s = streams.get(holder);
-        const row = s && rows.get(s.text);
-        if (row === undefined || indexIn(row.text, c.a) === null)
-            return holder;
-        const cuts = [];
-        row.bounds.forEach((b, j) => {
-            if (delim.get(b.s) === b.key)
-                cuts.push(j);
-        });
-        const head = delim.has(row.home) ? null : row.home;
-        // The gap before `r`: a live boundary's own index, else the boundaries before it.
-        let gap = row.bounds.length;
-        if (c.r != null) {
-            const key = `${c.r.c}:${c.r.k}`;
-            const at = row.bounds.findIndex((b) => b.key === key);
-            if (at >= 0)
-                gap = at;
-            else {
-                const p = indexIn(row.text, c.r);
-                if (p === null)
-                    return holder;
-                gap = row.bounds.filter((b) => b.at < p).length;
-            }
-        }
-        const segment = (g) => cuts.filter((j) => j < g).length;
-        const k = segment(gap);
-        // The holder's own segment: the one its stream starts in.
-        const k0 = segment(row.bounds.filter((b) => b.at < s.start).length);
-        if (k < k0)
-            return holder;
-        return (k === 0 ? head : row.bounds[cuts[k - 1]].s) ?? holder;
-    };
-    const own = new Map();
-    const moved = new Map();
-    for (const [h, rec] of blocks) {
-        const stays = [];
-        for (const c of rec.listClaims ?? rec.claims) {
-            const t = targetOf(h, c);
-            if (t === h)
-                stays.push(c);
-            else {
-                let into = moved.get(t);
-                if (into === undefined)
-                    moved.set(t, (into = []));
-                into.push({ ...c, holder: h });
-            }
-        }
-        own.set(h, stays);
-    }
-    for (const [t, list] of moved) {
-        if (!own.has(t))
-            continue;
-        list.sort((x, y) => cmpStamp(x.stamp, y.stamp));
-        own.set(t, [...own.get(t), ...list]);
-    }
-    return own;
-};
 export const computeOwnership = (doc, given) => {
     const rows = [];
     for (const rec of given.values())
         if (rec.content)
             rows.push(scanText(rec.id, rec.content));
-    const delim = delimiters(given, rows);
+    const delim = delimiters(given, rows, removedKeys(doc.get(SCHEMA.roots.registry)));
     const streams = new Map();
     const inText = new Map();
+    const rowOf = new Map();
     for (const row of rows) {
-        const list = placeText(row, delim);
+        const list = placeText(row, delim, (s) => !given.has(s));
         inText.set(row.home, list);
+        rowOf.set(row.text, row);
         for (const s of list)
             streams.set(s.block, s);
     }
-    // The records with their effective claims (`merge.claim.anchor`).
-    const effective = effectiveClaims(doc, given, new Map(rows.map((row) => [row.text, row])), delim, streams);
     const blocks = new Map();
-    for (const [id, rec] of given)
-        blocks.set(id, {
-            ...rec,
-            listClaims: rec.listClaims ?? rec.claims,
-            claims: effective.get(id) ?? rec.claims
-        });
+    for (const [id, rec] of given) {
+        const s = streams.get(id);
+        const items = s === undefined ? [] : claimsIn(rowOf.get(s.text), s);
+        blocks.set(id, { ...rec, claims: [...(rec.implicit ?? []), ...items] });
+    }
     const { owners, top } = claimGraph(blocks);
     const ownerOf = (b) => owners.get(b) ?? DEAD;
     const own = {
         ownerOf,
         hidden: (b) => ownerOf(b) !== b,
         top: (m) => top.get(m),
+        claimIndex: (holder, m) => blocks.get(holder)?.claims.findIndex((c) => c.m === m) ?? -1,
         streamOf: (b) => streams.get(b),
         streamsIn: (home) => inText.get(home) ?? [],
         streamAt: (home, i) => (inText.get(home) ?? []).find((x) => x.start <= i && i <= x.end),
-        display: (b) => displayOf(b, blocks, own),
-        claimsOf: (b) => blocks.get(b)?.claims ?? []
+        display: (b) => displayOf(b, blocks, own)
     };
     return own;
 };
@@ -288,17 +186,27 @@ export const insertIntoText = (doc, blocks, own, b, offset, payload, marks) => {
     const have = at.find((p) => !p.deleted && p.len > 0)?.formats;
     fitMarks(doc, text, hit.idx, payload.length, have, marks);
 };
-/** The per-stream delete: each range lies inside one stream's pieces, so no boundary is ever removed. */
+/**
+ * The per-stream delete: each range lies inside one stream's pieces, so no
+ * boundary is ever removed. The text is held by this writer's record (fork
+ * patch YP20, root `textdel`, in the history's scope): an undo deletes the
+ * record and the text shows again where it was, unless another writer's
+ * record holds it. Text the open undo step inserted is removed instead, so
+ * that step's undo still changes nothing.
+ */
 export const deleteRange = (doc, blocks, own, b, offset, length) => {
-    const spans = [];
-    for (const r of rangesOf(flatten(b, blocks, own), offset, offset + length)) {
-        for (const p of openRangeCursor(r.text).read(r.a, r.b))
-            if (!p.deleted && p.len > 0 && (p.content.str !== undefined || 'type' in p.content))
-                spans.push({ c: p.id.client, k: p.id.clock, n: p.len });
-        r.text.delete(r.a, r.b - r.a);
-    }
-    D.markDeleted(doc, spans);
+    const records = doc.get(TEXT_DELETES_ROOT);
+    const fresh = openInserts(doc);
+    for (const r of rangesOf(flatten(b, blocks, own), offset, offset + length))
+        r.text.delete(r.a, r.b - r.a, records, fresh, proposing.get(doc));
 };
+/**
+ * A suggestion's plan being written on a doc (`doc/suggest.ts`): its text
+ * deletes propose (fork patch YP32) into its record, `sort` telling each
+ * unit's lot (`1` its author's own: held; `2` proposed; `3` already
+ * proposed: stepped over).
+ */
+export const proposing = new WeakMap();
 export const formatRangeIn = (doc, blocks, own, b, offset, length, formats) => {
     for (const r of rangesOf(flatten(b, blocks, own), offset, offset + length))
         writeMarks(doc, r.text, r.a, r.b - r.a, formats);
@@ -337,60 +245,52 @@ export const findAtom = (own, b, inlineId) => {
 };
 /**
  * Split `b`'s display at `offset` for the new block `newId` (incarnation
- * `n`): one boundary through fork patch YP7 at the end of the gap, and the claims that
- * follow the split point — every claim of the stream's own block, then each
- * holder's claims after the one that led down — returned for re-insertion
- * on the new block and deleted from their holders. No text is copied.
+ * `n`): one boundary through fork patch YP7 at the end of the gap. The
+ * claims that follow the split point — every claim of the stream's own
+ * block, then each holder's claims after the one that led down — are
+ * written again, in that order, at the end of the new block's stream, and
+ * their items deleted (an implicit claim is written on the new block, whose
+ * claim outranks it). No text is copied.
  */
-export const splitAt = (blocks, own, b, offset, newId, n) => {
+export const splitAt = (doc, blocks, own, b, offset, newId, n) => {
     const segs = flatten(b, blocks, own);
     const hit = locate(segs, Math.max(0, Math.min(offset, ownedLength(segs))));
     if (hit === null)
         throw new Error(`splitAt: "${b}" has no stream`);
     const { seg, idx } = hit;
-    const moved = [];
-    // A claim another block stores (its anchor moved it here) is deleted from that list.
-    const after = (holder, from) => blocks
-        .get(holder)
-        .claims.slice(from)
-        .forEach((c) => moved.push({ holder: c.holder ?? holder, claim: c }));
-    after(seg.block, 0);
+    const moved = [...blocks.get(seg.block).claims];
     for (let i = seg.path.length - 1; i >= 0; i--)
-        after(seg.path[i].holder, seg.path[i].entry + 1);
+        moved.push(...blocks.get(seg.path[i].holder).claims.slice(seg.path[i].entry + 1));
     const text = seg.text;
+    // The new block's stream ends where the source's did, one boundary later.
+    const end = own.streamOf(seg.block).end + 1;
     text.insertAtGapEnd(idx, [{ s: newId, n }]);
-    const byHolder = new Map();
-    // An implicit claim (a losing incarnation) has no list entry: it is
-    // only written, explicitly, on the new block, whose claim outranks it.
-    for (const { holder, claim } of moved)
-        if (claim.seqIndex >= 0)
-            byHolder.set(holder, [...(byHolder.get(holder) ?? []), claim.seqIndex]);
-    for (const [holder, idxs] of byHolder) {
-        const list = blocks.get(holder).claimsNode;
-        for (const i of idxs.sort((x, y) => y - x))
-            list.delete(i, 1);
-    }
-    // Re-inserted with their anchors: the region they end is the new block's now.
-    return moved.map(({ claim: c }) => c.a === undefined ? { m: c.m } : { m: c.m, a: c.a, r: c.r ?? null });
+    if (moved.length === 0)
+        return;
+    text.insertAtGapEnd(end, moved.map((c) => ({ m: c.m })));
+    deleteClaims(doc, moved);
 };
 /**
- * Append a merge claim `{m: from}` to `into`'s claims list, anchored to
- * the end of `into`'s stream (`merge.claim.anchor`): its last unit (its
- * opening boundary when empty; none at an own text's start) and the item
- * after it.
+ * Merge `from` into `into`: one claim item `{m: from}` at the end of the gap
+ * at the end of `into`'s stream (fork patch YP7; YP21 sorts it after the
+ * content and boundaries a concurrent writer puts at its origin, so a split
+ * the merge's writer did not see leaves it in the piece that ends `into`'s
+ * region: `merge.claim.anchor`). `into` has a stream: the caller gives a
+ * streamless block its own text first.
  */
-export const claimInto = (blocks, own, from, into) => {
-    const list = blocks.get(into).claimsNode;
-    const claim = { m: from };
+export const claimInto = (own, from, into) => {
     const s = own.streamOf(into);
-    if (s !== undefined) {
-        const a = anchorAt(s.text, s.end, -1).i;
-        if (a !== null) {
-            claim.a = a;
-            claim.r = anchorAt(s.text, s.end, 0).i;
-        }
+    s.text.insertAtGapEnd(s.end, [{ m: from }]);
+};
+/** Delete the items of `claims` (an implicit claim has none). */
+export const deleteClaims = (doc, claims) => {
+    const store = storeOf(doc);
+    for (const { stamp } of claims) {
+        if (stamp.c < 0 || store.getItem({ client: stamp.c, clock: stamp.k }).deleted)
+            continue;
+        const at = Y.indexOfId(asYDoc(doc), Y.createID(stamp.c, stamp.k));
+        at.type.delete(at.index, 1);
     }
-    list.insert(list.length, [claim]);
 };
 /**
  * Give streamless block `rec` its own text and re-mint its nonce, so a late
@@ -467,3 +367,25 @@ export const bindText = (_Y) => ({
  * typing and keeps the text every replica shares.
  */
 export const ownTextIds = new WeakMap();
+/**
+ * Each history's open step on a doc (`doc/history.ts` registers them): what
+ * the step still capturing inserted, `null` when none is open.
+ */
+export const openSteps = new WeakMap();
+/**
+ * What this writer inserted in the open undo steps of `doc` (`null`: none):
+ * a history capturing a peer's frames (the room's validation) opens steps of
+ * that peer's writes, never fresh here.
+ */
+const openInserts = (doc) => {
+    let fresh = null;
+    for (const open of openSteps.get(doc) ?? []) {
+        const ranges = open()?.clients.get(doc.clientID);
+        if (ranges === undefined)
+            continue;
+        fresh ??= ops.idSet();
+        for (const r of ranges.getIds())
+            fresh.add(doc.clientID, r.clock, r.len);
+    }
+    return fresh;
+};

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

@@ -15,6 +15,6 @@ export declare const inlineItemOf: (entry: unknown) => RangeItem;
 /**
  * Read `[i0, i1)` through the cursor: text pieces as UTF-16 slices under their
  * folded marks (adjacent equal marks merge), inline atoms one item each.
- * Boundary items are skipped — the one read predicate stream ownership needs.
+ * Boundary and claim items are skipped — the one read predicate stream ownership needs.
  */
 export declare const readRange: (cur: RangeCursor, i0: number, i1: number, stats?: RangeReadStats, items?: RangeItem[]) => RangeItem[];

package/dist/crdt/text/ranges.js

@@ -1,6 +1,6 @@
 import { ID, TYPE } from '../schema.js';
 import { readData } from '../data.js';
-import { isBoundary } from './items.js';
+import { isRowMark } from './items.js';
 /** Canonical JSON key (sorted keys, recursive) — mark-set equality/interning. */
 export const canonKey = (v) => {
     if (v === null || typeof v !== 'object')
@@ -52,7 +52,7 @@ export const inlineItemOf = (entry) => {
 /**
  * Read `[i0, i1)` through the cursor: text pieces as UTF-16 slices under their
  * folded marks (adjacent equal marks merge), inline atoms one item each.
- * Boundary items are skipped — the one read predicate stream ownership needs.
+ * Boundary and claim items are skipped — the one read predicate stream ownership needs.
  */
 export const readRange = (cur, i0, i1, stats, items = []) => {
     for (const piece of cur.read(i0, i1, stats)) {
@@ -73,7 +73,7 @@ export const readRange = (cur, i0, i1, stats, items = []) => {
         else if (typeof c.getContent === 'function') {
             const arr = c.getContent();
             for (let k = piece.offset; k < piece.offset + piece.len; k++) {
-                if (!isBoundary(arr[k]))
+                if (!isRowMark(arr[k]))
                     items.push(inlineItemOf(arr[k]));
             }
         }