edytor 1.0.0-rc.3 → 2.0.0

package/dist/crdt/tables.d.ts

@@ -13,6 +13,15 @@ import type { JSONBlock, JSONText } from '../utils/json.js';
  * the same.
  */
 export declare const unlistedRank: (column: string) => number;
+/**
+ * The column each entry of a table's `data.columns` names (`null`: none),
+ * or `null` when the table lists no columns: its cells then show in their
+ * own order (`table.columns`). A column is its first entry
+ * ({@link listedColumns}).
+ */
+export declare const columnIds: (data: unknown) => (string | null)[] | null;
+/** The columns a table lists, in order, each once ({@link columnIds}); `null` when none. */
+export declare const listedColumns: (data: unknown) => string[] | null;
 /** The unlisted columns `ids` in their shown order ({@link unlistedRank}). */
 export declare const unlistedOrder: (ids: Iterable<string>) => string[];
 /** What {@link tableBlock} builds. */

package/dist/crdt/tables.js

@@ -7,6 +7,26 @@ import { hash32 } from './rand.js';
  * the same.
  */
 export const unlistedRank = (column) => hash32(column);
+/**
+ * The column each entry of a table's `data.columns` names (`null`: none),
+ * or `null` when the table lists no columns: its cells then show in their
+ * own order (`table.columns`). A column is its first entry
+ * ({@link listedColumns}).
+ */
+export const columnIds = (data) => {
+    const columns = data?.columns;
+    return Array.isArray(columns)
+        ? columns.map((c) => {
+            const id = c?.id;
+            return typeof id === 'string' ? id : null;
+        })
+        : null;
+};
+/** The columns a table lists, in order, each once ({@link columnIds}); `null` when none. */
+export const listedColumns = (data) => {
+    const ids = columnIds(data);
+    return ids && [...new Set(ids)].filter((id) => id !== null);
+};
 /** The unlisted columns `ids` in their shown order ({@link unlistedRank}). */
 export const unlistedOrder = (ids) => [...new Set(ids)].sort((a, b) => unlistedRank(a) - unlistedRank(b) || (a < b ? -1 : a > b ? 1 : 0));
 /**

package/dist/crdt/text/delete-index.d.ts

@@ -108,20 +108,7 @@ export declare const deleteIndex: (Y: EngineApi) => {
     liveRoots: (s: State, m: Member) => Span[];
     shown: (s: State, roots: readonly Span[]) => Span[];
     indexOf: (s: State, c: number, k: number) => number;
-    order: (s: State, a: {
-        c: number;
-        k: number;
-    }, b: {
-        c: number;
-        k: number;
-    }) => number;
     leaves: (s: State, r: Span) => Member[];
-    alive: (s: State, r: Rec) => boolean;
-    heldOf: (s: State, c: number) => {
-        k: number;
-        n: number;
-        mark: Rec;
-    }[];
     holders: (s: State, r: Span, skip?: (mark: Rec) => boolean) => Rec[];
     minus: (r: Span, done: readonly Span[]) => Span[];
     parts: (s: State, r: Span) => Span[];

package/dist/crdt/text/delete-index.js

@@ -6,7 +6,7 @@
  */
 import * as decoding from 'lib0-v14/decoding';
 import * as encoding from 'lib0-v14/encoding';
-import { asYDoc, clientsOf, collectable, collectNow, collects, engineOps, structAt, walkIdSetStructs } from '../structs.js';
+import { asYDoc, clientsOf, collectable, collectNow, collects, engineOps, structAt, walkIdSet } from '../structs.js';
 export const overlaps = (a, b) => a.k < b.k + b.n && b.k < a.k + a.n;
 export const push = (map, key, v) => {
     const list = map.get(key);
@@ -96,12 +96,8 @@ export const deleteIndex = (Y) => {
     /** The live parts of member `m`, in root coordinates. */
     const liveRoots = (s, m) => {
         const out = [];
-        walkIdSetStructs(Y, s.doc, idSet([m]), (st) => {
-            if (st.deleted)
-                return;
-            const lo = Math.max(m.k, st.id.clock);
-            const hi = Math.min(m.k + m.n, st.id.clock + st.length);
-            if (hi > lo)
+        walkIdSet(Y, s.doc, idSet([m]), (st, lo, hi) => {
+            if (!st.deleted && hi > lo)
                 out.push({ c: m.c, k: m.rk + lo - m.k, n: hi - lo });
         });
         return out;
@@ -109,7 +105,7 @@ export const deleteIndex = (Y) => {
     /** The live ids showing root spans `roots`. */
     const shown = (s, roots) => roots.flatMap((r) => members(s, r).flatMap((m) => liveRoots(s, m).map((p) => clip(m, p.k, p.k + p.n))));
     /** The live index of id `c:k` in its text (YATA order: the same on every replica). */
-    const indexOf = (s, c, k) => Y.createAbsolutePositionFromRelativePosition(Y.createRelativePositionFromJSON({ item: { client: c, clock: k }, assoc: 0 }), asYDoc(s.doc), false)?.index ?? Infinity;
+    const indexOf = (s, c, k) => Y.indexOfId(asYDoc(s.doc), Y.createID(c, k))?.index ?? Infinity;
     /**
      * List order of ids `a` and `b` of one text (negative: `a` first): their
      * live indices, and where no live unit separates them, the walk from one
@@ -287,7 +283,7 @@ export const deleteIndex = (Y) => {
         if (!tr.changed.has(s.marks) && !tr.changed.has(s.restored))
             return fresh;
         const inserted = [];
-        walkIdSetStructs(Y, s.doc, tr.insertSet, (st) => {
+        walkIdSet(Y, s.doc, tr.insertSet, (st) => {
             if (st.parent === s.restored || st.parent === s.marks)
                 inserted.push(st);
         });
@@ -301,7 +297,7 @@ export const deleteIndex = (Y) => {
                     if (indexMark(s, r, bytes))
                         fresh.marks.push(r);
         const dropped = [];
-        walkIdSetStructs(Y, s.doc, tr.deleteSet, (st) => {
+        walkIdSet(Y, s.doc, tr.deleteSet, (st) => {
             if (st.parent === s.marks)
                 for (const [r] of recordsIn(st, tr.deleteSet))
                     dropped.push(r);
@@ -333,7 +329,7 @@ export const deleteIndex = (Y) => {
     const collect = (s, tr, copies) => {
         if (!collects(s.doc) || copies.length === 0)
             return;
-        walkIdSetStructs(Y, s.doc, idSet(copies), (st) => {
+        walkIdSet(Y, s.doc, idSet(copies), (st) => {
             const it = st;
             const inside = copies.some((e) => e.c === it.id.client && e.k <= it.id.clock && it.id.clock + it.length <= e.k + e.n);
             if (inside &&
@@ -352,10 +348,7 @@ export const deleteIndex = (Y) => {
         liveRoots,
         shown,
         indexOf,
-        order,
         leaves,
-        alive,
-        heldOf,
         holders,
         minus,
         parts,

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

@@ -1,7 +1,7 @@
 /**
- * Per-writer text delete marks — the block delete marks' rule applied to text (fork patch YP11).
+ * Per-writer text delete marks — the block delete marks' rule applied to text.
  *
- * Deleting text tombstones its engine items, and the engine's undo brings
+ * Deleting text tombstones its engine items, and an undo brings
  * text back as COPIES (new items). The engine records no writer for a
  * delete, so two writers who deleted the same character concurrently could
  * not tell each other's delete from their own: one undo brought it back
@@ -21,8 +21,8 @@
  * text keeps its order whoever restores it. Every decision is made by the
  * replica whose fact it is, never on another replica's stale state:
  *
- * - restoring (the undoing history): the engine hands every text unit of a
- *   popped step to `restoreFilter`, which withholds it, and `onApply`
+ * - restoring (the undoing history): the history hands every text unit of a
+ *   replayed step to `restoreFilter`, which withholds it, and `onApply`
  *   restores each character of the step no other live mark holds and no
  *   copy shows, once. A character another mark holds stays PENDING on that
  *   history, which restores it once no mark holds it and no copy shows (two
@@ -48,6 +48,7 @@
  * writes the marks, restores, holds and deduplicates.
  */
 import type { EngineApi, EngineDoc, EngineNode, YUndoManager } from '../engine-api.js';
+import { type State, type Step, type Tr } from './delete-index.js';
 /** Engine ids `c:k … c:k+n-1`. */
 export type Span = {
     c: number;
@@ -62,24 +63,10 @@ export declare const bindDeletes: (Y: EngineApi) => {
      * transaction) as this writer's, and hide their other visible copies.
      */
     markDeleted: (doc: EngineDoc, deleted: readonly Span[]) => void;
-    /**
-     * 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: EngineDoc, spans: readonly Span[], old: (client: number, clock: number) => boolean) => boolean;
-    /**
-     * 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: EngineDoc, old: (client: number, clock: number) => boolean) => {
-        marks: number;
-        records: number;
-    };
-    /** 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: (doc: EngineDoc) => State;
+    remove: (tr: Tr, live: readonly Span[], into?: Step, keep?: boolean) => void;
+    /** The restore and apply rules of a history on `doc` (`doc/history.ts`). */
     history: (doc: EngineDoc, um: () => YUndoManager) => {
         /** Text units are restored by `onApply`, character by character. */
         restoreFilter: (item: unknown) => boolean;

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);