edytor 5.0.0 → 7.0.0

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

@@ -1,197 +0,0 @@
-/**
- * The index's state: every fact the parts of the index share, kept in one
- * object each part reads (`ix`). Containers are created once and mutated in
- * place; the fields a part reassigns (`delim`, `roles`, the children
- * indexes, the counters and flags) are read through `ix` at every use.
- * What one part alone keeps stays in that part.
- */
-import type { EngineDoc, EngineTransaction } from '../../engine-api.js';
-import { type BlockId, type BlockRec, type ChildSlot, type Edge, type ResolvedPlacement, type SlotRef } from '../../placement/model.js';
-import type { IdSetLike } from '../../structs.js';
-import type { LiveRow, RowItem } from '../rows.js';
-import type { ContentRun, DisplayRoles, Folded } from '../runs.js';
-import type { Cached } from './shared.js';
-export type TextEdit = {
-    item: RowItem;
-    len: number;
-    del: boolean;
-};
-export type TextEdits = {
-    edits: TextEdit[];
-    scan: boolean;
-    opaque: boolean;
-};
-/** One fold's effects: invalidated blocks, rescanned texts, rebuilt facets. */
-export type FoldCtx = {
-    invalidated: Set<BlockId>;
-    /** Per home block: its text's edits, whether it rescans, whether every reader re-reads. */
-    texts: Map<BlockId, {
-        edits: TextEdit[];
-        scan: boolean;
-        opaque: boolean;
-        seen: Set<TextEdits>;
-    }>;
-    /** The blocks whose entry or nonce changed: their delimiters are re-decided. */
-    named: Set<BlockId>;
-    table: boolean;
-    /** The winning parents, before and after, of the blocks the fold touched. */
-    parents: Set<BlockId>;
-};
-/** A slot in a children index: its display parent, rank and the island it displays out of. */
-export type Slot = {
-    parent: BlockId | null;
-    rank: string;
-    reset?: BlockId;
-};
-/** Each row's segments at its last placement: segment 0's block, then each cut's key and block. */
-export type Placed = {
-    head: BlockId | null;
-    keys: string[];
-    blocks: (BlockId | null)[];
-};
-/** The tree the change report last published. */
-export type Published = {
-    nodes: Map<BlockId, {
-        parent: BlockId | null;
-        index: number;
-        type: string;
-        data: unknown;
-        runs: readonly ContentRun[];
-        key?: string;
-    }>;
-    order: Map<BlockId | null, readonly BlockId[]>;
-    /** The children index version it was taken at. */
-    kids: number;
-};
-/** A transaction as the fold reads it. */
-export type Tx = {
-    insertSet?: IdSetLike;
-    deleteSet?: IdSetLike;
-    changed?: EngineTransaction['changed'];
-    /** The visibility changes hold records made, in order (fork patch YP20). */
-    holds?: number[];
-    /** The units whose mover changed, in order (fork patch YP22). */
-    moves?: number[];
-};
-/** The index's self-checks (`indexChecks`), run after each fold and each report. */
-export type SelfChecks = {
-    check: () => void;
-    checkPublished: (pub: Published) => void;
-};
-/** Build the empty state of `doc`'s index. */
-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. */
-    dataRoot: import("../../engine-api.js").EngineNode;
-    blocks: Map<string, BlockRec>;
-    /** Withdrawn blocks without a delete mark (`hist.undo.withdraw`), see the fold's `settle`. */
-    shells: Set<string>;
-    /** Forward dependencies of cached runs: backing text (by home) / walked block → consumers. */
-    textConsumers: Map<string, Set<string>>;
-    listConsumers: Map<string, Set<string>>;
-    /** Owner → the blocks it displays (itself included while it owns itself). */
-    displaysMap: Map<string, Set<string>>;
-    /** Blocks whose claims, delete mark or record changed since the last owner pass. */
-    ownerSeeds: Set<string>;
-    /** Blocks whose owner changed since the last placement pass. */
-    ownerChanged: Set<string>;
-    rows: Map<string, LiveRow>;
-    delim: Map<string, string>;
-    /** Each block's segment: its row and the cut that opens it (`null`: the row's segment 0). */
-    streamIx: Map<string, {
-        home: BlockId;
-        cut: string | null;
-    }>;
-    placed: Map<string, Placed>;
-    /** Each row's text → its home (rows are keyed by home). */
-    homeOfText: WeakMap<object, string>;
-    /** Blocks whose claims (implicit, then their stream's claim items) the next pass re-reads. */
-    reclaim: Set<string>;
-    /** The role table the display reads; `null` → none. */
-    roles: DisplayRoles | null;
-    /** A stored kind changed since the last report: derived kinds may follow it. */
-    retyped: boolean;
-    /** The live blocks the layout rules do not display (`layout.*`), per placement build. */
-    dissolved: Set<string>;
-    /** Resolved placements. */
-    placementsMap: Map<string, ResolvedPlacement>;
-    /** Counts the folds that changed a sequence (a slot or record written or removed): a slot map read before one is stale. */
-    seqEpoch: number;
-    /** Every block slot by the id it names (`{ b }`, fork patch YP22), kept from the folds; a block's home is `homeFor`. */
-    slotsByBlock: Map<string, SlotRef[]>;
-    /** Each sequence owner's blocks (every block whose display edge it holds), sorted by key. */
-    rawOrder: Map<string | null, ChildSlot[]>;
-    /** Each block's display edge as accepted, or its strongest when none is (`null`: no slot). */
-    edges: Map<string, Edge | null>;
-    /** The blocks shown below their strongest edge: a cycle dropped a later move, they are back where they stood. */
-    fallen: Set<string>;
-    /** The blocks at the root's tail: every edge closes a cycle, or no slot. */
-    rejected: Set<string>;
-    /** The children index without the layout rules (what they read), and with them. */
-    kids0: Map<string | null, ChildSlot[]>;
-    slots0: Map<string, Slot>;
-    kidsMap: Map<string | null, ChildSlot[]>;
-    /** Each visible block's slot (display parent, rank, the island it displays out of). */
-    slots: Map<string, Slot>;
-    /**
-     * The blocks whose shown kind follows their slot — displayed out of
-     * an island, then in a lined island or of a line kind — which the
-     * report re-reads after a retype.
-     */
-    following: Set<string>;
-    /** Bumps whenever a child list changes (the report compares it). */
-    kidsVersion: number;
-    /** The child lists patched since the last report (`all`: every list was rebuilt). */
-    dirtyLists: Set<string | null>;
-    /** The blocks that left every list since the last report. */
-    leftLists: Set<string>;
-    allListsDirty: boolean;
-    /** The next pass rebuilds everything (first build, roles, an irregular state). */
-    placementFull: boolean;
-    /** Blocks whose slot, record or mover changed; blocks whose display state changed. */
-    placementSeeds: Set<string>;
-    stateSeeds: Set<string>;
-    /**
-     * Per block: whether its kind is a layout, an item, a lines island
-     * (with its line kind), a table, a table's row or a row's cell.
-     */
-    kindsOf: Map<string, {
-        layout: boolean;
-        item: boolean;
-        line?: string;
-        table: boolean;
-        row: boolean;
-        cell: boolean;
-    }>;
-    /** The item kinds the roles declare, and those the document holds. */
-    itemKinds: Set<string>;
-    /** The row kinds of the table kinds the roles declare and the document holds, with their cell kinds. */
-    rowKinds: Map<string, string>;
-    /** The cell kinds of {@link rowKinds}. */
-    cellKinds: Set<string>;
-    /**
-     * The losing incarnations each key shows (`id.same.concurrent`):
-     * blocks of their own under derived ids, claimed by the key's block
-     * before its own claims (`incarnations.ts`).
-     */
-    incarnations: Map<string, string[]>;
-    cache: Map<string, Cached>;
-    dirty: Set<string>;
-    /** The index version (`RunView.version`). */
-    version: number;
-    /** The fold counters `debug` exposes read-only. */
-    foldStats: {
-        folds: number;
-        pairs: number;
-        structs: number;
-        placed: number;
-    };
-    /** Frames tracking the folds (the write funnel's `track()`), and the report's candidates. */
-    frames: Set<Folded>;
-    candidates: Set<string>;
-    reporting: boolean;
-    /** The self-checks, once built (`checksOf`). */
-    checks: SelfChecks | null;
-};
-export type IndexState = ReturnType<typeof indexState>;

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

@@ -1,116 +0,0 @@
-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 = (doc) => {
-    // The children index starts as the one without the layout rules (no layout yet).
-    const kids0 = new Map();
-    const slots0 = new Map();
-    return {
-        doc,
-        registry: doc.get(REGISTRY_KEY),
-        /** The document's own data (`crdt/data.ts`): outside the registry, reported apart. */
-        dataRoot: doc.get(DOC_DATA_ROOT),
-        // ── the replicated-state index
-        blocks: new Map(),
-        /** Withdrawn blocks without a delete mark (`hist.undo.withdraw`), see the fold's `settle`. */
-        shells: new Set(),
-        /** Forward dependencies of cached runs: backing text (by home) / walked block → consumers. */
-        textConsumers: new Map(),
-        listConsumers: new Map(),
-        // ── the claim graph (`claims.ts`)
-        /** Owner → the blocks it displays (itself included while it owns itself). */
-        displaysMap: new Map(),
-        /** Blocks whose claims, delete mark or record changed since the last owner pass. */
-        ownerSeeds: new Set(),
-        /** Blocks whose owner changed since the last placement pass. */
-        ownerChanged: new Set(),
-        // ── the stream table (`streams.ts`)
-        rows: new Map(),
-        delim: new Map(),
-        /** Each block's segment: its row and the cut that opens it (`null`: the row's segment 0). */
-        streamIx: new Map(),
-        placed: new Map(),
-        /** Each row's text → its home (rows are keyed by home). */
-        homeOfText: new WeakMap(),
-        /** Blocks whose claims (implicit, then their stream's claim items) the next pass re-reads. */
-        reclaim: new Set(),
-        // ── roles
-        /** The role table the display reads; `null` → none. */
-        roles: null,
-        /** A stored kind changed since the last report: derived kinds may follow it. */
-        retyped: false,
-        // ── placements and the children index (`placement.ts`, `layout.ts`)
-        /** The live blocks the layout rules do not display (`layout.*`), per placement build. */
-        dissolved: new Set(),
-        /** Resolved placements. */
-        placementsMap: new Map(),
-        /** Counts the folds that changed a sequence (a slot or record written or removed): a slot map read before one is stale. */
-        seqEpoch: 0,
-        /** Every block slot by the id it names (`{ b }`, fork patch YP22), kept from the folds; a block's home is `homeFor`. */
-        slotsByBlock: new Map(),
-        /** Each sequence owner's blocks (every block whose display edge it holds), sorted by key. */
-        rawOrder: new Map(),
-        /** Each block's display edge as accepted, or its strongest when none is (`null`: no slot). */
-        edges: new Map(),
-        /** The blocks shown below their strongest edge: a cycle dropped a later move, they are back where they stood. */
-        fallen: new Set(),
-        /** The blocks at the root's tail: every edge closes a cycle, or no slot. */
-        rejected: new Set(),
-        /** The children index without the layout rules (what they read), and with them. */
-        kids0,
-        slots0,
-        kidsMap: kids0,
-        /** Each visible block's slot (display parent, rank, the island it displays out of). */
-        slots: slots0,
-        /**
-         * The blocks whose shown kind follows their slot — displayed out of
-         * an island, then in a lined island or of a line kind — which the
-         * report re-reads after a retype.
-         */
-        following: new Set(),
-        /** Bumps whenever a child list changes (the report compares it). */
-        kidsVersion: 0,
-        /** The child lists patched since the last report (`all`: every list was rebuilt). */
-        dirtyLists: new Set(),
-        /** The blocks that left every list since the last report. */
-        leftLists: new Set(),
-        allListsDirty: true,
-        /** The next pass rebuilds everything (first build, roles, an irregular state). */
-        placementFull: true,
-        /** Blocks whose slot, record or mover changed; blocks whose display state changed. */
-        placementSeeds: new Set(),
-        stateSeeds: new Set(),
-        /**
-         * Per block: whether its kind is a layout, an item, a lines island
-         * (with its line kind), a table, a table's row or a row's cell.
-         */
-        kindsOf: new Map(),
-        /** The item kinds the roles declare, and those the document holds. */
-        itemKinds: new Set(),
-        /** The row kinds of the table kinds the roles declare and the document holds, with their cell kinds. */
-        rowKinds: new Map(),
-        /** The cell kinds of {@link rowKinds}. */
-        cellKinds: new Set(),
-        // ── records (`records.ts`)
-        /**
-         * The losing incarnations each key shows (`id.same.concurrent`):
-         * blocks of their own under derived ids, claimed by the key's block
-         * before its own claims (`incarnations.ts`).
-         */
-        incarnations: new Map(),
-        // ── the run cache (`cache.ts`)
-        cache: new Map(),
-        dirty: new Set(),
-        /** The index version (`RunView.version`). */
-        version: 0,
-        /** The fold counters `debug` exposes read-only. */
-        foldStats: { folds: 0, pairs: 0, structs: 0, placed: 0 },
-        // ── the fold (`fold.ts`) and the report (`report.ts`)
-        /** Frames tracking the folds (the write funnel's `track()`), and the report's candidates. */
-        frames: new Set(),
-        candidates: new Set(),
-        reporting: false,
-        /** The self-checks, once built (`checksOf`). */
-        checks: null
-    };
-};

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

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

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

@@ -1,248 +0,0 @@
-import { byId, cmpStamp, scanText } from '../model.js';
-import { removedKeys } from '../streams.js';
-import { headOf, placeRow, rowOf, segmentAt, segmentClaims, segmentOfCut, streamOfSegment } from '../rows.js';
-/** The stream table of one doc's index, over its state and claim graph. */
-export const indexStreams = (ix) => {
-    const { registry, blocks, listConsumers, rows, streamIx, placed, homeOfText, reclaim, noteClaims, invalidateBlock } = ix;
-    // ── the stream table ────────────────────────────────────
-    // One maintained row per backing text (keyed by its home block): its
-    // live boundaries and the units between them (`text/rows.ts`), the
-    // delimiting boundary of each block, and each block's segment. An edit
-    // that writes or removes no boundary moves its row by its units
-    // (`shiftGap`); a row is rescanned only when its boundary set (or its
-    // text) changed, and only the delimiters of the blocks its boundaries
-    // name are re-decided, so only the rows those delimiters cut re-place.
-    /** Every live boundary naming a block, by block: key → its row and nonce. */
-    const boundsBy = new Map();
-    const streamOf = (b) => {
-        const at = streamIx.get(b);
-        const row = at && rows.get(at.home);
-        if (row === undefined)
-            return undefined;
-        const k = segmentOfCut(row, at.cut);
-        return k < 0 ? undefined : streamOfSegment(row, k, b);
-    };
-    const streamsIn = (home) => {
-        const row = rows.get(home);
-        const out = [];
-        for (let k = 0; row !== undefined && k <= row.cuts.length; k++) {
-            const b = headOf(row, k);
-            if (b !== null)
-                out.push(streamOfSegment(row, k, b));
-        }
-        return out;
-    };
-    const streamAt = (home, i) => {
-        const row = rows.get(home);
-        if (row === undefined)
-            return undefined;
-        const k = segmentAt(row, i);
-        const b = headOf(row, k);
-        if (b === null)
-            return undefined;
-        const st = streamOfSegment(row, k, b);
-        return st.start <= i && i <= st.end ? st : undefined;
-    };
-    /** Record `home`'s new row (or none); the blocks its boundary set change names join `named`. */
-    const setRow = (home, row, named) => {
-        const old = rows.get(home);
-        if (row === undefined)
-            rows.delete(home);
-        else {
-            rows.set(home, row);
-            homeOfText.set(row.text, home);
-        }
-        if (old?.key === row?.key)
-            return;
-        for (const b of old?.bounds ?? []) {
-            if (b.m !== undefined || row?.keyIndex.has(b.key))
-                continue;
-            const by = boundsBy.get(b.s);
-            // A text can change homes (a key's node becomes a losing incarnation,
-            // `id.same.concurrent`): drop the entry only while it is still this row's.
-            if (by?.get(b.key)?.home === home)
-                by.delete(b.key);
-            if (by?.size === 0)
-                boundsBy.delete(b.s);
-            named.add(b.s);
-        }
-        for (const b of row?.bounds ?? []) {
-            if (b.m !== undefined || old?.keyIndex.has(b.key))
-                continue;
-            let by = boundsBy.get(b.s);
-            if (by === undefined)
-                boundsBy.set(b.s, (by = new Map()));
-            by.set(b.key, { home, n: b.n });
-            named.add(b.s);
-        }
-    };
-    /** A fresh row of `home`'s text (none without one). */
-    const scanRow = (home) => {
-        const text = blocks.get(home)?.content;
-        return text === undefined ? undefined : rowOf(scanText(home, text));
-    };
-    /** A removed block's key (`room.purge.what`): its boundary delimits nobody's stretch. */
-    const removed = removedKeys(registry);
-    /** A cut's stretch is nobody's when it names no block (a removed one). */
-    const nobody = (s) => !blocks.has(s);
-    /** Re-decide the delimiting boundary of each block in `named`; the rows a change cuts join `homes`. */
-    const refreshDelims = (named, homes) => {
-        for (const s of named) {
-            const rec = blocks.get(s);
-            const gone = rec === undefined && removed(s);
-            let best;
-            if (rec !== undefined || gone)
-                for (const [key, b] of boundsBy.get(s) ?? [])
-                    if ((gone || b.n === rec.n) && (best === undefined || byId(key, best) < 0))
-                        best = key;
-            const old = ix.delim.get(s);
-            if (old === best) {
-                // The cut stays, and the block it opens may have come or gone (removed).
-                if (best !== undefined)
-                    homes.add(boundsBy.get(s).get(best).home);
-                continue;
-            }
-            if (best === undefined)
-                ix.delim.delete(s);
-            else
-                ix.delim.set(s, best);
-            const was = old === undefined ? undefined : boundsBy.get(s)?.get(old)?.home;
-            if (was !== undefined)
-                homes.add(was);
-            if (best !== undefined)
-                homes.add(boundsBy.get(s).get(best).home);
-            if (rows.has(s) || placed.has(s))
-                homes.add(s);
-        }
-    };
-    /**
-     * Place `home`'s row; invalidate the blocks whose segment changed (or
-     * appeared, or went). A segment is its two delimiting cuts, so only the
-     * segments between the longest common prefix and suffix of the old and
-     * new cut lists can differ: the others keep their entries untouched.
-     */
-    const placeHome = (home, invalidated) => {
-        const row = rows.get(home);
-        const before = placed.get(home) ?? { head: null, keys: [], blocks: [] };
-        const now = { head: null, keys: [], blocks: [] };
-        if (row !== undefined) {
-            placeRow(row, ix.delim, nobody);
-            now.head = row.head;
-            row.cuts.forEach((j, k) => {
-                now.keys.push(row.bounds[j].key);
-                now.blocks.push(row.heads[k]);
-            });
-        }
-        if (row === undefined)
-            placed.delete(home);
-        else
-            placed.set(home, now);
-        // Its segments' claim items may have changed, or gone to other blocks.
-        for (const x of [before, now]) {
-            if (x.head !== null)
-                reclaim.add(x.head);
-            for (const b of x.blocks)
-                if (b !== null)
-                    reclaim.add(b);
-        }
-        const [a, b] = [before.keys, now.keys];
-        // A cut is the same when its boundary and the block it opens are (a
-        // removed block's cut opens nobody's stretch).
-        const same = (i, j) => a[i] === b[j] && before.blocks[i] === now.blocks[j];
-        let p = 0;
-        while (p < a.length && p < b.length && same(p, p))
-            p++;
-        let q = 0;
-        while (q < a.length - p && q < b.length - p && same(a.length - 1 - q, b.length - 1 - q))
-            q++;
-        // Segment k ends at cut k: it changed iff k lies in [p, n - q] (segment 0 also with its block).
-        const from = before.head === now.head ? p : 0;
-        const changed = (blk) => {
-            if (blk === null)
-                return;
-            invalidated.add(blk);
-            for (const c of listConsumers.get(blk) ?? [])
-                invalidated.add(c);
-        };
-        const blockOf = (x, k) => (k === 0 ? x.head : x.blocks[k - 1]);
-        for (let k = from; k <= a.length - q; k++) {
-            const blk = blockOf(before, k);
-            if (blk !== null && streamIx.get(blk)?.home === home)
-                streamIx.delete(blk);
-            changed(blk);
-        }
-        for (let k = from; k <= b.length - q; k++) {
-            const blk = blockOf(now, k);
-            if (blk === null)
-                continue;
-            streamIx.set(blk, { home, cut: k === 0 ? null : b[k - 1] });
-            changed(blk);
-        }
-    };
-    /** Rebuild the delimiters and every row's segments (the first build). */
-    const rebuildTable = (invalidated) => {
-        boundsBy.clear();
-        for (const [home, row] of rows)
-            for (const b of row.bounds) {
-                if (b.m !== undefined)
-                    continue;
-                let by = boundsBy.get(b.s);
-                if (by === undefined)
-                    boundsBy.set(b.s, (by = new Map()));
-                by.set(b.key, { home, n: b.n });
-            }
-        ix.delim = new Map();
-        const homes = new Set([...rows.keys(), ...placed.keys()]);
-        refreshDelims(boundsBy.keys(), homes);
-        for (const home of homes)
-            placeHome(home, invalidated);
-    };
-    // ── claims ──────────────────────────────────────────────
-    // A block's claims are its implicit ones (`id.same.concurrent`), then
-    // the claim items of its segment, in text order (fork patch YP21:
-    // YATA placed each one, so a split its writer did not see leaves it in
-    // the piece that ends its holder's region, `merge.claim.anchor`). They
-    // change with the record (its implicit claims) and with its row's bounds
-    // or cuts: re-read after each fold's texts for the blocks queued.
-    const sameClaims = (x, y) => x.length === y.length &&
-        x.every((c, i) => c.m === y[i].m && cmpStamp(c.stamp, y[i].stamp) === 0);
-    /** `b`'s claims now: its implicit ones, then its segment's claim items. */
-    const claimsOf = (b) => {
-        const at = streamIx.get(b);
-        const row = at && rows.get(at.home);
-        const k = row === undefined ? -1 : segmentOfCut(row, at.cut);
-        const items = k < 0 ? [] : segmentClaims(row, k);
-        const implicit = blocks.get(b)?.implicit ?? [];
-        return implicit.length === 0 ? items : [...implicit, ...items];
-    };
-    /** Re-read the claims of the blocks queued; a change is a structural change of the block. */
-    const applyReclaims = (ctx) => {
-        for (const b of reclaim) {
-            const rec = blocks.get(b);
-            if (rec === undefined)
-                continue;
-            const before = rec.claims;
-            const after = claimsOf(b);
-            if (sameClaims(before, after))
-                continue;
-            rec.claims = after;
-            noteClaims(b, before, after);
-            if (ctx !== null)
-                invalidateBlock(b, ctx, before);
-        }
-        reclaim.clear();
-    };
-    return {
-        streamOf,
-        streamsIn,
-        streamAt,
-        setRow,
-        scanRow,
-        refreshDelims,
-        placeHome,
-        rebuildTable,
-        sameClaims,
-        claimsOf,
-        applyReclaims
-    };
-};