edytor 1.0.0-rc.2 → 1.0.0

package/dist/crdt/migration/migrate.d.ts

@@ -1,56 +0,0 @@
-import type { EngineApi, YDoc } from '../engine-api.js';
-import { type JSONDoc } from '../../utils/json.js';
-/** The name of the migration lock of logical document `name`. */
-export declare const migrationBcRoom: (name: string) => string;
-export type MigrationStatus = 'none' | 'pending' | 'active' | 'failed' | 'rolledback';
-/** Durable progress. `pending` is never stored: it is the lock, reported by `status()`. */
-export type MigrationRecord = {
-    v: 1;
-    status: MigrationStatus;
-    migratedAt?: number;
-    rolledbackAt?: number;
-    sourceRows?: number;
-    sourceBytes?: number;
-    error?: string;
-};
-export type MigrationPhase = 'claim' | 'read' | 'materialize' | 'rebuild' | 'verify' | 'persist';
-export type MigrateResult = {
-    /** `active` also covers `already-active` and `nothing-to-migrate`. */
-    status: 'active' | 'busy' | 'failed' | 'rolledback';
-    alreadyActive?: boolean;
-    empty?: boolean;
-    /** The migrated v14 doc (present when this call ran the import). */
-    doc?: YDoc;
-    /**
-     * The migrated state (present when this call ran the import) — restore it
-     * through the document admission path: `loadDocument(result.update)`
-     * lands a `hydrated` document through the gate every load crosses.
-     * The appended row is its diff against what the generation held (the
-     * whole state for a first import).
-     */
-    update?: Uint8Array;
-    /** The materialized logical JSON with its ids (present when this call ran the import). */
-    json?: JSONDoc;
-    sourceRows?: number;
-    error?: string;
-};
-export type MigrateOptions = {
-    /** Legacy database name — defaults to the logical `name` (the v13 layout). */
-    sourceName?: string;
-    /** Re-run even when already `active` or `rolledback` — restores the legacy ids in place. */
-    force?: boolean;
-    /** `false`: return `busy` instead of queueing behind another tab's attempt. */
-    wait?: boolean;
-    /** Phase observer — invoked BEFORE each phase; throwing simulates a crash. */
-    onPhase?: (phase: MigrationPhase) => void | Promise<void>;
-};
-export type Migration = ReturnType<typeof bindMigration>;
-/**
- * Bind the migration path to the vendored v14 engine module.
- */
-export declare const bindMigration: (Y: EngineApi) => {
-    migrate: (name: string, options?: MigrateOptions) => Promise<MigrateResult>;
-    rollback: (name: string) => Promise<void>;
-    status: (name: string) => Promise<MigrationRecord>;
-    waitForSettled: (name: string) => Promise<MigrationRecord>;
-};

package/dist/crdt/migration/migrate.js

@@ -1,227 +0,0 @@
-/**
- * Non-destructive v13 → v14 persistence migration.
- *
- * - READS every row of the legacy `<name>` database's `updates` store (the
- *   v13 y-indexeddb layout) in one readonly transaction, and materializes the
- *   logical JSON a v13 editor produced (`legacy-schema.ts`).
- * - WRITES the import into the generation `edytor-v14-g5:<name>`: the row is
- *   APPENDED and the `active` record written in ONE transaction, so a
- *   completed import is visible iff both committed. The store is append-only
- *   for this writer as for the provider; the legacy database is never
- *   written, so rollback stays available.
- * - A first import is a fresh identity appended beside whatever a live
- *   provider already stored. `force` is a replace-edit instead: it
- *   hydrates the generation, restores every legacy id in place
- *   (restore-definition — delete marks cleared, type, data, placement and
- *   content rewritten, every other block deleted) and appends that diff, so
- *   a forced re-migration reproduces the legacy ids and two devices forcing
- *   independently converge on one copy.
- *
- * CRDT identity, history and undo do not survive a first import (it is a
- * JSON-level import); logical `b_*`/`i_*` ids do, and verification compares
- * them.
- *
- * Attempt vs progress: the attempt is a `navigator.locks` lock named
- * {@link migrationBcRoom} — crash-released, so no lease, owner or poll
- * exists; where the platform has none (Node 22) an in-process mutex stands
- * in. Progress is only the durable record, which is never `pending`:
- * `status()` reports `pending` while the lock is held, and `wait: false`
- * asks for the lock `ifAvailable` and returns `busy`.
- */
-import * as idb from 'lib0-v14/indexeddb';
-import * as f from 'lib0-v14/function';
-import { asEngineDoc } from '../structs.js';
-import { bindEdytorDoc } from '../edytor-doc.js';
-import { bindLegacyReader } from './legacy-schema.js';
-import { keepingReplaced } from '../incarnations.js';
-import { generationDbName } from '../protocols/envelope.js';
-import { CUSTOM, decodeRow, encodeRow, readRow, openContainer, openIfExists, UPDATES, verifyOrStamp } from '../providers/container.js';
-import { jsonBlockToSpec, sanitizeWireJson } from '../../utils/json.js';
-const MIGRATION_KEY = 'migration';
-/** The name of the migration lock of logical document `name`. */
-export const migrationBcRoom = (name) => `edytor-v14-migration:${name}`;
-/** Where `navigator.locks` is absent, an in-process mutex (exclusive only) with its surface. */
-const tails = new Map();
-const inProcess = {
-    request: (name, { ifAvailable }, fn) => {
-        if (ifAvailable && tails.has(name))
-            return Promise.resolve(fn(null));
-        const run = (tails.get(name) ?? Promise.resolve()).then(() => fn({ name }));
-        const tail = run.then(f.nop, f.nop);
-        tails.set(name, tail);
-        void tail.then(() => tails.get(name) === tail && tails.delete(name));
-        return run;
-    },
-    query: async () => ({ held: [...tails.keys()].map((name) => ({ name })) })
-};
-const locks = () => globalThis.navigator?.locks ?? inProcess;
-const readRecord = async (db) => (await idb.rtop(idb.transact(db, [CUSTOM], 'readonly')[0].get(MIGRATION_KEY))) ?? { v: 1, status: 'none' };
-/**
- * The legacy rows, in ONE readonly transaction — the fence: a live v13
- * writer's rows land entirely before or after this snapshot (later rows are
- * the `force` path's). Never creates the legacy database.
- */
-const readLegacyRows = async (sourceName) => {
-    const db = await openIfExists(sourceName);
-    try {
-        if (!db?.objectStoreNames.contains(UPDATES))
-            return [];
-        return (await idb.getAll(idb.transact(db, [UPDATES], 'readonly')[0])).map(decodeRow);
-    }
-    finally {
-        db?.close();
-    }
-};
-/**
- * Give id-less legacy blocks and atoms a deterministic `mig-<path>` id — the
- * one id policy: the import is built from, and verified against, this JSON.
- */
-const withFallbackIds = (b, path) => {
-    const out = { ...b, id: b.id ?? `mig-${path}` };
-    if (b.content && b.content.length > 0) {
-        out.content = b.content.map((item, i) => 'text' in item ? item : { ...item, id: item.id ?? `mig-${path}-i${i}` });
-    }
-    if (b.children && b.children.length > 0) {
-        out.children = b.children.map((c, i) => withFallbackIds(c, `${path}.${i}`));
-    }
-    return out;
-};
-/**
- * Bind the migration path to the vendored v14 engine module.
- */
-export const bindMigration = (Y) => {
-    const reader = bindLegacyReader(Y);
-    const edytorDoc = bindEdytorDoc(Y);
-    /** The durable record — NON-CREATING: probing never leaves a database behind. */
-    const stored = async (name) => {
-        const db = await openIfExists(generationDbName(name));
-        try {
-            return db?.objectStoreNames.contains(CUSTOM)
-                ? await readRecord(db)
-                : { v: 1, status: 'none' };
-        }
-        finally {
-            db?.close();
-        }
-    };
-    /** `pending` while a tab holds the attempt (a waiter's shared hold is not one); the durable record otherwise. */
-    const status = async (name) => {
-        const { held = [] } = await locks().query();
-        return held.some((lock) => lock.name === migrationBcRoom(name) && lock.mode !== 'shared')
-            ? { v: 1, status: 'pending' }
-            : stored(name);
-    };
-    /** Resolve with the durable record once no tab holds the attempt. */
-    const waitForSettled = (name) => locks().request(migrationBcRoom(name), { mode: 'shared' }, () => stored(name));
-    /** One attempt, run while holding the lock. */
-    const attempt = async (name, { sourceName = name, force = false, onPhase }) => {
-        await onPhase?.('claim');
-        const db = await openContainer(generationDbName(name));
-        try {
-            const record = await readRecord(db);
-            if (!force && record.status === 'active')
-                return { status: 'active', alreadyActive: true };
-            if (!force && record.status === 'rolledback')
-                return { status: 'rolledback' };
-            /** Progress, atomically: the appended row (if any) and the record. */
-            const commit = async (next, row) => {
-                const [updates, custom] = idb.transact(db, [UPDATES, CUSTOM]);
-                try {
-                    await verifyOrStamp(name, updates, custom);
-                    if (row)
-                        await idb.addAutoKey(updates, encodeRow(row));
-                    await idb.rtop(custom.put({ v: 1, ...next }, MIGRATION_KEY));
-                }
-                catch (error) {
-                    try {
-                        updates.transaction.abort();
-                    }
-                    catch {
-                        // Already finished — the failed request aborted it.
-                    }
-                    throw error;
-                }
-            };
-            const failed = async (error) => {
-                await commit({ status: 'failed', error, migratedAt: Date.now() });
-                return { status: 'failed', error };
-            };
-            await onPhase?.('read');
-            const rows = await readLegacyRows(sourceName);
-            const sourceRows = rows.length;
-            if (sourceRows === 0) {
-                await onPhase?.('persist');
-                await commit({ status: 'active', migratedAt: Date.now(), sourceRows, sourceBytes: 0 });
-                return { status: 'active', empty: true, sourceRows };
-            }
-            await onPhase?.('materialize');
-            let legacy;
-            try {
-                // Throws PendingLegacyUpdatesError when rows carry structs whose
-                // deps never landed — a truncated document must not activate.
-                // Every string becomes well-formed UTF-16 (F2-M1), as the wire
-                // would deliver it, so verify compares normalized JSON.
-                legacy = sanitizeWireJson(reader.readLegacyJSON(rows));
-            }
-            catch (error) {
-                return failed(`legacy decode failed: ${error.message}`);
-            }
-            const json = { children: legacy.children.map((b, i) => withFallbackIds(b, `${i}`)) };
-            await onPhase?.('rebuild');
-            const doc = keepingReplaced(new Y.Doc());
-            if (force) {
-                const [updates, custom] = idb.transact(db, [UPDATES, CUSTOM]);
-                await verifyOrStamp(name, updates, custom);
-                // Rows first (one transaction), then inflate: a snapshot row is v2, maybe gzip.
-                for (const row of await idb.getAll(updates)) {
-                    const update = await readRow(row);
-                    if (update instanceof Uint8Array)
-                        Y.applyUpdate(doc, update);
-                    else
-                        Y.applyUpdateV2(doc, update.v2);
-                }
-            }
-            const base = Y.encodeStateVector(doc);
-            edytorDoc.restore(asEngineDoc(doc), json.children.map((b) => jsonBlockToSpec(b)));
-            const update = Y.encodeStateAsUpdate(doc);
-            await onPhase?.('verify');
-            const check = keepingReplaced(new Y.Doc());
-            Y.applyUpdate(check, update);
-            if (!f.equalityDeep(edytorDoc.create(asEngineDoc(check)).toJSON(), json)) {
-                return failed('verification failed: migrated document does not reproduce the legacy logical JSON');
-            }
-            await onPhase?.('persist');
-            const sourceBytes = rows.reduce((n, r) => n + r.byteLength, 0);
-            await commit({ status: 'active', migratedAt: Date.now(), sourceRows, sourceBytes }, Y.encodeStateAsUpdate(doc, base));
-            return { status: 'active', doc, update, json, sourceRows };
-        }
-        finally {
-            db.close();
-        }
-    };
-    /**
-     * Run the migration for logical document `name`: `active` already →
-     * `{alreadyActive: true}`; `rolledback` → `{status: 'rolledback'}` unless
-     * `force`; another tab mid-attempt → queue behind it (`wait: false` →
-     * `busy`); otherwise import, verify and commit.
-     */
-    const migrate = (name, options = {}) => locks().request(migrationBcRoom(name), { ifAvailable: options.wait === false }, (lock) => lock === null ? { status: 'busy' } : attempt(name, options));
-    /**
-     * Roll back: mark the generation `rolledback` and clear its rows. The
-     * legacy database is untouched, so a v13 stack works again on its own
-     * data; a later `migrate` needs `force` — rollback is an operator decision.
-     */
-    const rollback = async (name) => {
-        const db = await openContainer(generationDbName(name));
-        try {
-            const [updates, custom] = idb.transact(db, [UPDATES, CUSTOM]);
-            const record = { v: 1, status: 'rolledback', rolledbackAt: Date.now() };
-            await idb.rtop(custom.put(record, MIGRATION_KEY));
-            await idb.rtop(updates.clear());
-        }
-        finally {
-            db.close();
-        }
-    };
-    return { migrate, rollback, status, waitForSettled };
-};

package/dist/crdt/nodes.d.ts

@@ -1,121 +0,0 @@
-/**
- * Typed node surface — `document.block(id)` handles over the semantic
- * model. Each handle is a thin dead-safe wrapper: ops delegate to the
- * facade's ownership-aware operations and return its {@link OpResult}
- * (`refused` on absent/merged ids).
- *
- * Handles are transaction-aware: `childIds()` etc. reflect mutations made
- * earlier in the same transaction.
- * What is COMMIT-BOUND is PUBLICATION: the change report and
- * `onChange` fire once per completed transaction with the final coherent
- * state — a mid-transaction read never publishes a partial snapshot, and
- * a change-then-revert transaction publishes nothing.
- *
- * Snapshot isolation: item `marks`/`data` payloads on `items`,
- * `project()`, `runs` and `DocChange` content are canonical deep-frozen
- * objects — mutating a returned snapshot throws (strict mode) or lands on
- * a frozen shared instance, never on live engine state.
- *
- * The read half is deliberately narrow — the consumed set: identity
- * (`id`, `document`), the per-block attribution record, the two content views
- * (transaction-aware `items`, commit-synced `runs`), `length` and
- * `childIds`. Richer structure reads (positions, paths, roles, anchors)
- * live on the facade (`positionOf`/`pathOf`/`isVoid`/`anchorAt`/…).
- */
-import type { BlockId, BlockSpec, ContentItem, InlineSpec, SplitTail } from './placement/model.js';
-import type { ContentRun } from './text/runs.js';
-import type { EdytorDoc, OpResult } from './edytor-doc.js';
-import type { DocumentOperations, DocumentWrites } from './operations.js';
-import type { BlockAttribution } from './attribution/block.js';
-/** A node argument: another block handle, a raw block id, or `null` for the root list. */
-export type NodeRef = DocBlock | BlockId | null;
-/**
- * Typed handle over one document block. Handles are dead-safe: constructing
- * one for an absent/merged id is legal — ops are `refused` (the underlying
- * facade ops guard the same way).
- *
- * Read members are getters — every access re-derives from current doc state,
- * so a handle obtained before a mutation sees the mutation afterwards
- * (including within the same transaction).
- */
-export type DocBlock = {
-    /** Stable caller-assigned block id. */
-    readonly id: BlockId;
-    /** The owning document — cross-node and document-level ops live here. */
-    readonly document: DocumentOperations;
-    /**
-     * Compact per-block attribution (`{createdBy, contributors,
-     * lastChangedBy}` as durable actor ids), or `undefined` for
-     * system/foreign blocks carrying no record. Read live per access.
-     */
-    readonly attribution: BlockAttribution | undefined;
-    /**
-     * Resolved content items of this block's display ({kind:'text'} runs and
-     * {kind:'inline'} atoms in display order, unmerged across streams).
-     * Reflects writes made earlier in the same transaction.
-     */
-    readonly items: readonly ContentItem[];
-    /** Display length in atoms (UTF-16 text units + 1 per inline atom). */
-    readonly length: number;
-    /**
-     * The maintained run view for this block — frozen, structurally shared
-     * run arrays refreshed at transaction commit. Rendering and `DocChange`
-     * payloads consume this; command code should use {@link items} (the
-     * transaction-aware view) when reading mid-transaction.
-     */
-    readonly runs: readonly ContentRun[];
-    /** Ordered visible child ids. */
-    childIds(): BlockId[];
-    insertText(offset: number, text: string, marks?: Record<string, unknown>): OpResult;
-    deleteText(offset: number, length: number): OpResult;
-    /** Multi-mark format over `[offset, offset+length)`; `null` values unset. */
-    format(offset: number, length: number, marks: Record<string, unknown>): OpResult;
-    setMark(offset: number, length: number, name: string, value: unknown): OpResult;
-    unsetMark(offset: number, length: number, name: string): OpResult;
-    /** Remove every mark present anywhere in the range. */
-    clearMarks(offset: number, length: number): OpResult;
-    insertInline(offset: number, spec: InlineSpec): OpResult;
-    removeInline(inlineId: string): OpResult;
-    setInlineData(inlineId: string, data: Record<string, unknown>): OpResult;
-    /** Insert a fresh-identity child spec; `ids`: the new block. */
-    insertChild(index: number, spec: BlockSpec): OpResult;
-    /** Relocate this block — identity preserved; island/void rules apply. */
-    moveTo(dest: {
-        parent: NodeRef;
-        index: number;
-    }): OpResult;
-    /** Move to the last position under `parent`. */
-    nestUnder(parent: DocBlock | BlockId): OpResult;
-    /** Move beside the parent (index = parent index + 1). */
-    unNest(): OpResult;
-    /** Split content at display `offset` into a new sibling `newId`; `ids`: the new block. */
-    split(offset: number, newId: BlockId, tail?: SplitTail): OpResult;
-    /** Baseline merge into the previous block in document order (a list's first item lifts out instead); `ids`: the survivor. */
-    mergeBackward(): OpResult;
-    /** Baseline merge pulling the next block in document order into this (a list passes its first item). */
-    mergeForward(): OpResult;
-    /** Engine merge primitive — `other`'s content+children claim into this. */
-    mergeFrom(other: DocBlock | BlockId): OpResult;
-    /** Delete (per-writer marks on this block and what it displays); the children take its slot unless `keepChildren: false`. */
-    delete(opts?: {
-        keepChildren?: boolean;
-    }): OpResult;
-    setType(type: string): OpResult;
-    setData(data: Record<string, unknown>): OpResult;
-    /** Baseline `setBlock` — type/data update in place; content/children replace (all-or-nothing). */
-    set(value: Parameters<DocumentWrites['setBlock']>[1]): OpResult;
-    /**
-     * Fresh-identity copy of this subtree right after it; `freshId` names each
-     * copied block and inline atom (an unanswered atom id is minted, an
-     * unanswered block id refuses); `ids`: the copy.
-     */
-    duplicate(freshId: (oldId: string, kind: 'block' | 'inline') => string): OpResult;
-};
-/**
- * Build the `document.block(id)` node surface over an existing facade —
- * one cached handle per id (the facade normalized it at ingress), all
- * delegating to the facade's semantic ops.
- */
-export declare const bindNodes: (doc: EdytorDoc) => {
-    block: (id: BlockId) => DocBlock;
-};

package/dist/crdt/nodes.js

@@ -1,56 +0,0 @@
-const idOf = (ref) => ref == null ? null : typeof ref === 'string' ? ref : ref.id;
-/**
- * Build the `document.block(id)` node surface over an existing facade —
- * one cached handle per id (the facade normalized it at ingress), all
- * delegating to the facade's semantic ops.
- */
-export const bindNodes = (doc) => {
-    const cache = new Map();
-    const block = (id) => {
-        const cached = cache.get(id);
-        if (cached)
-            return cached;
-        const handle = {
-            id,
-            document: doc,
-            get attribution() {
-                return doc.blockAttribution(id);
-            },
-            get items() {
-                return doc.contentItems(id);
-            },
-            get length() {
-                return doc.displayLength(id);
-            },
-            get runs() {
-                return doc.runs(id);
-            },
-            childIds: () => doc.childrenIds(id),
-            insertText: (offset, text, marks) => doc.insertText(id, offset, text, marks),
-            deleteText: (offset, length) => doc.deleteText(id, offset, length),
-            format: (offset, length, marks) => doc.formatRange(id, offset, length, marks),
-            setMark: (offset, length, name, value) => doc.setMark(id, offset, length, name, value),
-            unsetMark: (offset, length, name) => doc.unsetMark(id, offset, length, name),
-            clearMarks: (offset, length) => doc.clearMarks(id, offset, length),
-            insertInline: (offset, spec) => doc.insertInline(id, offset, spec),
-            removeInline: (inlineId) => doc.removeInline(id, inlineId),
-            setInlineData: (inlineId, data) => doc.setInlineData(id, inlineId, data),
-            insertChild: (index, spec) => doc.insertBlock({ parent: id, index }, spec),
-            moveTo: (dest) => doc.moveBlock(id, { parent: idOf(dest.parent), index: dest.index }),
-            nestUnder: (parent) => doc.nestBlock(id, idOf(parent)),
-            unNest: () => doc.unNestBlock(id),
-            split: (offset, newId, tail) => doc.splitBlock(id, offset, newId, tail),
-            mergeBackward: () => doc.mergeBackward(id),
-            mergeForward: () => doc.mergeForward(id),
-            mergeFrom: (other) => doc.mergeBlocks(idOf(other), id),
-            delete: (opts) => doc.deleteBlock(id, opts),
-            setType: (type) => doc.setBlockType(id, type),
-            setData: (data) => doc.setBlockData(id, data),
-            set: (value) => doc.setBlock(id, value),
-            duplicate: (freshId) => doc.duplicateBlock(id, freshId)
-        };
-        cache.set(id, handle);
-        return handle;
-    };
-    return { block };
-};

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

@@ -1,15 +0,0 @@
-import type { IndexAnchored } from './anchored.js';
-import type { IndexCache } from './cache.js';
-import type { IndexClaims } from './claims.js';
-import type { IndexFold } from './fold.js';
-import type { IndexLayout } from './layout.js';
-import type { IndexPlacement } from './placement.js';
-import type { IndexReporter } from './report.js';
-import type { IndexState, Published } from './state.js';
-import type { IndexStreams } from './streams.js';
-/** The self-checks of one doc's index, over every part they compare. */
-export declare const indexSelfChecks: (ix: IndexState & IndexClaims & IndexStreams & IndexAnchored & IndexLayout & IndexPlacement & IndexCache & IndexFold & IndexReporter) => {
-    check: () => void;
-    checkPublished: (pub: Published) => void;
-};
-export type IndexSelfChecks = ReturnType<typeof indexSelfChecks>;

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

@@ -1,156 +0,0 @@
-/**
- * The index's self-checks (`indexChecks`, on in the test lanes): after every
- * fold each fact the index maintains incrementally equals its rebuild from
- * the replicated state, and after every report the published tree equals a
- * fresh walk; the first difference throws.
- */
-import { sameIds } from '../../../utils/json.js';
-import { childrenIndex, displayIndex, resolvePlacements } from '../../placement/model.js';
-import { DEAD, claimGraph, cmpStamp, delimiters, placeText, scanText } from '../model.js';
-import { sameRow } from '../rows.js';
-import { keyOf } from './shared.js';
-/** The self-checks of one doc's index, over every part they compare. */
-export const indexSelfChecks = (ix) => {
-    const { blocks, displaysMap, rows, streamIx, placementsMap, following, cache, dirty, ownerOf, streamOf, sameClaims, targetOf, dissolve, ranker, ownShim, own0, noteFollowing, ensurePlacements, computeFresh, unfolded, reachable } = ix;
-    /** {@link indexChecks}: every incrementally maintained fact equals its rebuild. */
-    const check = () => {
-        // A queued transaction whose writes this fold has not seen yet
-        // (a follow-up a cleanup started): the index lags it until its
-        // own fold, so there is nothing to compare yet.
-        if (unfolded())
-            return;
-        const fail = (what) => {
-            throw new Error(`[edytor index] ${what} differs from its rebuild`);
-        };
-        const scans = new Map();
-        for (const rec of blocks.values())
-            if (rec.content)
-                scans.set(rec.id, scanText(rec.id, rec.content));
-        for (const home of rows.keys())
-            if (!scans.has(home))
-                fail(`row ${home}`);
-        for (const [home, scan] of scans) {
-            const row = rows.get(home);
-            if (row === undefined || row.text !== scan.text || !sameRow(row, scan))
-                fail(`row ${home}`);
-        }
-        const want = delimiters(blocks, scans.values());
-        if (want.size !== ix.delim.size || [...want].some(([b, k]) => ix.delim.get(b) !== k))
-            fail('delimiters');
-        const streamSig = (st) => st && `${st.home}:${st.start}-${st.end}/${st.inert.join(',')}`;
-        const placed = new Set();
-        for (const [home, scan] of scans)
-            for (const st of placeText(scan, want)) {
-                placed.add(st.block);
-                if (streamSig(streamOf(st.block)) !== streamSig(st))
-                    fail(`stream of ${st.block} in ${home}`);
-            }
-        for (const b of streamIx.keys())
-            if (!placed.has(b))
-                fail(`stream of ${b}`);
-        // The anchored claims (`merge.claim.anchor`): each record's effective claims, from scratch.
-        {
-            const moved = new Map();
-            const stays = new Map();
-            for (const [h, rec] of blocks) {
-                const list = rec.listClaims ?? rec.claims;
-                const own = [];
-                for (const c of list) {
-                    const [t] = targetOf(h, c);
-                    if (t === h)
-                        own.push(c);
-                    else {
-                        let into = moved.get(t);
-                        if (into === undefined)
-                            moved.set(t, (into = []));
-                        into.push({ ...c, holder: h });
-                    }
-                }
-                stays.set(h, own);
-            }
-            for (const [b, rec] of blocks) {
-                const extra = (moved.get(b) ?? []).sort((x, y) => cmpStamp(x.stamp, y.stamp));
-                if (!sameClaims(rec.claims, [...stays.get(b), ...extra]))
-                    fail(`claims of ${b}`);
-            }
-        }
-        for (const [b, c] of cache) {
-            if (dirty.has(b))
-                continue;
-            const fresh = computeFresh(b).fresh;
-            if (keyOf(fresh) !== keyOf(c.runs))
-                fail(`runs of ${b}`);
-        }
-        // The claim graph, placements, children index and layout rules.
-        ensurePlacements();
-        const graph = claimGraph(blocks);
-        for (const b of blocks.keys()) {
-            if (ownerOf(b) !== (graph.owners.get(b) ?? DEAD))
-                fail(`owner of ${b}`);
-            if (ownShim.top(b) !== graph.top.get(b))
-                fail(`top of ${b}`);
-        }
-        const shown = displayIndex(blocks, ownerOf);
-        for (const [o, list] of shown)
-            if (list.length !== (displaysMap.get(o)?.size ?? 0) ||
-                list.some((b) => !displaysMap.get(o).has(b)))
-                fail(`displays of ${o}`);
-        for (const o of displaysMap.keys())
-            if (!shown.has(o))
-                fail(`displays of ${o}`);
-        const resolved = resolvePlacements(blocks, ownerOf);
-        if (resolved.size !== placementsMap.size)
-            fail('placements');
-        for (const [b, pl] of resolved) {
-            const mine = placementsMap.get(b);
-            if (mine?.parent !== pl.parent || mine.rank !== pl.rank)
-                fail(`placement of ${b}`);
-        }
-        const same = (x, y) => x.size === y.size && [...x].every(([p, l]) => keyOf(l) === keyOf(y.get(p) ?? null));
-        // The text orders decided afresh: a stale one shows as a slot mismatch.
-        ranker.forget();
-        const k0 = childrenIndex(placementsMap, own0);
-        if (!same(k0, ix.kids0))
-            fail('children index (before the layout rules)');
-        const out = dissolve(k0);
-        if (out.size !== ix.dissolved.size || [...out].some((b) => !ix.dissolved.has(b)))
-            fail('dissolved');
-        if (!same(childrenIndex(placementsMap, ownShim), ix.kidsMap))
-            fail('children index');
-        for (const [p, l] of ix.kidsMap)
-            for (const { id, rank, reset } of l) {
-                const slot = ix.slots.get(id);
-                if (slot?.parent !== p || slot.rank !== rank || slot.reset !== reset)
-                    fail(`slot of ${id}`);
-            }
-        const follow = new Set(following);
-        for (const id of ix.slots.keys())
-            noteFollowing(id);
-        if (follow.size !== following.size || [...follow].some((b) => !following.has(b)))
-            fail('following');
-    };
-    /** {@link indexChecks}: the published tree the report advanced equals a fresh walk. */
-    const checkPublished = (pub) => {
-        // Payloads from the published nodes: the check reads no runs.
-        const want = reachable(pub.nodes);
-        const fail = (what) => {
-            throw new Error(`[edytor index] published ${what} differs from its rebuild`);
-        };
-        if (want.order.size !== pub.order.size)
-            fail('lists');
-        for (const [p, ids] of want.order)
-            if (!sameIds(ids, pub.order.get(p) ?? []))
-                fail(`list of ${p}`);
-        if (want.nodes.size !== pub.nodes.size)
-            fail('blocks');
-        for (const [id, n] of want.nodes) {
-            const m = pub.nodes.get(id);
-            if (m?.parent !== n.parent || m.index !== n.index)
-                fail(`slot of ${id}`);
-        }
-    };
-    return {
-        check,
-        checkPublished
-    };
-};

package/dist/crdt/vendor/yjs/dts/utils/EventHandler.d.ts

@@ -1,17 +0,0 @@
-/**
- * General event handler implementation.
- *
- * @template ARG0, ARG1
- *
- * @private
- */
-export class EventHandler<ARG0, ARG1> {
-    /**
-     * @type {Array<function(ARG0, ARG1):void>}
-     */
-    l: Array<(arg0: ARG0, arg1: ARG1) => void>;
-}
-export function createEventHandler<ARG0, ARG1>(): EventHandler<ARG0, ARG1>;
-export function addEventHandlerListener<ARG0, ARG1>(eventHandler: EventHandler<ARG0, ARG1>, f: (arg0: ARG0, arg1: ARG1) => void): number;
-export function removeEventHandlerListener<ARG0, ARG1>(eventHandler: EventHandler<ARG0, ARG1>, f: (arg0: ARG0, arg1: ARG1) => void): void;
-export function callEventHandlerListeners<ARG0, ARG1>(eventHandler: EventHandler<ARG0, ARG1>, arg0: ARG0, arg1: ARG1): void;