edytor 3.0.0 → 4.0.0

package/dist/crdt/placement/rank.js

@@ -1,332 +0,0 @@
-/**
- * Rank keys for the placement model — a Logoot-style dense ordering.
- *
- * A rank is a non-empty sequence of *segments* `(v, t)`:
- *
- * - `v` — a signed digit in `[VMIN, VMAX]` (±2^40). There is always room
- *   between two distinct digits (`rv - lv > 1`); when there is not, the
- *   generator descends one level instead of renumbering.
- * - `t` — the allocator's `doc.clientID` (uint53), the *tiebreak* that makes
- *   concurrent allocations of the same digit path distinct, or none
- *   (`Infinity`: sorts above every client) on a segment that only leads to
- *   deeper ones. The last segment always carries one (schema
- *   generation 5): a rank's own client sits on its last segment, and a
- *   copied segment keeps its tie only where the order needs it (between two
- *   keys that differ only by their ties).
- *
- * Encoding is variable-length and order-preserving, so the persisted rank
- * is a plain string and the comparator is `a < b` (CRDT study 2026-10;
- * up to generation 4 every segment was 16 characters, 9 of them a tie):
- *
- * - `v` → a length character (`'H'` for zero, `'H' + k` for a positive
- *   digit of `k` base-64 places, `'H' - k` for a negative one, its places
- *   complemented) and its places — small digits are short;
- * - a tie → `'!'`, then `t` as a digit (`'!'` sorts below every length
- *   character, so a tied segment sorts before the same digit leading on);
- * - rank = segments concatenated; a prefix sorts before its extension, as
- *   string `<` does.
- *
- * Allocation (`rankBetween(left, right, clientId)`):
- *
- * - gap at level `i` (`rv - lv > 1`): emit `lv + 1 + floor(rand·(rv-lv-1))`,
- *   own tie — random-in-gap keeps sequential inserts shallow and concurrent
- *   same-gap inserts deterministic-distinct.
- * - adjacent or equal digits (`rv - lv ≤ 1`): the left digit or the right
- *   one with the allocator's own tie when that tie sorts between theirs;
- *   else copy the left segment and descend — untied when that already sorts
- *   below the right bound (the result is then above left and below right,
- *   and the next level is free), tied otherwise.
- * - left exhausted/open: emit `rSeg.v - 1` (boundary-minus). Sequential
- *   prepends stay at depth 1; the bound can only underflow after ~2^40
- *   consecutive boundary pushes — documented unreachable, guarded by a
- *   descriptive throw.
- *
- * No floating point, no global renumbering, no wall clocks.
- */
-/**
- * Order-preserving alphabet: charCode order equals numeric order.
- * `-`(45) < `0-9`(48-57) < `A-Z`(65-90) < `_`(95) < `a-z`(97-122) — 64 chars,
- * strictly ascending charCodes, all safe inside a plain JSON string.
- */
-const ALPHABET = '-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz';
-const BASE = 64;
-/** Digit range. VMIN = -2^40, VMAX = 2^40 - 1. */
-export const RANK_VMIN = -(2 ** 40);
-export const RANK_VMAX = 2 ** 40 - 1;
-/** The length character of zero; a digit of `k` places is `ZERO ± k`. */
-const ZERO = 'H'.charCodeAt(0);
-/** Most places a digit or a tie takes (uint53 → 9 base-64 places). */
-const MAX_PLACES = 9;
-/** Marks a segment's tie: below every length character. */
-const TIE = '!';
-/** Thrown when rank generation would need a digit below VMIN (unreachable). */
-export class RankSpaceExhausted extends Error {
-    constructor() {
-        super('rank space exhausted at digit minimum — requires ~2^40 sequential boundary inserts; unreachable in practice');
-        this.name = 'RankSpaceExhausted';
-    }
-}
-/** A rank this module cannot encode, a malformed rank, or bounds out of order (a caller's error). */
-const bad = (what) => {
-    throw new Error(`rank: ${what}`);
-};
-/** `n` (≥ 0) as exactly `width` base-64 places. */
-const places = (n, width) => {
-    let out = '';
-    for (let i = 0; i < width; i++) {
-        out = ALPHABET[n % BASE] + out;
-        n = Math.floor(n / BASE);
-    }
-    if (n > 0)
-        bad('overflow');
-    return out;
-};
-/** How many base-64 places `m` (≥ 1) takes. */
-const width = (m) => {
-    let k = 1;
-    for (let x = Math.floor(m / BASE); x > 0; x = Math.floor(x / BASE))
-        k++;
-    return k;
-};
-/** A signed integer as a self-delimiting, order-preserving string. */
-const encInt = (v) => {
-    if (!Number.isSafeInteger(v))
-        bad('digit');
-    if (v === 0)
-        return 'H';
-    const m = Math.abs(v);
-    const k = width(m);
-    if (k > MAX_PLACES)
-        bad('overflow');
-    if (v > 0)
-        return String.fromCharCode(ZERO + k) + places(m, k);
-    // Complemented: a greater magnitude sorts first.
-    return String.fromCharCode(ZERO - k) + places(BASE ** k - 1 - m, k);
-};
-/** The integer at `s[i]`, and where it ends. */
-const decInt = (s, i) => {
-    const k = s.charCodeAt(i) - ZERO;
-    const n = Math.abs(k);
-    if (Number.isNaN(k) || n > MAX_PLACES || i + 1 + n > s.length)
-        bad('malformed');
-    let x = 0;
-    for (let j = i + 1; j <= i + n; j++) {
-        const d = ALPHABET.indexOf(s[j]);
-        if (d < 0)
-            bad('malformed');
-        x = x * BASE + d;
-    }
-    const v = k === 0 ? 0 : k > 0 ? x : -(BASE ** n - 1 - x);
-    return [v, i + 1 + n];
-};
-/** Decode a rank string into its segment array (`t: Infinity` where a segment has no tie). */
-export const decodeRank = (rank) => {
-    if (rank.length === 0)
-        bad('malformed');
-    const segs = [];
-    for (let i = 0; i < rank.length;) {
-        const [v, j] = decInt(rank, i);
-        let t = Infinity;
-        i = j;
-        if (rank[i] === TIE)
-            [t, i] = decInt(rank, i + 1);
-        segs.push({ v, t });
-    }
-    if (segs[segs.length - 1].t === Infinity)
-        bad('malformed');
-    return segs;
-};
-/** Encode segments back to the persisted string form. */
-export const encodeRank = (segs) => {
-    let out = '';
-    for (const { v, t } of segs) {
-        if (v < RANK_VMIN || v > RANK_VMAX)
-            bad('overflow');
-        out += encInt(v);
-        if (t !== Infinity)
-            out += TIE + encInt(t);
-    }
-    return out;
-};
-const tieCmp = (a, b) => (a === b ? 0 : a < b ? -1 : 1);
-const segCmp = (a, b) => a.v - b.v || tieCmp(a.t, b.t);
-/**
- * Window for open-end (append-at-tail) allocation: emit at most `lv + APPEND_WINDOW`
- * rather than anywhere in `(lv, VMAX]`. Sequential appends advance the tail
- * digit by ≤2^16, so the digit space only saturates after ~2^24 tail-appends;
- * a uniform-in-`(lv, VMAX]` pick would instead halve the headroom every step
- * and cascade into ever-deeper levels after ~40 appends. Concurrent tail
- * inserts may collide on `v` — the `t` tiebreak orders them.
- */
-const APPEND_WINDOW = 2 ** 16;
-/**
- * Allocate a rank strictly between `left` and `right` (either may be
- * `undefined` for the open end of a sibling list). `clientId` is the
- * allocating doc's clientID; `rand` supplies the in-gap pick (defaults to
- * `Math.random`, tests inject a seeded stream).
- *
- * Guaranteed: `left < result < right` for any `left < right`, including
- * equal-prefix/concurrent-collision inputs — the tiebreak dimension makes a
- * strictly-between key always exist (modulo the documented VMIN bound).
- */
-export const rankBetween = (left, right, clientId, rand = Math.random, compact = true) => {
-    const L = left === undefined ? [] : decodeRank(left);
-    const R = right === undefined ? [] : decodeRank(right);
-    if (left !== undefined && right !== undefined && left >= right)
-        bad('left >= right');
-    const rightOpen = right === undefined;
-    const path = [];
-    // `locked`: the emitted prefix already sorts below the right bound.
-    let locked = false;
-    // `above`: the emitted prefix already sorts above the left bound.
-    let above = false;
-    // `floor` = right segments at the digit minimum were copied past the left
-    // bound's end (a promoted slot's separator): the result equals right so far.
-    let floor = false;
-    const own = (v) => encodeRank([...path, { v, t: clientId }]);
-    for (let i = 0;; i++) {
-        const lSeg = above ? undefined : L[i];
-        // Locked: the right bound no longer constrains any deeper level
-        // (descending past it grew ranks linearly under concentrated edits).
-        const rSeg = rightOpen || locked ? undefined : R[i];
-        if (lSeg === undefined) {
-            // Left bound exhausted (or passed): extending the prefix keeps the
-            // result above it. Only the right bound constrains the digit.
-            if (rSeg === undefined) {
-                if (floor)
-                    throw new RankSpaceExhausted();
-                return own(0);
-            }
-            if (rSeg.v <= RANK_VMIN) {
-                // No digit below: copy it and descend — below a promoted block
-                // (`slot + separator + rank`) there is room under its own rank.
-                floor = true;
-                path.push(rSeg);
-                continue;
-            }
-            return own(rSeg.v - 1);
-        }
-        if (rSeg === undefined) {
-            // Right bound ended while left continues: valid only when `locked`
-            // already holds (an earlier copied segment was < the right's). If not,
-            // right is a proper prefix of left — i.e. right < left, caller error.
-            if (!rightOpen && !locked)
-                bad('left >= right');
-            // No right bound at this level (open, or `locked` below it): emit
-            // within the bounded append window — dense growth, and one more
-            // level per exhausted gap, not one per insert (SW12-crdt-2).
-            const span = Math.min(APPEND_WINDOW, RANK_VMAX - lSeg.v);
-            if (span <= 0) {
-                path.push(lSeg); // digit space exhausted at this level — descend
-                continue;
-            }
-            return own(lSeg.v + 1 + Math.floor(rand() * span));
-        }
-        if (rSeg.v - lSeg.v > 1) {
-            // Gap at this level: any v in (lv, rv) is > left and < right.
-            return own(lSeg.v + 1 + Math.floor(rand() * (rSeg.v - lSeg.v - 1)));
-        }
-        // rv - lv ≤ 1. Compact: the left digit with our tie, or the right
-        // one, when it sorts between; else the left digit untied when that
-        // already sorts below the right bound. A run's member (`rankAfter`) is
-        // never compact: a peer's rank of the same digit and another tie would
-        // sort between two of its members.
-        const mineL = { v: lSeg.v, t: clientId };
-        if (compact && segCmp(lSeg, mineL) < 0 && segCmp(mineL, rSeg) < 0)
-            return own(lSeg.v);
-        const mineR = { v: rSeg.v, t: clientId };
-        if (compact && rSeg.v > lSeg.v && segCmp(mineR, rSeg) < 0)
-            return own(rSeg.v);
-        // Copy the left digit and descend: untied when compact and that
-        // already sorts below the right bound (then above the left one too,
-        // unless its segment was untied as well), else with its tie.
-        const bare = { v: lSeg.v, t: Infinity };
-        if (compact && segCmp(bare, rSeg) < 0) {
-            path.push(bare);
-            locked = true;
-            if (lSeg.t !== Infinity)
-                above = true;
-            continue;
-        }
-        const c = segCmp(lSeg, rSeg);
-        if (c < 0)
-            locked = true;
-        else if (c > 0 && !locked) {
-            // Never locked and left's segment exceeds right's at the first
-            // differing level → left > right (invalid bounds — caller error).
-            bad('left >= right');
-        }
-        path.push(lSeg);
-    }
-};
-/** The base of the run band: a run member's digit lies just above it. */
-export const RANK_RUN = -(2 ** 30);
-/**
- * A run member's digit lies in `(RANK_RUN, RANK_RUN + RUN_BAND)`: below every
- * digit a plain rank extends a prefix with (`0`, an append's), far above the
- * digit minimum. A run opens at {@link RUN_START}, the middle of the band, so
- * its members can be inserted before and after one another.
- */
-const RUN_BAND = 2 ** 29;
-const RUN_START = RANK_RUN + 2 ** 28;
-const inRun = (v) => v > RANK_RUN && v < RANK_RUN + RUN_BAND;
-/**
- * A rank in `(left, right)` for an insert right after `left` — one rule for
- * array items (`crdt/data.ts`) and inserted blocks (`order.insert.run`).
- * When `client` made `left`, the rank is in the client's run after it: `left`
- * itself as the prefix, then one segment of the run band — or, when `left`
- * is already a member of the client's run, that run's prefix and a member
- * between `left` and the next one. So what one client inserts after its own
- * items stays together whatever a peer inserts in that gap meanwhile: a
- * peer's rank there is either no extension of the run's prefix (it sorts
- * after the whole run) or one whose next digit is above the band (YATA's
- * origin rule, as `Y.Array` keeps an insert after its origin). Elsewhere, or
- * when the run rank would not sort below `right`, a plain {@link rankBetween}.
- */
-export const rankAfter = (left, right, client, rand = Math.random) => {
-    const plain = () => rankBetween(left, right, client, rand);
-    if (left === undefined)
-        return plain();
-    const segs = decodeRank(left);
-    const last = segs.at(-1);
-    const bottom = encodeRank([{ v: RANK_RUN, t: 0 }]);
-    const top = encodeRank([{ v: RANK_RUN + RUN_BAND, t: 0 }]);
-    /**
-     * `prefix` and a rank after `after` (`undefined`: the run opens) in the
-     * run, inside the band. Opening, it takes the band's middle, or a digit
-     * below the run's first member; at the run's end it appends as an open
-     * end does (a window, not half the band); else between the two.
-     */
-    const own = (prefix, after) => {
-        const tail = (r) => r && r.length > prefix.length && r.startsWith(prefix) ? r.slice(prefix.length) : undefined;
-        let next = tail(right);
-        if (next !== undefined && next > top)
-            next = undefined;
-        let mine;
-        if (after === undefined) {
-            if (next === undefined)
-                mine = encodeRank([{ v: RUN_START, t: client }]);
-            else if (next > bottom)
-                mine = rankBetween(bottom, next, client, rand, false);
-            else
-                return plain();
-        }
-        else if (next === undefined) {
-            const append = rankBetween(after, undefined, client, rand, false);
-            mine = append < top ? append : rankBetween(after, top, client, rand, false);
-        }
-        else
-            mine = rankBetween(after, next, client, rand, false);
-        const rank = prefix + mine;
-        return right === undefined || rank < right ? rank : plain();
-    };
-    // A member of the client's run: the next member, inside the band.
-    if (last.t === client && inRun(last.v))
-        return own(encodeRank(segs.slice(0, -1)), encodeRank([last]));
-    // A rank the client made: its run opens right after it. The prefix keeps
-    // `left`'s tie: a peer's rank of the same digit and a greater tie
-    // then sorts after the whole run, never between `left` and it.
-    if (last.t === client)
-        return own(left, undefined);
-    return plain();
-};

package/dist/crdt/placement/source.d.ts

@@ -1,43 +0,0 @@
-/**
- * The rank of a block promoted into the slot ranked `slot` (read-time
- * promotion, and a promote-delete's planned moves): a valid rank, so an
- * insert beside a promoted block ranks against it like any other.
- */
-export declare const promotedRank: (slot: string, rank: string) => string;
-/**
- * Which side of a gap `(X, Y)` a block ranked by its source comes from
- * ({@link sourceRank}), in the order every serial run puts them: the
- * pieces a split of `X` creates, then the blocks leaving `X` for the gap
- * right after it (its children, a list's last items), then the blocks
- * leaving `Y` for the gap right before it (a list's first items).
- */
-export declare const SOURCE_SIDE: {
-    readonly pieces: 0;
-    readonly after: 1;
-    readonly before: 2;
-};
-/**
- * The rank of a block ranked by where it came from for the gap
- * `(left, right)` right beside its source, not by who moved it.
- * Two peers splitting or lifting out of the same block at once rank their
- * blocks in the same gap; ranks drawn at random there (and tied by client
- * id) sorted one peer's blocks before the other's whatever the text order.
- * Here the rank is a base every replica that saw the same gap computes
- * alike (the gap's midpoint, a fixed tie), then the `side` it comes from
- * ({@link SOURCE_SIDE}: blocks from different sources share the gap, and
- * their paths are not comparable), then the ranks down the
- * block's `path` in its source (the block it stands at), each closed by
- * the lowest segment (a shorter rank then sorts first, as a prefix does),
- * then its `part` there (the caller's order among what stands at one
- * block), its first segment tied by `clientId`: two peers' blocks at one
- * part never share a rank (a later insert between two equal ranks could
- * not land between them), and each peer's blocks there stay together. A
- * segment tied by `clock`, the client's own next clock, follows that first
- * one: one client never mints one rank twice in a gap, even when the block
- * it first minted it for was deleted there and a peer's undo brings it
- * back, and what one gesture minted (the lines of one paste)
- * sorts before what its later gestures mint there, never among it.
- * `null` on a degenerate gap (`left >= right`): the caller ranks it as any
- * insert.
- */
-export declare const sourceRank: (left: string | undefined, right: string | undefined, side: number, path: readonly string[], part: readonly number[], clientId: number, clock: number) => string | null;

package/dist/crdt/placement/source.js

@@ -1,66 +0,0 @@
-/**
- * Ranks minted from where a block comes from: the rank of a block promoted
- * into a slot (`promotedRank`), and the source rank of a block placed beside
- * its source (`sourceRank`), the same on every replica that saw the gap.
- */
-import { decodeRank, encodeRank, rankBetween, RANK_VMIN } from './rank.js';
-/**
- * The rank separator of a promoted slot: the lowest segment a rank can hold
- * (`rankBetween` only copies it from a promoted bound), so `slot + PROMOTED + rank` sorts after
- * `slot` and before every rank the slot's list minted after it — also one
- * that extends `slot`, as an insert between two adjacent digits does.
- */
-const PROMOTED = encodeRank([{ v: RANK_VMIN, t: 0 }]);
-/**
- * The rank of a block promoted into the slot ranked `slot` (read-time
- * promotion, and a promote-delete's planned moves): a valid rank, so an
- * insert beside a promoted block ranks against it like any other.
- */
-export const promotedRank = (slot, rank) => slot + PROMOTED + rank;
-/**
- * Which side of a gap `(X, Y)` a block ranked by its source comes from
- * ({@link sourceRank}), in the order every serial run puts them: the
- * pieces a split of `X` creates, then the blocks leaving `X` for the gap
- * right after it (its children, a list's last items), then the blocks
- * leaving `Y` for the gap right before it (a list's first items).
- */
-export const SOURCE_SIDE = { pieces: 0, after: 1, before: 2 };
-/**
- * The rank of a block ranked by where it came from for the gap
- * `(left, right)` right beside its source, not by who moved it.
- * Two peers splitting or lifting out of the same block at once rank their
- * blocks in the same gap; ranks drawn at random there (and tied by client
- * id) sorted one peer's blocks before the other's whatever the text order.
- * Here the rank is a base every replica that saw the same gap computes
- * alike (the gap's midpoint, a fixed tie), then the `side` it comes from
- * ({@link SOURCE_SIDE}: blocks from different sources share the gap, and
- * their paths are not comparable), then the ranks down the
- * block's `path` in its source (the block it stands at), each closed by
- * the lowest segment (a shorter rank then sorts first, as a prefix does),
- * then its `part` there (the caller's order among what stands at one
- * block), its first segment tied by `clientId`: two peers' blocks at one
- * part never share a rank (a later insert between two equal ranks could
- * not land between them), and each peer's blocks there stay together. A
- * segment tied by `clock`, the client's own next clock, follows that first
- * one: one client never mints one rank twice in a gap, even when the block
- * it first minted it for was deleted there and a peer's undo brings it
- * back, and what one gesture minted (the lines of one paste)
- * sorts before what its later gestures mint there, never among it.
- * `null` on a degenerate gap (`left >= right`): the caller ranks it as any
- * insert.
- */
-export const sourceRank = (left, right, side, path, part, clientId, clock) => {
-    if (left !== undefined && right !== undefined && left >= right)
-        return null;
-    const closed = path.flatMap((r) => [...decodeRank(r), { v: RANK_VMIN, t: SOURCE_TIE }]);
-    const [first, ...rest] = part;
-    const parts = [
-        { v: first, t: clientId },
-        { v: 0, t: clock },
-        ...rest.map((v) => ({ v, t: SOURCE_TIE }))
-    ];
-    const own = [{ v: side, t: SOURCE_TIE }, ...closed, ...parts];
-    return rankBetween(left, right, SOURCE_TIE, () => 0.5) + encodeRank(own);
-};
-/** The tie of a source rank's own segments: the same on every replica. */
-const SOURCE_TIE = 0;

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

@@ -1,129 +0,0 @@
-import type { EngineApi, EngineDoc, EngineNode, YUndoManager } from '../engine-api.js';
-import { type IdSetLike, type IdSetOf, type StoreStruct } from '../structs.js';
-import type { Span } from './deletes.js';
-/** Copy `c:k…` of member `oc:ok…`, whose root characters are `rc:rk…` (`n` of them). */
-export type Copy = Span & {
-    rc: number;
-    rk: number;
-    oc: number;
-    ok: number;
-};
-/** A piece of one member (root or copy) of some characters: ids `c:k…`, root characters from `rk`. */
-export type Member = Span & {
-    rk: number;
-};
-/** A record (one element of a records list), by engine id. */
-export type Rec = {
-    client: number;
-    clock: number;
-};
-export type Unit = StoreStruct & {
-    parent: EngineNode & {
-        name?: string;
-    };
-    content: {
-        getContent(): unknown[];
-        str?: string;
-        type?: {
-            name?: string;
-            _map?: Map<string, Unit>;
-        };
-    };
-    delete(tr: unknown): void;
-};
-export type IdSet = IdSetOf;
-export type Tr = {
-    local: boolean;
-    insertSet: IdSet;
-    deleteSet: IdSet;
-    changed: Map<unknown, unknown>;
-};
-export type Step = {
-    inserts: IdSet;
-    deletes: IdSet;
-};
-export type Policy = {
-    um: () => YUndoManager;
-    /**
-     * Root spans this session answers for: characters an undo skipped (held,
-     * or shown by another copy) and copies it removed as duplicates. Each is
-     * restored whenever nothing shows it and no mark holds it.
-     */
-    watch: Span[];
-    /** The text units of the step being popped (its transaction). */
-    tr: unknown;
-    units: Span[];
-};
-export type State = {
-    doc: EngineDoc & {
-        clientID: number;
-        _transaction: Tr | null;
-    };
-    marks: EngineNode;
-    restored: EngineNode;
-    /** The purge horizon's root: a transaction that changes it is a purge. */
-    horizon: EngineNode;
-    /** Marks by root client: the root spans each holds (and by mark key). */
-    held: Map<number, Map<string, {
-        k: number;
-        n: number;
-        mark: Rec;
-    }[]>>;
-    holds: Map<string, Span[]>;
-    /** Copies by copy client, root client and origin client. */
-    copies: Map<number, Copy[]>;
-    byRoot: Map<number, Copy[]>;
-    byOrigin: Map<number, Copy[]>;
-    copyKeys: Set<string>;
-    policies: Set<Policy>;
-    /** This replica's last delete record (its id), the one a delete may fold into. */
-    lastMark: {
-        c: number;
-        k: number;
-    } | null;
-};
-export declare const overlaps: (a: {
-    k: number;
-    n: number;
-}, b: {
-    k: number;
-    n: number;
-}) => boolean;
-export declare const push: <T>(map: Map<number, T[]>, key: number, v: T) => void;
-export declare const keyOf: (r: Rec) => string;
-/** The most spans a folded delete record holds (a backspace run merges into one). */
-export declare const FOLD_SPANS = 8;
-/** `spans` sorted, with touching and overlapping spans of one client merged. */
-export declare const mergeSpans: (spans: readonly Span[]) => Span[];
-/** `m` narrowed to root characters `[lo, hi)`. */
-export declare const clip: (m: Member, lo: number, hi: number) => Member;
-export declare const encode: (rows: number[][]) => Uint8Array;
-export declare const decode: (bytes: Uint8Array, width: number) => number[][];
-/** The index's reads and writes over a document's `State`. */
-export declare const deleteIndex: (Y: EngineApi) => {
-    idSet: (spans: readonly Span[]) => IdSet;
-    each: (tr: Tr, spans: readonly Span[], fn: (it: Unit) => void) => void;
-    rootSpans: (s: State, sp: Span) => Span[];
-    members: (s: State, r: Span) => Member[];
-    liveRoots: (s: State, m: Member) => Span[];
-    shown: (s: State, roots: readonly Span[]) => Span[];
-    indexOf: (s: State, c: number, k: number) => number;
-    leaves: (s: State, r: Span) => Member[];
-    holders: (s: State, r: Span, skip?: (mark: Rec) => boolean) => Rec[];
-    minus: (r: Span, done: readonly Span[]) => Span[];
-    parts: (s: State, r: Span) => Span[];
-    addCopies: (s: State, copies: readonly Copy[]) => Copy[];
-    indexRecord: (s: State, rec: Rec, bytes: Uint8Array) => Copy[];
-    indexMark: (s: State, mark: Rec, bytes: Uint8Array) => boolean;
-    dropMarks: (s: State, marks: readonly Rec[]) => boolean;
-    recordsIn: (st: StoreStruct, ids: IdSetLike | null) => [Rec, Uint8Array][];
-    sync: (s: State, tr: Tr) => {
-        copies: Copy[];
-        marks: Rec[];
-        released: boolean;
-    };
-    copiesOf: (r: Rec, bytes: Uint8Array) => Copy[];
-    forget: (s: State, copies: readonly Copy[]) => void;
-    collect: (s: State, tr: unknown, copies: readonly Copy[]) => void;
-};
-export type DeleteIndex = ReturnType<typeof deleteIndex>;