edytor 1.0.0-rc.3 → 2.0.0

package/dist/crdt/text/model.js

@@ -1,4 +1,5 @@
-import { asYDoc, asYNode, attrItems, engineOps, newNode as makeNode, rangeCursorOf, storeOf, withoutRenderer } from '../structs.js';
+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 { DEV } from 'esm-env';
 import { hash32, hash53 } from '../rand.js';
@@ -105,372 +106,361 @@ export const claimGraph = (blocks) => {
 };
 /** `owner(b)` for every block (see {@link claimGraph}). */
 export const computeOwners = (blocks) => claimGraph(blocks).owners;
-/** Every write addresses live-content space: a renderer on a backing text is a read concern. */
-const plain = (text, f) => withoutRenderer(text, f);
-export const bindText = (Y) => {
-    const D = bindDeletes(Y);
-    const newNode = (name) => makeNode(Y, name);
-    const ops = engineOps(Y);
-    /** Anchor → live index in `text`, or `null` when its item is not integrated here. */
-    const resolveAnchor = (doc, text, anchor) => {
-        const itemId = text._item?.id;
-        if (!itemId)
-            return anchor.i === null ? (anchor.a < 0 ? 0 : text.length) : null;
-        const abs = Y.createAbsolutePositionFromRelativePosition(Y.createRelativePositionFromJSON({
-            type: { client: itemId.client, clock: itemId.clock },
-            item: anchor.i === null ? null : { client: anchor.i.c, clock: anchor.i.k },
-            assoc: anchor.a
-        }), asYDoc(doc), false);
-        return abs === null ? null : abs.index;
-    };
-    /**
-     * Live index → anchor bound on the `assoc` side: `assoc < 0` binds the unit
-     * before `index` (an insert at `index` lands right of it; `i: null` at the
-     * text start), `assoc >= 0` the unit at `index` (`i: null` at the text end).
-     */
-    const anchorAt = (text, index, assoc) => {
-        const json = Y.relativePositionToJSON(Y.createRelativePositionFromTypeIndex(asYNode(text), index, assoc));
-        return {
-            i: json.item ? { c: json.item.client, k: json.item.clock } : null,
-            a: assoc < 0 ? -1 : 0
-        };
-    };
-    /** A renderer-free bounded read cursor on `text` (live-content space). */
-    const openRangeCursor = (text) => rangeCursorOf(Y, text);
-    const itemsOfRange = (text, i0, i1) => readRange(openRangeCursor(text), i0, i1);
-    /** The items of `segs`, one cursor per backing text. */
-    const readSegs = (segs, stats) => {
-        const out = [];
-        const cursors = new Map();
-        for (const seg of segs) {
-            let cur = cursors.get(seg.text);
-            if (cur === undefined)
-                cursors.set(seg.text, (cur = openRangeCursor(seg.text)));
-            readRange(cur, seg.i0, seg.i1, stats, out);
-        }
-        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.
-     */
-    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) => {
-            const itemId = text._item?.id;
-            if (!itemId)
-                return null;
-            const abs = Y.createAbsolutePositionFromRelativePosition(Y.createRelativePositionFromJSON({
-                type: { client: itemId.client, clock: itemId.clock },
-                item: { client: ref.c, clock: ref.k },
-                assoc: 0
-            }), asYDoc(doc), false);
-            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;
-    };
-    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 streams = new Map();
-        const inText = new Map();
-        for (const row of rows) {
-            const list = placeText(row, delim);
-            inText.set(row.home, list);
-            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
-            });
-        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),
-            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 ?? []
-        };
-        return own;
-    };
-    /** `b`'s display pieces (`[]` when hidden or streamless and claimless). */
-    const flatten = (b, blocks, own) => {
-        void blocks;
-        return own.display(b) ?? [];
+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);
+/** Anchor → live index in `text`, or `null` when its item is not integrated here. */
+export const resolveAnchor = (doc, text, anchor) => {
+    const item = text._item;
+    // A text end: the text's own length, while the text is held (not collected).
+    if (anchor.i === null)
+        return !item?.id || item.content?.type === text ? (anchor.a < 0 ? 0 : text.length) : null;
+    if (!item?.id)
+        return null;
+    return Y.indexOfId(asYDoc(doc), Y.createID(anchor.i.c, anchor.i.k), anchor.a)?.index ?? null;
+};
+/**
+ * Live index → anchor bound on the `assoc` side: `assoc < 0` binds the unit
+ * before `index` (an insert at `index` lands right of it; `i: null` at the
+ * text start), `assoc >= 0` the unit at `index` (`i: null` at the text end).
+ */
+export const anchorAt = (text, index, assoc) => {
+    const id = Y.idAtIndex(asYNode(text), index, assoc);
+    return { i: id ? { c: id.client, k: id.clock } : null, a: assoc < 0 ? -1 : 0 };
+};
+/** A bounded read cursor on `text` (live-content space). */
+export const openRangeCursor = (text) => rangeCursorOf(Y, text);
+export const itemsOfRange = (text, i0, i1) => readRange(openRangeCursor(text), i0, i1);
+/** The items of `segs`, one cursor per backing text. */
+export const readSegs = (segs, stats) => {
+    const out = [];
+    const cursors = new Map();
+    for (const seg of segs) {
+        let cur = cursors.get(seg.text);
+        if (cur === undefined)
+            cursors.set(seg.text, (cur = openRangeCursor(seg.text)));
+        readRange(cur, seg.i0, seg.i1, stats, out);
+    }
+    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.
+ */
+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 contentItemsOf = (b, blocks, own) => readSegs(flatten(b, blocks, own));
-    const blockTextOf = (b, blocks, own) => contentItemsOf(b, blocks, own)
-        .map((i) => (i.kind === 'text' ? i.text : ''))
-        .join('');
-    // ── writes (inside doc.transact; the plan clamped offsets) ────────
-    /**
-     * Insert at a display offset, beside the boundary the engine walk and the
-     * left side choose. The display must be non-empty: a streamless block gets
-     * its own text first ({@link ownText}). The content goes in its gap
-     * (`insertInGap`, fork patch YP13: after the marks attached to the text before it,
-     * before those attached to the text after it); text then shows exactly
-     * `marks` (an operation for each mark its gap gave it otherwise).
-     */
-    const insertIntoText = (doc, blocks, own, b, offset, payload, marks) => {
-        const segs = flatten(b, blocks, own);
-        const hit = locate(segs, Math.max(0, Math.min(offset, ownedLength(segs))));
-        if (hit === null)
-            throw new Error(`insertIntoText: "${b}" has no stream`);
-        const text = hit.seg.text;
-        plain(text, () => {
-            if (typeof payload !== 'string')
-                return text.insertInGap(hit.idx, [payload]);
-            text.insertInGap(hit.idx, payload);
-            const at = openRangeCursor(text).read(hit.idx, hit.idx + payload.length);
-            const have = at.find((p) => !p.deleted && p.len > 0)?.formats;
-            fitMarks(doc, text, hit.idx, payload.length, have, marks);
+    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);
         });
-    };
-    /** The per-stream delete: each range lies inside one stream's pieces, so no boundary is ever removed. */
-    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 });
-            plain(r.text, () => r.text.delete(r.a, r.b - r.a));
-        }
-        D.markDeleted(doc, spans);
-    };
-    const formatRangeIn = (doc, blocks, own, b, offset, length, formats) => {
-        for (const r of rangesOf(flatten(b, blocks, own), offset, offset + length))
-            plain(r.text, () => writeMarks(doc, r.text, r.a, r.b - r.a, formats));
-    };
-    /**
-     * Delete the content of streams `streams` (the room's purge of a
-     * block deleted past the horizon): every piece, so no boundary goes and
-     * each stream still delimits, renderer-free, writing no delete mark.
-     * Streams of one text are deleted from its end, so the indices the
-     * caller read stay valid.
-     */
-    const purgeStreams = (streams) => {
-        const ordered = [...streams].sort((a, b) => b.start - a.start);
-        for (const s of ordered) {
-            const parts = pieces(s).filter(([a, b]) => b > a);
-            for (let i = parts.length - 1; i >= 0; i--) {
-                const [a, b] = parts[i];
-                plain(s.text, () => s.text.delete(a, b - a));
+        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;
     };
-    /** The inline atom `inlineId` in `b`'s display: its text, engine index and node. */
-    const findAtom = (own, b, inlineId) => {
-        for (const s of own.display(b) ?? []) {
-            let at = 0;
-            for (let it = nodeStart(s.text); it !== null && at < s.i1; it = it.right) {
-                if (it.deleted || it.countable === false)
-                    continue;
-                const node = it.content.type;
-                if (node !== undefined && at >= s.i0 && node.getAttr(ID) === inlineId)
-                    return { text: s.text, at, node };
-                at += it.length;
+    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 });
             }
         }
-        return 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.
-     */
-    const splitAt = (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);
-        for (let i = seg.path.length - 1; i >= 0; i--)
-            after(seg.path[i].holder, seg.path[i].entry + 1);
-        const text = seg.text;
-        plain(text, () => 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 });
+        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 streams = new Map();
+    const inText = new Map();
+    for (const row of rows) {
+        const list = placeText(row, delim);
+        inText.set(row.home, list);
+        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
+        });
+    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),
+        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 ?? []
     };
-    /**
-     * 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.
-     */
-    const claimInto = (blocks, own, from, into) => {
-        const list = blocks.get(into).claimsNode;
-        const claim = { m: from };
-        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;
-            }
+    return own;
+};
+/** `b`'s display pieces (`[]` when hidden or streamless and claimless). */
+export const flatten = (b, blocks, own) => {
+    void blocks;
+    return own.display(b) ?? [];
+};
+export const contentItemsOf = (b, blocks, own) => readSegs(flatten(b, blocks, own));
+export const blockTextOf = (b, blocks, own) => contentItemsOf(b, blocks, own)
+    .map((i) => (i.kind === 'text' ? i.text : ''))
+    .join('');
+// ── writes (inside doc.transact; the plan clamped offsets) ────────
+/**
+ * Insert at a display offset, beside the boundary the engine walk and the
+ * left side choose. The display must be non-empty: a streamless block gets
+ * its own text first ({@link ownText}). The content goes in its gap
+ * (`insertInGap`, fork patch YP13: after the marks attached to the text before it,
+ * before those attached to the text after it); text then shows exactly
+ * `marks` (an operation for each mark its gap gave it otherwise).
+ */
+export const insertIntoText = (doc, blocks, own, b, offset, payload, marks) => {
+    const segs = flatten(b, blocks, own);
+    const hit = locate(segs, Math.max(0, Math.min(offset, ownedLength(segs))));
+    if (hit === null)
+        throw new Error(`insertIntoText: "${b}" has no stream`);
+    const text = hit.seg.text;
+    if (typeof payload !== 'string')
+        return text.insertInGap(hit.idx, [payload]);
+    text.insertInGap(hit.idx, payload);
+    const at = openRangeCursor(text).read(hit.idx, hit.idx + payload.length);
+    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. */
+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);
+};
+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);
+};
+/**
+ * Delete the content of streams `streams` (the room's purge of a
+ * block deleted past the horizon): every piece, so no boundary goes and
+ * each stream still delimits, writing no delete mark.
+ * Streams of one text are deleted from its end, so the indices the
+ * caller read stay valid.
+ */
+export const purgeStreams = (streams) => {
+    const ordered = [...streams].sort((a, b) => b.start - a.start);
+    for (const s of ordered) {
+        const parts = pieces(s).filter(([a, b]) => b > a);
+        for (let i = parts.length - 1; i >= 0; i--) {
+            const [a, b] = parts[i];
+            s.text.delete(a, b - a);
         }
-        list.insert(list.length, [claim]);
-    };
-    /**
-     * 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
-     * derived from the block's node and its dead incarnation, so replicas that
-     * type into the block concurrently write the SAME items and both typings
-     * land in one text (the seed writer's mechanism). Returns the nonce
-     * change (the caller moves the block's attribution record with it).
-     */
-    const ownText = (doc, rec) => {
-        const map = attrItems(rec.node);
-        const idOf = (x) => {
-            const it = x?.id;
-            return it === undefined ? '-' : `${it.client}:${it.clock}`;
-        };
-        const seed = [
-            `own/${SCHEMA.name}@${SCHEMA.version}`,
-            rec.id,
-            String(rec.n),
-            idOf(rec.node._item),
-            idOf(map.get(NONCE)),
-            idOf(map.get(CONTENT))
-        ].join('|');
-        const writer = hash53(seed) || 1;
-        const to = hash32(`${seed}|n`);
-        const store = storeOf(doc);
-        // The derivation is fresh per incarnation: a writer that already wrote
-        // here is another block's (a hash collision, the known residual class).
-        if (DEV && store.getClock(writer) !== 0)
-            console.warn(`[edytor] own-text writer ${writer} of block ${rec.id} collides`);
-        const local = doc.clientID;
-        doc.clientID = writer;
-        try {
-            rec.node.setAttr(CONTENT, newNode(CONTENT_NODE));
-            rec.node.setAttr(NONCE, to);
+    }
+};
+/** The inline atom `inlineId` in `b`'s display: its text, engine index and node. */
+export const findAtom = (own, b, inlineId) => {
+    for (const s of own.display(b) ?? []) {
+        let at = 0;
+        for (let it = nodeStart(s.text); it !== null && at < s.i1; it = it.right) {
+            if (it.deleted || it.countable === false)
+                continue;
+            const node = it.content.type;
+            if (node !== undefined && at >= s.i0 && node.getAttr(ID) === inlineId)
+                return { text: s.text, at, node };
+            at += it.length;
         }
-        finally {
-            doc.clientID = local;
+    }
+    return 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.
+ */
+export const splitAt = (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);
+    for (let i = seg.path.length - 1; i >= 0; i--)
+        after(seg.path[i].holder, seg.path[i].entry + 1);
+    const text = seg.text;
+    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 });
+};
+/**
+ * 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.
+ */
+export const claimInto = (blocks, own, from, into) => {
+    const list = blocks.get(into).claimsNode;
+    const claim = { m: from };
+    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;
         }
-        const ids = ownTextIds.get(doc) ?? ops.idSet();
-        ownTextIds.set(doc, ids);
-        const clock = store.getClock(writer);
-        ids.add(writer, clock - 2, 2);
-        return { from: rec.n, to };
-    };
-    return {
-        newNode,
-        resolveAnchor,
-        anchorAt,
-        openRangeCursor,
-        itemsOfRange,
-        readSegs,
-        computeOwnership,
-        flatten,
-        ownedLength,
-        contentItemsOf,
-        blockTextOf,
-        insertIntoText,
-        deleteRange,
-        formatRangeIn,
-        purgeStreams,
-        findAtom,
-        splitAt,
-        claimInto,
-        ownText
+    }
+    list.insert(list.length, [claim]);
+};
+/**
+ * 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
+ * derived from the block's node and its dead incarnation, so replicas that
+ * type into the block concurrently write the SAME items and both typings
+ * land in one text (the seed writer's mechanism). Returns the nonce
+ * change (the caller moves the block's attribution record with it).
+ */
+export const ownText = (doc, rec) => {
+    const map = attrItems(rec.node);
+    const idOf = (x) => {
+        const it = x?.id;
+        return it === undefined ? '-' : `${it.client}:${it.clock}`;
     };
+    const seed = [
+        `own/${SCHEMA.name}@${SCHEMA.version}`,
+        rec.id,
+        String(rec.n),
+        idOf(rec.node._item),
+        idOf(map.get(NONCE)),
+        idOf(map.get(CONTENT))
+    ].join('|');
+    const writer = hash53(seed) || 1;
+    const to = hash32(`${seed}|n`);
+    const store = storeOf(doc);
+    // The derivation is fresh per incarnation: a writer that already wrote
+    // here is another block's (a hash collision, the known residual class).
+    if (DEV && store.getClock(writer) !== 0)
+        console.warn(`[edytor] own-text writer ${writer} of block ${rec.id} collides`);
+    const local = doc.clientID;
+    doc.clientID = writer;
+    try {
+        rec.node.setAttr(CONTENT, newNode(CONTENT_NODE));
+        rec.node.setAttr(NONCE, to);
+    }
+    finally {
+        doc.clientID = local;
+    }
+    const ids = ownTextIds.get(doc) ?? ops.idSet();
+    ownTextIds.set(doc, ids);
+    const clock = store.getClock(writer);
+    ids.add(writer, clock - 2, 2);
+    return { from: rec.n, to };
 };
+/**
+ * The text engine as one object (the public binding's `text`): the reads
+ * and writes above. Edytor's own modules import them directly.
+ */
+export const bindText = (_Y) => ({
+    newNode,
+    resolveAnchor,
+    anchorAt,
+    openRangeCursor,
+    itemsOfRange,
+    readSegs,
+    computeOwnership,
+    flatten,
+    ownedLength,
+    contentItemsOf,
+    blockTextOf,
+    insertIntoText,
+    deleteRange,
+    formatRangeIn,
+    purgeStreams,
+    findAtom,
+    splitAt,
+    claimInto,
+    ownText
+});
 /**
  * The items this replica wrote with a derived own-text writer (local only): a
  * history step never captures them, so undoing the first typing removes the