edytor 1.0.0-rc.2 → 1.0.0

package/dist/crdt/text/deletes.js

@@ -1,10 +1,10 @@
 import { CONTENT_NODE, HORIZON_ROOT, INLINE_NODE, RESTORED_ROOT, TEXT_DELETES_ROOT } from '../schema.js';
-import { attrItems, clientsOf, dropSearchMarkers, engineOps, firstItem, keepFromCollection, nextClock, onTransaction, stepsOf, structAt, walkIdSetStructs } from '../structs.js';
+import { attrItems, clientsOf, dropSearchMarkers, engineOps, firstItem, keepFromCollection, nextClock, onTransaction, stepsOf, structAt, walkIdSet } from '../structs.js';
 import { clip, decode, deleteIndex, encode, FOLD_SPANS, keyOf, mergeSpans, overlaps } from './delete-index.js';
 const REACT = Symbol('edytor.text-deletes');
 const states = new WeakMap();
 export const bindDeletes = (Y) => {
-    const { idSet, each, rootSpans, members, liveRoots, shown, indexOf, leaves, holders, minus, parts, addCopies, indexRecord, indexMark, dropMarks, recordsIn, sync, copiesOf, forget, collect } = deleteIndex(Y);
+    const { idSet, each, rootSpans, members, liveRoots, shown, indexOf, leaves, holders, minus, parts, addCopies, indexRecord, indexMark, recordsIn, sync } = deleteIndex(Y);
     const ops = engineOps(Y);
     const attach = (doc) => {
         let s = states.get(doc);
@@ -75,7 +75,7 @@ export const bindDeletes = (Y) => {
                 // A leaf has no copy: a local `redone` link left by an earlier
                 // restoration points at a copy this lineage no longer shows.
                 it.redone = null;
-                const copy = ops.redo(tr, it, new Set([it]), p.um());
+                const copy = ops.redo(tr, it, new Set([it]));
                 if (copy === null)
                     continue;
                 dropSearchMarkers(copy.parent);
@@ -85,7 +85,7 @@ export const bindDeletes = (Y) => {
                 if (attrs !== undefined) {
                     const kids = [...attrs.values()].filter((c) => c.deleted);
                     for (const kid of kids)
-                        ops.redo(tr, kid, new Set(kids), p.um());
+                        ops.redo(tr, kid, new Set(kids));
                 }
                 const e = {
                     c: copy.id.client,
@@ -252,14 +252,9 @@ export const bindDeletes = (Y) => {
     /** The text units `ids` names, as spans. */
     const unitsIn = (s, ids) => {
         const out = [];
-        ids.clients.forEach((ranges, c) => {
-            for (const r of ranges.getIds())
-                walkIdSetStructs(Y, s.doc, idSet([{ c, k: r.clock, n: r.len }]), (st) => {
-                    const lo = Math.max(r.clock, st.id.clock);
-                    const hi = Math.min(r.clock + r.len, st.id.clock + st.length);
-                    if (hi > lo && isUnit(st))
-                        out.push({ c, k: lo, n: hi - lo });
-                });
+        walkIdSet(Y, s.doc, ids, (st, lo, hi) => {
+            if (hi > lo && isUnit(st))
+                out.push({ c: st.id.client, k: lo, n: hi - lo });
         });
         return out;
     };
@@ -320,68 +315,10 @@ export const bindDeletes = (Y) => {
             if (tr !== null)
                 remove(tr, shown(s, spans.flatMap((sp) => rootSpans(s, sp))));
         },
-        /**
-         * Whether every live mark holding a character of `spans` was written
-         * where `old` says (a withdrawn block's content was deleted
-         * before the horizon). Characters no mark holds count as old.
-         */
-        heldBefore: (doc, spans, old) => {
-            const s = attach(doc);
-            return spans
-                .flatMap((sp) => rootSpans(s, sp))
-                .every((r) => holders(s, r).every((mark) => old(mark.client, mark.clock)));
-        },
-        /**
-         * The purge's part (`room.purge.what`), inside the purge
-         * transaction: delete every text delete mark record `old` names, and
-         * every restoration record `old` names whose copies are all deleted
-         * and that no remaining mark holds; its copies are forgotten (the
-         * `gcFilter` no longer keeps them) and collected. Writes no mark.
-         */
-        purge: (doc, old) => {
-            const s = attach(doc);
-            const tr = s.doc._transaction;
-            if (tr === null)
-                throw new Error('purge: outside a transaction');
-            const spans = [];
-            const dropped = [];
-            for (let it = firstItem(s.marks); it; it = it.right)
-                if (!it.deleted)
-                    for (let j = 0; j < it.length; j++) {
-                        const r = { client: it.id.client, clock: it.id.clock + j };
-                        if (!old(r.client, r.clock))
-                            continue;
-                        dropped.push(r);
-                        const last = spans[spans.length - 1];
-                        if (last !== undefined && last.c === r.client && last.k + last.n === r.clock)
-                            last.n++;
-                        else
-                            spans.push({ c: r.client, k: r.clock, n: 1 });
-                    }
-            dropMarks(s, dropped);
-            const marks = dropped.length;
-            remove(tr, spans);
-            const doomed = [];
-            attrItems(s.restored).forEach((it, key) => {
-                if (it.deleted || !old(it.id.client, it.id.clock))
-                    return;
-                const [record, bytes] = recordsIn(it, null)[0] ?? [];
-                if (bytes === undefined)
-                    return;
-                const copies = copiesOf(record, bytes);
-                const dead = copies.every((e) => liveRoots(s, { c: e.c, k: e.k, n: e.n, rk: e.k }).length === 0 &&
-                    holders(s, { c: e.rc, k: e.rk, n: e.n }).length === 0);
-                if (dead)
-                    doomed.push({ key, copies });
-            });
-            for (const { key, copies } of doomed) {
-                s.restored.deleteAttr(key);
-                forget(s, copies);
-                collect(s, tr, copies);
-            }
-            return { marks, records: doomed.length };
-        },
-        /** The `restoreFilter` and `onApply` options of a history on `doc` (fork patch YP11). */
+        /** A doc's index of marks and copies, and the delete the purge writes (`purge.ts`). */
+        state: attach,
+        remove,
+        /** The restore and apply rules of a history on `doc` (`doc/history.ts`). */
         history: (doc, um) => {
             const s = attach(doc);
             const p = { um, watch: [], tr: null, units: [] };

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

@@ -3,11 +3,11 @@
  * when a fold invalidates it, sharing unchanged runs and interned payloads.
  */
 import { cloneJsonSafe } from '../../../utils/json.js';
-import { canonKey, deepFreeze, displayOf } from '../model.js';
+import { canonKey, deepFreeze, displayOf, readSegs } from '../model.js';
 import { runEquals } from './shared.js';
 /** The run cache of one doc's index. */
 export const indexCache = (ix) => {
-    const { T, blocks, textConsumers, listConsumers, cache, dirty, foldStats, frames, ownShim } = ix;
+    const { blocks, textConsumers, listConsumers, cache, dirty, foldStats, frames, ownShim } = ix;
     const rangeStats = { items: 0, markers: 0 };
     // ── run cache ────────────────────────────────────────────────────
     const internMap = new Map();
@@ -97,7 +97,7 @@ export const indexCache = (ix) => {
                 deps.lists.add(c.m);
         }) ?? [];
         const fresh = [];
-        for (const item of T.readSegs(segs, rangeStats)) {
+        for (const item of readSegs(segs, rangeStats)) {
             if (item.kind === 'text') {
                 const last = fresh[fresh.length - 1];
                 const marks = item.marks === undefined ? undefined : intern(item.marks);

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

@@ -1,4 +1,3 @@
-import type { EngineDeepEvent } from '../../engine-api.js';
 import { type BlockId } from '../../placement/model.js';
 import type { ContentRun } from '../runs.js';
 import type { IndexAnchored } from './anchored.js';
@@ -17,7 +16,7 @@ export declare const indexFold: (ix: IndexState & IndexClaims & IndexStreams & I
     openTx: () => Tx | null | undefined;
     syncAll: () => void;
     unfolded: () => boolean;
-    onCommit: (e: EngineDeepEvent) => void;
+    onCommit: (tr: Tx) => void;
     committed: WeakSet<Tx>;
 };
 export type IndexFold = ReturnType<typeof indexFold>;

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

@@ -4,16 +4,17 @@
  * pending part of every transaction whose commit fold has not run.
  */
 import { readData } from '../../data.js';
+import { Y } from '../../engine.js';
 import { LIVE_WRITERS, baseIdOf, incarnationId } from '../../incarnations.js';
 import { candidatesOf } from '../../placement/model.js';
 import { CONTENT, NONCE, hasDeleteMark, isNodeLike } from '../../schema.js';
-import { engineOps, itemOf, queuedTransactions, sequenceLength, walkIdSetRanges, walkIdSetStructs } from '../../structs.js';
+import { changedUnder, engineOps, itemOf, queuedTransactions, sequenceLength, walkIdSet } from '../../structs.js';
 import { DEAD, isBoundary } from '../model.js';
 import { gapOfItem, headOf, rowLength, segmentOfGap, shiftGap } from '../rows.js';
-import { CONTENT_ATTR, EMPTY_RUNS, ENTRY_FACET, facetOf, indexChecks, sameShape, typeAttr } from './shared.js';
+import { CONTENT_ATTR, EMPTY_RUNS, ENTRY_FACET, facetOf, checksOf, indexChecks, sameShape, typeAttr } from './shared.js';
 /** The fold of one doc's index, over every part it folds into. */
 export const indexFold = (ix) => {
-    const { Y, doc, registry, dataRoot, blocks, shells, textConsumers, ownerSeeds, rows, retargets, unresolved, reclaim, placementSeeds, stateSeeds, incarnations, cache, dirty, foldStats, frames, candidates, ownerOf, invalidateBlock, streamOf, streamsIn, setRow, scanRow, refreshDelims, placeHome, applyRetargets, noteKind, argParent, noteCands, kept, updateBlockRec, ensureRec, syncIncarnations, computeRuns, tableFacts } = ix;
+    const { doc, registry, dataRoot, blocks, shells, textConsumers, ownerSeeds, rows, retargets, unresolved, reclaim, placementSeeds, stateSeeds, incarnations, cache, dirty, foldStats, frames, candidates, ownerOf, invalidateBlock, streamOf, streamsIn, setRow, scanRow, refreshDelims, placeHome, applyRetargets, noteKind, argParent, noteCands, kept, updateBlockRec, ensureRec, syncIncarnations, computeRuns, tableFacts } = ix;
     const ops = engineOps(Y);
     const NO_EDITS = Object.freeze({
         edits: [],
@@ -38,7 +39,7 @@ export const indexFold = (ix) => {
             if (ins === undefined || del === undefined)
                 return (built = null);
             const out = new Map();
-            const visit = (idSet, deleted) => walkIdSetRanges(Y, doc, idSet, (s, from, to) => {
+            const visit = (idSet, deleted) => walkIdSet(Y, doc, idSet, (s, from, to) => {
                 const parent = s.parent;
                 if (s.parentSub !== null || !isNodeLike(parent))
                     return;
@@ -384,7 +385,7 @@ export const indexFold = (ix) => {
         for (const b of ctx.invalidated)
             dirty.add(b);
         if (indexChecks.on)
-            ix.checks.check();
+            checksOf(ix).check();
         if (derived)
             ix.version++;
         if (ix.reporting) {
@@ -449,8 +450,8 @@ export const indexFold = (ix) => {
                 changed.set(s.parent, (subs = new Set()));
             subs.add(s.parentSub);
         };
-        walkIdSetStructs(Y, doc, ins, note);
-        walkIdSetStructs(Y, doc, del, note);
+        walkIdSet(Y, doc, ins, note);
+        walkIdSet(Y, doc, del, note);
         fold(changed, makeEditIndex(ins, del));
         return true;
     };
@@ -473,9 +474,13 @@ export const indexFold = (ix) => {
         tr.insertSet !== undefined &&
         tr.deleteSet !== undefined &&
         lengthOf(tr.insertSet) + lengthOf(tr.deleteSet) !== (cursors.get(tr)?.mark ?? 0));
-    /** The commit: fold `transaction.changed` once (the report publishes from `update`). */
-    const onCommit = (e) => {
-        const tr = e.transaction;
+    /**
+     * The commit of a transaction that changed the registry or a node under
+     * it: fold `transaction.changed` once (the report publishes from `update`).
+     */
+    const onCommit = (tr) => {
+        if (!changedUnder(tr, [registry]))
+            return;
         let [ins, del] = [tr.insertSet, tr.deleteSet];
         // The writes a read folded already moved the rows: only the rest
         // are edits now (the facets fold again, idempotent).

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

@@ -18,16 +18,6 @@ export declare const indexLayout: (ix: IndexState) => {
     cellRank: (row: BlockId, id: BlockId) => string | undefined;
     tableFacts: (b: BlockId, data: unknown) => string;
     declaredItems: () => Set<string>;
-    dissolveVisit: (kids: Map<BlockId | null, ChildSlot[]>, out: Set<BlockId>, ids: readonly BlockId[], layout: boolean, ctx?: {
-        table: BlockId;
-    } | {
-        row: BlockId;
-        columns: Map<string, number> | null;
-        seen: Set<string>;
-    } | null) => {
-        id: BlockId;
-        kids: BlockId[];
-    }[];
     dissolve: (kids: Map<BlockId | null, ChildSlot[]>) => Set<BlockId>;
     redissolve: (changed: Map<BlockId, [BlockId | null | undefined, BlockId | null | undefined]>, kinds: Iterable<BlockId>) => Set<BlockId>;
 };

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

@@ -1,5 +1,5 @@
 import { encodeRank, RANK_VMAX } from '../../placement/rank.js';
-import { unlistedRank } from '../../tables.js';
+import { listedColumns, unlistedRank } from '../../tables.js';
 /** The layout rules of one doc's index, over its state. */
 export const indexLayout = (ix) => {
     const { blocks, kindsOf } = ix;
@@ -46,19 +46,10 @@ export const indexLayout = (ix) => {
         if (data === null || typeof data !== 'object')
             return null;
         let index = columnsMemo.get(data);
-        if (index !== undefined)
-            return index;
-        const columns = data.columns;
-        index = null;
-        if (Array.isArray(columns)) {
-            index = new Map();
-            for (const c of columns) {
-                const id = c?.id;
-                if (typeof id === 'string' && !index.has(id))
-                    index.set(id, index.size);
-            }
+        if (index === undefined) {
+            const ids = listedColumns(data);
+            columnsMemo.set(data, (index = ids && new Map(ids.map((id, i) => [id, i]))));
         }
-        columnsMemo.set(data, index);
         return index;
     };
     /** The column a cell names (`data.column`), if any. */
@@ -75,12 +66,8 @@ export const indexLayout = (ix) => {
         const k = kindsOf.get(b);
         if (data === null || typeof data !== 'object')
             return '';
-        if (k?.table) {
-            const columns = data.columns;
-            return Array.isArray(columns)
-                ? JSON.stringify(columns.map((c) => c?.id ?? null))
-                : '';
-        }
+        if (k?.table)
+            return JSON.stringify(listedColumns(data));
         if (k?.cell) {
             const c = data.column;
             return typeof c === 'string' ? c : '';
@@ -281,7 +268,6 @@ export const indexLayout = (ix) => {
         cellRank,
         tableFacts,
         declaredItems,
-        dissolveVisit,
         dissolve,
         redissolve
     };

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

@@ -4,6 +4,7 @@
  * the maintained facts must re-decide.
  */
 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';
@@ -12,7 +13,7 @@ import { readClaims } from '../model.js';
 import { dropFrom, sameShape, typeAttr } from './shared.js';
 /** The block records of one doc's index. */
 export const indexRecords = (ix) => {
-    const { Y, registry, blocks, shells, attachOf, foreignOf, retargets, reclaim, byArgParent, placementSeeds, stateSeeds, incarnations, noteClaims, effectiveClaims, noteKind, argParent, noteCands } = ix;
+    const { registry, blocks, shells, attachOf, foreignOf, retargets, reclaim, byArgParent, placementSeeds, stateSeeds, incarnations, noteClaims, effectiveClaims, noteKind, argParent, noteCands } = ix;
     // ── records ──────────────────────────────────────────────────────
     /** Fork patch YP14's predicate: the registry values the engine keeps. */
     const kept = engineOps(Y).isKeptReplaced;

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

@@ -5,16 +5,15 @@
 import { cloneJsonSafe, sameIds } from '../../../utils/json.js';
 import { readData } from '../../data.js';
 import { callEach } from '../../protocols/observable.js';
-import { protectItems } from '../model.js';
-import { EMPTY_IDS, dataOf, indexChecks, keyOf } from './shared.js';
+import { EMPTY_IDS, checksOf, dataOf, indexChecks, keyOf } from './shared.js';
 /** The change report of one doc's index. */
 export const indexReporter = (ix) => {
-    const { T, doc, dataRoot, blocks, following, dirtyLists, leftLists, candidates, ownShim, ensurePlacements, typeOf, intern, runs, syncAll } = ix;
+    const { doc, dataRoot, blocks, following, dirtyLists, leftLists, candidates, ensurePlacements, typeOf, runs, syncAll } = ix;
     const docData = () => cloneJsonSafe(readData(dataRoot) ?? {});
     let dataChanged = false;
     // ── projection ───────────────────────────────────────────────────
-    /** `id`'s visible content items, canonical and frozen. */
-    const itemsOf = (id) => protectItems(T.readSegs(ownShim.display(id) ?? []), intern);
+    /** `id`'s visible content items: its runs, as fresh wrappers over their shared payloads. */
+    const itemsOf = (id) => runs(id).map((r) => ({ ...r }));
     const projectBlock = (id) => {
         const rec = blocks.get(id);
         const projected = {
@@ -290,7 +289,7 @@ export const indexReporter = (ix) => {
         leftLists.clear();
         ix.allListsDirty = false;
         if (indexChecks.on)
-            ix.checks.checkPublished(published);
+            checksOf(ix).checkPublished(published);
         const empty = r.added.size + r.removed.size + r.moved.size + r.meta.size + r.content.size + r.order.size;
         return empty === 0 && !r.data ? null : r;
     };

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

@@ -1,6 +1,7 @@
 import type { EngineNode } from '../../engine-api.js';
 import type { BlockId, BlockRec } from '../../placement/model.js';
 import type { ContentRun, DisplayRoles } from '../runs.js';
+import type { SelfChecks } from './state.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.
@@ -48,14 +49,20 @@ export type Cached = {
  */
 export declare const sameShape: (roles: DisplayRoles, a: string, b: string) => boolean;
 /**
- * Test lanes turn this on (`globalThis.__EDYTOR_INDEX_CHECKS__`, set before
- * the index loads): after every fold the index checks each fact it keeps
- * incrementally against a rebuild from the replicated state and throws on
- * the first difference. Off in production.
+ * The index's self-checks, off in production: a test lane's setup installs
+ * `of`, which builds an index's checker (on its first check), and turns them
+ * `on`. After every fold the index checks each fact it keeps incrementally
+ * against a rebuild from the replicated state and throws on the first
+ * difference; after every report, the published tree.
  */
 export declare const indexChecks: {
     on: boolean;
+    of?: (ix: never) => SelfChecks;
 };
+/** `ix`'s checker ({@link indexChecks}), built on its first check. */
+export declare const checksOf: (ix: {
+    checks: SelfChecks | null;
+}) => SelfChecks;
 /** Add `value` to `key`'s set in `index`. */
 export declare const addTo: <K, V>(index: Map<K, Set<V>>, key: K, value: V) => void;
 /** Remove `value` from `key`'s set in `index` (the set goes once empty). */

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

@@ -74,14 +74,15 @@ export const sameShape = (roles, a, b) => {
         cells.has(a) === cells.has(b));
 };
 /**
- * Test lanes turn this on (`globalThis.__EDYTOR_INDEX_CHECKS__`, set before
- * the index loads): after every fold the index checks each fact it keeps
- * incrementally against a rebuild from the replicated state and throws on
- * the first difference. Off in production.
+ * The index's self-checks, off in production: a test lane's setup installs
+ * `of`, which builds an index's checker (on its first check), and turns them
+ * `on`. After every fold the index checks each fact it keeps incrementally
+ * against a rebuild from the replicated state and throws on the first
+ * difference; after every report, the published tree.
  */
-export const indexChecks = {
-    on: globalThis.__EDYTOR_INDEX_CHECKS__ === true
-};
+export const indexChecks = { on: false };
+/** `ix`'s checker ({@link indexChecks}), built on its first check. */
+export const checksOf = (ix) => (ix.checks ??= indexChecks.of(ix));
 /** Add `value` to `key`'s set in `index`. */
 export const addTo = (index, key, value) => {
     let set = index.get(key);

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

@@ -5,10 +5,9 @@
  * indexes, the counters and flags) are read through `ix` at every use.
  * What one part alone keeps stays in that part.
  */
-import type { EngineApi, EngineDoc, EngineTransaction } from '../../engine-api.js';
+import type { EngineDoc, EngineTransaction } from '../../engine-api.js';
 import { type BlockId, type BlockRec, type ChildSlot, type ResolvedPlacement } from '../../placement/model.js';
 import type { IdSetLike } from '../../structs.js';
-import type { TextEngine } from '../model.js';
 import type { LiveRow, RowItem } from '../rows.js';
 import type { ContentRun, DisplayRoles, Folded } from '../runs.js';
 import type { Cached } from './shared.js';
@@ -76,36 +75,7 @@ export type SelfChecks = {
     checkPublished: (pub: Published) => void;
 };
 /** Build the empty state of `doc`'s index. */
-export declare const indexState: (Y: EngineApi, T: TextEngine, doc: EngineDoc) => {
-    Y: Pick<typeof import("../../vendor/yjs/dts/index.js"), import("../../engine.js").EngineSymbol>;
-    T: {
-        newNode: (name: string) => import("../../engine-api.js").EngineNode;
-        resolveAnchor: (doc: EngineDoc, text: import("../../engine-api.js").EngineNode, anchor: import("../model.js").Anchor) => number | null;
-        anchorAt: (text: import("../../engine-api.js").EngineNode, index: number, assoc: number) => import("../model.js").Anchor;
-        openRangeCursor: (text: import("../../engine-api.js").EngineNode) => import("../model.js").RangeCursor;
-        itemsOfRange: (text: import("../../engine-api.js").EngineNode, i0: number, i1: number) => import("../model.js").RangeItem[];
-        readSegs: (segs: readonly import("../model.js").Seg[], stats?: import("../model.js").RangeReadStats) => import("../model.js").RangeItem[];
-        computeOwnership: (doc: EngineDoc, given: ReadonlyMap<import("../model.js").BlockId, import("../model.js").TextBlockRec>) => import("../model.js").Ownership;
-        flatten: (b: import("../model.js").BlockId, blocks: unknown, own: import("../model.js").Ownership) => import("../model.js").Seg[];
-        ownedLength: (segs: readonly import("../model.js").Seg[]) => number;
-        contentItemsOf: (b: import("../model.js").BlockId, blocks: unknown, own: import("../model.js").Ownership) => import("../model.js").RangeItem[];
-        blockTextOf: (b: import("../model.js").BlockId, blocks: unknown, own: import("../model.js").Ownership) => string;
-        insertIntoText: (doc: EngineDoc, blocks: unknown, own: import("../model.js").Ownership, b: import("../model.js").BlockId, offset: number, payload: string | import("../../engine-api.js").EngineNode, marks?: Record<string, unknown>) => void;
-        deleteRange: (doc: EngineDoc, blocks: unknown, own: import("../model.js").Ownership, b: import("../model.js").BlockId, offset: number, length: number) => void;
-        formatRangeIn: (doc: EngineDoc, blocks: unknown, own: import("../model.js").Ownership, b: import("../model.js").BlockId, offset: number, length: number, formats: Record<string, unknown>) => void;
-        purgeStreams: (streams: readonly import("../model.js").Stream[]) => void;
-        findAtom: (own: import("../model.js").Ownership, b: import("../model.js").BlockId, inlineId: string) => {
-            text: import("../../engine-api.js").EngineNode;
-            at: number;
-            node: import("../../engine-api.js").EngineNode;
-        } | null;
-        splitAt: (blocks: ReadonlyMap<import("../model.js").BlockId, import("../model.js").TextBlockRec>, own: import("../model.js").Ownership, b: import("../model.js").BlockId, offset: number, newId: import("../model.js").BlockId, n: number) => import("../model.js").MergeClaim[];
-        claimInto: (blocks: ReadonlyMap<import("../model.js").BlockId, import("../model.js").TextBlockRec>, own: Pick<import("../model.js").Ownership, "streamOf">, from: import("../model.js").BlockId, into: import("../model.js").BlockId) => void;
-        ownText: (doc: EngineDoc, rec: import("../model.js").TextBlockRec) => {
-            from: unknown;
-            to: number;
-        };
-    };
+export declare const indexState: (doc: EngineDoc) => {
     doc: EngineDoc;
     registry: import("../../engine-api.js").EngineNode;
     /** The document's own data (`crdt/data.ts`): outside the registry, reported apart. */
@@ -217,7 +187,7 @@ export declare const indexState: (Y: EngineApi, T: TextEngine, doc: EngineDoc) =
     frames: Set<Folded>;
     candidates: Set<string>;
     reporting: boolean;
-    /** The self-checks, once built (`checks.ts`). */
+    /** The self-checks, once built (`checksOf`). */
     checks: SelfChecks | null;
 };
 export type IndexState = ReturnType<typeof indexState>;

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

@@ -1,13 +1,11 @@
 import { REGISTRY_KEY } from '../../placement/model.js';
 import { DOC_DATA_ROOT } from '../../schema.js';
 /** Build the empty state of `doc`'s index. */
-export const indexState = (Y, T, doc) => {
+export const indexState = (doc) => {
     // The children index starts as the one without the layout rules (no layout yet).
     const kids0 = new Map();
     const slots0 = new Map();
     return {
-        Y,
-        T,
         doc,
         registry: doc.get(REGISTRY_KEY),
         /** The document's own data (`crdt/data.ts`): outside the registry, reported apart. */
@@ -114,7 +112,7 @@ export const indexState = (Y, T, doc) => {
         frames: new Set(),
         candidates: new Set(),
         reporting: false,
-        /** The self-checks, once built (`checks.ts`). */
+        /** The self-checks, once built (`checksOf`). */
         checks: null
     };
 };

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

@@ -29,7 +29,10 @@
  *
  * The item guards are `text/items.ts`, the range reads `text/ranges.ts` and
  * the stream table `text/streams.ts` (re-exported here); this module declares
- * the text model's types and binds its reads and writes to an engine.
+ * the text model's types and its reads and writes, each a function edytor's
+ * modules import (the public binding's `text` lists them, `bindText`). The
+ * from-scratch ownership (`computeOwnership`) is the oracle the index is
+ * checked against: only the public binding and the tests reach it.
  */
 import type { EngineApi, EngineDoc, EngineNode } from '../engine-api.js';
 import { type IdSetOf } from '../structs.js';
@@ -239,7 +242,84 @@ export type Ownership = {
     /** `b`'s effective claims (`merge.claim.anchor`), when the context computed them. */
     claimsOf?: (b: BlockId) => readonly Claim[];
 };
-export declare const bindText: (Y: EngineApi) => {
+/** Construct a detached v14 node, viewed through the structural interface. */
+export declare const newNode: (name: string) => EngineNode;
+/** Anchor → live index in `text`, or `null` when its item is not integrated here. */
+export declare const resolveAnchor: (doc: EngineDoc, text: EngineNode, anchor: Anchor) => number | 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 declare const anchorAt: (text: EngineNode, index: number, assoc: number) => Anchor;
+/** A bounded read cursor on `text` (live-content space). */
+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[];
+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[];
+export declare const contentItemsOf: (b: BlockId, blocks: unknown, own: Ownership) => RangeItem[];
+export declare const blockTextOf: (b: BlockId, blocks: unknown, own: Ownership) => string;
+/**
+ * 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 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. */
+export declare const deleteRange: (doc: EngineDoc, blocks: unknown, own: Ownership, b: BlockId, offset: number, length: number) => void;
+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
+ * 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 declare const purgeStreams: (streams: readonly Stream[]) => void;
+/** The inline atom `inlineId` in `b`'s display: its text, engine index and node. */
+export declare const findAtom: (own: Ownership, b: BlockId, inlineId: string) => {
+    text: EngineNode;
+    at: number;
+    node: EngineNode;
+} | 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 declare const splitAt: (blocks: ReadonlyMap<BlockId, TextBlockRec>, own: Ownership, b: BlockId, offset: number, newId: BlockId, n: number) => MergeClaim[];
+/**
+ * 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 declare const claimInto: (blocks: ReadonlyMap<BlockId, TextBlockRec>, own: Pick<Ownership, "streamOf">, from: BlockId, into: BlockId) => 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
+ * 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 declare const ownText: (doc: EngineDoc, rec: TextBlockRec) => {
+    from: unknown;
+    to: number;
+};
+/**
+ * The text engine as one object (the public binding's `text`): the reads
+ * and writes above. Edytor's own modules import them directly.
+ */
+export declare const bindText: (_Y: EngineApi) => {
     newNode: (name: string) => EngineNode;
     resolveAnchor: (doc: EngineDoc, text: EngineNode, anchor: Anchor) => number | null;
     anchorAt: (text: EngineNode, index: number, assoc: number) => Anchor;