edytor 1.0.0-rc.3 → 2.0.0

package/dist/crdt/doc/table.d.ts

@@ -1,21 +0,0 @@
-import type { BlockId } from '../placement/model.js';
-import type { DataPatch } from '../data.js';
-import type { DataTarget, PlanStep, Prepared } from './types.js';
-import type { OpsContext } from './steps.js';
-/** One column of a table's `data.columns`. */
-export type TableColumn = {
-    id: string;
-    width?: number;
-};
-/** The table ops of one facade, prepared. */
-export declare const tableOps: (c: OpsContext & {
-    dataSteps: (target: DataTarget, patches: DataPatch[]) => PlanStep[] | null;
-}) => {
-    insertTableRow: (table: BlockId, index: number) => Prepared;
-    deleteTableRows: (rows: readonly BlockId[]) => Prepared;
-    insertTableColumn: (table: BlockId, index: number, width?: number) => Prepared;
-    deleteTableColumn: (table: BlockId, column: string | number) => Prepared;
-    moveTableColumn: (table: BlockId, column: string | number, to: number) => Prepared;
-    moveTableRows: (rows: readonly BlockId[], to: number) => Prepared;
-    fillTableCell: (row: BlockId, column: string | number) => Prepared;
-};

package/dist/crdt/doc/table.js

@@ -1,288 +0,0 @@
-/**
- * Table ops (`table.*`): a table (a kind whose role says `table`) holds
- * rows, a row cells, each cell names its column (`data.column`) and the
- * table lists its columns in order (`data.columns`: `{ id, width? }`). The
- * columns are data: inserting, deleting or moving one writes the table's
- * `columns` array (and the cells of the rows it shows) in one plan, and
- * the index shows every row's cells in that order (`table.columns`); a
- * cell of no listed column does not display (`table.cell`), and the view
- * pads a row that shows fewer cells than the table's columns
- * (`table.pad`). Rows are blocks: a row moves among its table's rows by
- * placement.
- */
-import { id as newId } from '../../utils.js';
-import { ref } from './plan.js';
-/** The table ops of one facade, prepared. */
-export const tableOps = (c) => {
-    const { roles, childrenIds, positionOf, live, isTable, isTableRow, rowKindOf, tableColumns, tableGrid, blockDataOf, dataItemIds, REFUSED, plan, ranksFor, move, remove, emptied, dataSteps } = c;
-    /** The cell kind of `table`'s rows. */
-    const cellKindOf = (table) => roles.defaultChild(rowKindOf(table));
-    const cellSpec = (table, column) => ({
-        id: newId('b'),
-        type: cellKindOf(table),
-        data: { column }
-    });
-    /**
-     * The table's columns and grid. A table listing none gets one column
-     * per column of its widest row, with ids from their positions (`c1`,
-     * `c2`, … as `tableBlock`'s), and `adopt` names each shown
-     * cell's column: two peers adopting one table write the same array
-     * items and the same cells' columns. The op then writes that array
-     * first, in its plan ({@link columnsSteps}).
-     */
-    const adopted = (table) => {
-        const grid = tableGrid(table);
-        if (grid === null)
-            return null;
-        const listed = tableColumns(table);
-        if (listed !== null) {
-            const stored = blockDataOf(table)?.columns;
-            const raw = stored.map((col) => {
-                const id = col?.id;
-                return typeof id === 'string' ? id : null;
-            });
-            return { columns: listed, raw, adopt: [], first: [], grid };
-        }
-        const columns = grid.columns.map((_, i) => ({ id: `c${i + 1}` }));
-        const adopt = [];
-        for (const row of grid.rows)
-            row.cells.forEach((cell, i) => {
-                if (cell === null)
-                    return;
-                const steps = dataSteps(cell, [{ path: ['column'], value: columns[i].id }]);
-                if (steps)
-                    adopt.push(...steps);
-            });
-        return {
-            columns,
-            raw: columns.map((col) => col.id),
-            adopt,
-            first: [{ path: ['columns'], value: columns }],
-            grid: { columns: columns.map((col) => col.id), rows: grid.rows }
-        };
-    };
-    /** The adoption's steps, then `patches` of the table's `data.columns`. */
-    const columnsSteps = (table, a, patches = []) => {
-        const all = [...a.first, ...patches];
-        const steps = all.length === 0 ? [] : dataSteps(table, all);
-        return steps === null ? null : [...a.adopt, ...steps];
-    };
-    /**
-     * The position among the grid's columns of `column`: a position, or an
-     * id (a table listing no columns names them by position until it adopts
-     * them); `-1` when none.
-     */
-    const positionIn = (a, listed, column) => {
-        const at = typeof column === 'number'
-            ? column
-            : listed
-                ? a.grid.columns.indexOf(column)
-                : Number(column);
-        return Number.isInteger(at) && at >= 0 && at < a.grid.columns.length ? at : -1;
-    };
-    /**
-     * The stored entry (its index in `data.columns`) the listed column at
-     * position `at` is: the first naming it; the array's length past them.
-     */
-    const rawIndex = (a, at) => {
-        const id = a.columns[at]?.id;
-        const i = id === undefined ? -1 : a.raw.indexOf(id);
-        return i < 0 ? a.raw.length : i;
-    };
-    /**
-     * Insert a row at `index` among `table`'s rows (`table.insert-row`): one
-     * empty cell per column, in one plan. An insert's rank (it extends this
-     * client's run, `order.insert.run`). `ids`: the new row.
-     */
-    const insertTableRow = (table, index) => {
-        table = ref(table);
-        if (!isTable(table) || !live(table))
-            return REFUSED;
-        const a = adopted(table);
-        if (a === null)
-            return REFUSED;
-        const rows = childrenIds(table);
-        const at = Math.max(0, Math.min(Math.trunc(index) || 0, rows.length));
-        const row = {
-            id: newId('b'),
-            type: rowKindOf(table),
-            data: {},
-            children: a.columns.map((col) => cellSpec(table, col.id))
-        };
-        const ranks = ranksFor(table, at, 1, [], true);
-        const data = columnsSteps(table, a);
-        if (data === null)
-            return REFUSED;
-        return plan([row.id], [...data, { op: 'insertBlocks', parent: table, index: at, specs: [row], ranks }]);
-    };
-    /**
-     * Delete `rows` with their cells (`table.delete-row`): one plan; a table
-     * left with no row goes with them.
-     */
-    const deleteTableRows = (rows) => {
-        const ids = [...new Set(rows.map(ref))];
-        if (ids.length === 0 || ids.some((id) => !live(id) || !isTableRow(id)))
-            return REFUSED;
-        return plan(ids, emptied(ids, ids.map((id) => remove(id))));
-    };
-    /**
-     * Insert a column at `index` among `table`'s listed columns
-     * (`table.insert-column`): a new id in `data.columns` and an empty cell
-     * for it in every row the table shows, in one plan. `width`: the new
-     * column's. `ids`: the table.
-     */
-    const insertTableColumn = (table, index, width) => {
-        table = ref(table);
-        if (!isTable(table) || !live(table))
-            return REFUSED;
-        const a = adopted(table);
-        if (a === null)
-            return REFUSED;
-        const at = Math.max(0, Math.min(Math.trunc(index) || 0, a.columns.length));
-        const column = typeof width === 'number' && Number.isFinite(width) && width > 0
-            ? { id: newId('c'), width }
-            : { id: newId('c') };
-        const data = columnsSteps(table, a, [
-            { path: ['columns'], splice: [rawIndex(a, at), 0, column] }
-        ]);
-        if (data === null)
-            return REFUSED;
-        const cells = a.grid.rows.map((row) => {
-            const kids = childrenIds(row.id);
-            const slot = Math.min(row.cells.slice(0, at).filter((x) => x !== null).length, kids.length);
-            return {
-                op: 'insertBlocks',
-                parent: row.id,
-                index: slot,
-                specs: [cellSpec(table, column.id)],
-                ranks: ranksFor(row.id, slot, 1)
-            };
-        });
-        return plan([table], [...data, ...cells]);
-    };
-    /**
-     * Delete a column (`table.delete-column`, by id or position among the
-     * grid's): it leaves `data.columns` (every entry naming it) and every
-     * shown cell of it is deleted, in one plan; a table left with no column
-     * goes with it. A column the table shows but no longer lists
-     * (`table.cell`) loses its cells. `ids`: the table.
-     */
-    const deleteTableColumn = (table, column) => {
-        table = ref(table);
-        if (!isTable(table) || !live(table))
-            return REFUSED;
-        const listed = tableColumns(table) !== null;
-        const a = adopted(table);
-        if (a === null)
-            return REFUSED;
-        const at = positionIn(a, listed, column);
-        if (at < 0)
-            return REFUSED;
-        if (a.grid.columns.length === 1)
-            return plan([table], [remove(table)]);
-        const id = a.grid.columns[at];
-        const items = listed ? dataItemIds(table, ['columns']) : [];
-        const entries = listed
-            ? a.raw.flatMap((c, i) => (c === id && items[i] ? [items[i]] : []))
-            : [];
-        const data = columnsSteps(table, a, listed
-            ? entries.map((item) => ({ path: ['columns', item] }))
-            : [{ path: ['columns'], splice: [at, 1] }]);
-        if (data === null)
-            return REFUSED;
-        const gone = a.grid.rows.flatMap((row) => {
-            const cell = row.cells[at];
-            return cell === null || cell === undefined ? [] : [cell];
-        });
-        return plan([table], emptied(gone, [...data, ...gone.map((cell) => remove(cell))]));
-    };
-    /**
-     * Move a listed column to position `to` among them (`table.move-column`):
-     * one `order` patch of `data.columns`; no cell moves, every row shows its
-     * cells in the new order. `ids`: the table.
-     */
-    const moveTableColumn = (table, column, to) => {
-        table = ref(table);
-        if (!isTable(table) || !live(table))
-            return REFUSED;
-        const listed = tableColumns(table) !== null;
-        const a = adopted(table);
-        if (a === null)
-            return REFUSED;
-        const from = positionIn(a, listed, column);
-        const dest = Math.trunc(to);
-        if (from < 0 || from >= a.columns.length || !(dest >= 0 && dest < a.columns.length))
-            return REFUSED;
-        if (from === dest) {
-            const same = columnsSteps(table, a);
-            return same === null ? REFUSED : plan([table], same);
-        }
-        const moved = a.columns.map((_, i) => i);
-        moved.splice(from, 1);
-        moved.splice(dest, 0, from);
-        // Over the stored entries: the listed ones in their new order, then the rest as they were.
-        const firsts = moved.map((i) => rawIndex(a, i));
-        const rest = a.raw.map((_, i) => i).filter((i) => !firsts.includes(i));
-        const data = columnsSteps(table, a, [{ path: ['columns'], order: [...firsts, ...rest] }]);
-        return data === null ? REFUSED : plan([table], data);
-    };
-    /**
-     * Move rows to position `to` among their table's rows
-     * (`table.move-row`): a move (plain ranks). Refused unless every one is
-     * a row of `table`. `ids`: the rows.
-     */
-    const moveTableRows = (rows, to) => {
-        const ids = rows.map(ref);
-        const table = ids.length > 0 ? positionOf(ids[0])?.parent : null;
-        if (table == null || ids.some((id) => !isTableRow(id) || positionOf(id).parent !== table))
-            return REFUSED;
-        const at = Math.max(0, Math.min(Math.trunc(to) || 0, childrenIds(table).length));
-        return plan(ids, move(ids, table, at));
-    };
-    /**
-     * Create the cell `row` shows none of for `column` (an id, or a
-     * position among the grid's; `table.pad`: the first edit in a padded
-     * cell), empty, in one plan. A column the table shows but no longer
-     * lists (`table.cell`) is listed again, last. `ids`: the new cell.
-     */
-    const fillTableCell = (row, column) => {
-        row = ref(row);
-        if (!isTableRow(row) || !live(row))
-            return REFUSED;
-        const table = positionOf(row).parent;
-        const listed = tableColumns(table) !== null;
-        const a = adopted(table);
-        if (a === null)
-            return REFUSED;
-        const at = positionIn(a, listed, column);
-        const shown = a.grid.rows.find((r) => r.id === row);
-        if (at < 0 || shown === undefined || shown.cells[at] !== null)
-            return REFUSED;
-        const kids = childrenIds(row);
-        const slot = Math.min(shown.cells.slice(0, at).filter((x) => x !== null).length, kids.length);
-        const id = a.grid.columns[at];
-        const spec = cellSpec(table, id);
-        const data = columnsSteps(table, a, at < a.columns.length ? [] : [{ path: ['columns'], splice: [a.raw.length, 0, { id }] }]);
-        if (data === null)
-            return REFUSED;
-        return plan([spec.id], [
-            ...data,
-            {
-                op: 'insertBlocks',
-                parent: row,
-                index: slot,
-                specs: [spec],
-                ranks: ranksFor(row, slot, 1)
-            }
-        ]);
-    };
-    return {
-        insertTableRow,
-        deleteTableRows,
-        insertTableColumn,
-        deleteTableColumn,
-        moveTableColumn,
-        moveTableRows,
-        fillTableCell
-    };
-};

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

@@ -1,58 +0,0 @@
-/**
- * The generation cutover (schema generation 4 → 5, 0.1.0-next.25).
- *
- * Generation 5 changed the format of what a document stores: marks are
- * paired operations (fork patch YP13), ranks are variable-length
- * and a SyncStep2 is v2 on the wire. Bytes of generation 4 are never
- * integrated beside generation 5's (every frame and container names its
- * generation, `protocols/envelope.ts`): a container of generation 4 is
- * READ — its records applied to a scratch document, no admission, no
- * write — and its visible document taken as JSON, which generation 5
- * seeds again (a deterministic seed: two replicas converting the same
- * state write the same update). Reading needs no conversion of its own:
- * generation 4's plain format items fold as upstream formats, its ranks
- * order as strings, its delete records read as they are.
- *
- * What a conversion keeps: the visible document (blocks with their ids,
- * kinds, data and content, marks, the document's data). What it does not:
- * CRDT identity, history (undo), attribution, waiting deletes, and edits
- * a replica never sent before the cutover.
- *
- * Worker-safe: the room converts its container at load.
- */
-import type { EngineApi, YDoc } from '../engine-api.js';
-import { type GenerationRecord } from '../protocols/envelope.js';
-import type { DocumentSemanticsConfig } from '../document.js';
-import type { JSONDoc } from '../../utils/json.js';
-/** The schema generation this build converts from. */
-export declare const PREVIOUS_SCHEMA = 4;
-/** Whether container record `v` is generation 4's (`{engine, protocol, schema: 4}`). */
-export declare const isPreviousGenerationRecord: (v: unknown) => v is GenerationRecord;
-/** A facade that reads (`toJSON`) and is let go (`dispose`). */
-type Reader = {
-    toJSON(): JSONDoc;
-    dispose(): void;
-};
-export declare const bindGenerations: (Y: EngineApi) => {
-    isPreviousGenerationRecord: (v: unknown) => v is GenerationRecord;
-    /**
-     * The visible document a state of generation 4 holds, as JSON: `updates`
-     * (v1 updates, or `{ v2 }` snapshots, in order) applied to a scratch
-     * document, read through `facadeOf` (a facade of this build, with the
-     * semantics the document is read with).
-     */
-    previousJSON: (updates: ReadonlyArray<Uint8Array | {
-        v2: Uint8Array;
-    }>, facadeOf: (doc: YDoc) => Reader) => JSONDoc;
-    /**
-     * This generation's seed of `value` — the update a document seeds it
-     * with (deterministic: the same value writes the same update anywhere),
-     * read with `semantics`.
-     */
-    seedOf: (value: JSONDoc, semantics?: DocumentSemanticsConfig) => Uint8Array;
-    /** {@link previousJSON} read with `semantics` (the bundled kinds' by default). */
-    previousJSONWith: (updates: ReadonlyArray<Uint8Array | {
-        v2: Uint8Array;
-    }>, semantics?: DocumentSemanticsConfig) => JSONDoc;
-};
-export {};

package/dist/crdt/migration/generation.js

@@ -1,70 +0,0 @@
-import { asEngineDoc } from '../structs.js';
-import { bindEdytorDoc } from '../edytor-doc.js';
-import { keepingReplaced } from '../incarnations.js';
-import { PROTOCOL_VERSION } from '../protocols/envelope.js';
-import { defaultSemantics, facadeConfigOf } from '../semantics.js';
-/** The schema generation this build converts from. */
-export const PREVIOUS_SCHEMA = 4;
-/** Whether container record `v` is generation 4's (`{engine, protocol, schema: 4}`). */
-export const isPreviousGenerationRecord = (v) => typeof v === 'object' &&
-    v !== null &&
-    v.engine === 'yjs-v14' &&
-    v.protocol === PROTOCOL_VERSION &&
-    v.schema === PREVIOUS_SCHEMA &&
-    [undefined, 'v1', 'v2'].includes(v.storage);
-export const bindGenerations = (Y) => {
-    const docs = bindEdytorDoc(Y);
-    /** A facade reading with `semantics` (the bundled kinds' by default). */
-    const facadeWith = (semantics = defaultSemantics) => (doc) => docs.create(asEngineDoc(doc), facadeConfigOf(semantics));
-    const generations = {
-        isPreviousGenerationRecord,
-        /**
-         * The visible document a state of generation 4 holds, as JSON: `updates`
-         * (v1 updates, or `{ v2 }` snapshots, in order) applied to a scratch
-         * document, read through `facadeOf` (a facade of this build, with the
-         * semantics the document is read with).
-         */
-        previousJSON: (updates, facadeOf) => {
-            const doc = keepingReplaced(new Y.Doc());
-            try {
-                Y.transact(doc, () => {
-                    for (const u of updates)
-                        if (u instanceof Uint8Array)
-                            Y.applyUpdate(doc, u);
-                        else
-                            Y.applyUpdateV2(doc, u.v2);
-                });
-                const facade = facadeOf(doc);
-                try {
-                    return facade.toJSON();
-                }
-                finally {
-                    facade.dispose();
-                }
-            }
-            finally {
-                doc.destroy();
-            }
-        },
-        /**
-         * This generation's seed of `value` — the update a document seeds it
-         * with (deterministic: the same value writes the same update anywhere),
-         * read with `semantics`.
-         */
-        seedOf: (value, semantics) => {
-            const doc = keepingReplaced(new Y.Doc());
-            try {
-                const facade = facadeWith(semantics)(doc);
-                facade.seed(value.children, value.data);
-                facade.dispose();
-                return Y.encodeStateAsUpdate(doc);
-            }
-            finally {
-                doc.destroy();
-            }
-        },
-        /** {@link previousJSON} read with `semantics` (the bundled kinds' by default). */
-        previousJSONWith: (updates, semantics) => generations.previousJSON(updates, facadeWith(semantics))
-    };
-    return generations;
-};

package/dist/crdt/migration/legacy-schema.d.ts

@@ -1,61 +0,0 @@
-/**
- * Legacy (v13 Edytor) document reader.
- *
- * A v13 Edytor document is a `doc.getMap('content')` root whose attrs are
- * `{id:'root', type:'root', data, children: Y.Array<YMap>, content:
- * Y.Array<YText|YMap>}`; each block Y.Map carries `{type, id, data,
- * children, content}`; content arrays mix `Y.Text` parts (marks = format
- * attributes) and `Y.Map` inline atoms (`{id, type, data}`). A separate
- * `doc.getText('INITIALIZED')` root marks initialization.
- *
- * When those v1 updates are applied to the vendored v14 engine, every legacy
- * shared type decodes as a unified `Y.Node` with `_legacyTypeRef` recording
- * the original class:
- *
- * | v13 type  | `_legacyTypeRef` | read as                          |
- * | --------- | ---------------- | -------------------------------- |
- * | `Y.Array` | 0                | sequence children (`get`/`length`) |
- * | `Y.Map`   | 1                | attrs (`getAttr`/`attrKeys`)     |
- * | `Y.Text`  | 2                | delta children: `{insert, format}` |
- * | fragment  | 4                | root shared types                |
- *
- * Tombstoned content never appears — deleted blocks are absent from the
- * children sequence, deleted/format-removed text is absent from the delta —
- * so the materialized JSON is the logical doc exactly as a v13 reader saw
- * it (the same contract the v13 fixtures pin).
- */
-import type { EngineApi, EngineDoc } from '../engine-api.js';
-import { type JSONDoc } from '../../utils/json.js';
-/** v13 root key for the document tree. */
-export declare const LEGACY_ROOT_KEY = "content";
-/**
- * Raised when legacy update rows carry structs whose CRDT dependencies are
- * absent from the stored set — i.e. a peer's update never reached this
- * browser's IndexedDB before cutover. Applying such rows leaves
- * `store.pendingStructs`/`pendingDs` non-null and the materialized JSON
- * would silently omit the un-integrated content, so the reader fails closed
- * instead of producing a truncated document (gate-2 migration probe).
- */
-export declare class PendingLegacyUpdatesError extends Error {
-    /** Clients whose structs are still missing (`client → clock` needed). */
-    readonly missing: ReadonlyMap<number, number>;
-    constructor(missing: ReadonlyMap<number, number>, hasPendingDs: boolean);
-}
-/**
- * True iff the doc carries the v13 Edytor schema: a `content` root whose
- * `children` attr is a sequence node. Anything else (empty doc, v14 schema,
- * foreign document) is rejected by the migration path — it is not a legacy
- * document we know how to read.
- */
-export declare const isLegacyDoc: (doc: EngineDoc) => boolean;
-/**
- * Bind the legacy reader to the engine module. `readLegacyJSON(updates)`
- * applies the stored v1 update rows to a scratch doc (in order — pending
- * offline rows are simply later rows) and materializes the logical JSONDoc.
- * The scratch doc is discarded; nothing is written back to any store.
- */
-export declare const bindLegacyReader: (Y: EngineApi) => {
-    readLegacyJSON: (updates: Uint8Array[]) => JSONDoc;
-    readLegacyJSONFromDoc: (doc: EngineDoc) => JSONDoc;
-    isLegacyDoc: (doc: EngineDoc) => boolean;
-};

package/dist/crdt/migration/legacy-schema.js

@@ -1,151 +0,0 @@
-import { asEngineDoc } from '../structs.js';
-import { cloneJson } from '../../utils/json.js';
-// Legacy type refs (vendored `structs/Item.js` — not re-exported publicly).
-const Y_ARRAY_REF = 0;
-const Y_MAP_REF = 1;
-const Y_TEXT_REF = 2;
-/** v13 root key for the document tree. */
-export const LEGACY_ROOT_KEY = 'content';
-/**
- * Raised when legacy update rows carry structs whose CRDT dependencies are
- * absent from the stored set — i.e. a peer's update never reached this
- * browser's IndexedDB before cutover. Applying such rows leaves
- * `store.pendingStructs`/`pendingDs` non-null and the materialized JSON
- * would silently omit the un-integrated content, so the reader fails closed
- * instead of producing a truncated document (gate-2 migration probe).
- */
-export class PendingLegacyUpdatesError extends Error {
-    /** Clients whose structs are still missing (`client → clock` needed). */
-    missing;
-    constructor(missing, hasPendingDs) {
-        const clients = [...missing.keys()].join(', ');
-        super(`Legacy update rows have unmet CRDT dependencies (pending structs` +
-            `${clients.length > 0 ? ` waiting on client(s) ${clients}` : ''}` +
-            `${hasPendingDs ? ', pending delete set' : ''}). ` +
-            `Materializing now would silently drop content that has not integrated.`);
-        this.name = 'PendingLegacyUpdatesError';
-        this.missing = missing;
-    }
-}
-/**
- * True iff the doc carries the v13 Edytor schema: a `content` root whose
- * `children` attr is a sequence node. Anything else (empty doc, v14 schema,
- * foreign document) is rejected by the migration path — it is not a legacy
- * document we know how to read.
- */
-export const isLegacyDoc = (doc) => {
-    const root = doc.get(LEGACY_ROOT_KEY);
-    const children = root.getAttr('children');
-    return children != null && children._legacyTypeRef === Y_ARRAY_REF;
-};
-const readText = (node) => {
-    const out = [];
-    const children = node.delta?.toJSON?.()?.children;
-    for (const op of children ?? []) {
-        if (typeof op?.insert !== 'string')
-            continue;
-        if (op.insert.length === 0)
-            continue;
-        const t = { text: op.insert };
-        if (op.format && Object.keys(op.format).length > 0) {
-            t.marks = { ...op.format };
-        }
-        out.push(t);
-    }
-    return out;
-};
-const readInline = (node) => {
-    const inline = { type: String(node.getAttr('type') ?? 'inline') };
-    const id = node.getAttr('id');
-    if (id !== undefined)
-        inline.id = String(id);
-    const data = node.getAttr('data');
-    if (data != null && typeof data === 'object') {
-        inline.data = cloneJson(data);
-    }
-    return inline;
-};
-const readBlock = (node) => {
-    const block = { type: String(node.getAttr('type') ?? 'paragraph') };
-    const id = node.getAttr('id');
-    if (id !== undefined)
-        block.id = String(id);
-    const data = node.getAttr('data');
-    if (data != null && typeof data === 'object') {
-        block.data = cloneJson(data);
-    }
-    else {
-        block.data = {};
-    }
-    const content = node.getAttr('content');
-    if (content != null && content._legacyTypeRef === Y_ARRAY_REF) {
-        const items = [];
-        for (let i = 0; i < content.length; i++) {
-            const part = content.get(i);
-            if (part._legacyTypeRef === Y_TEXT_REF) {
-                items.push(...readText(part));
-            }
-            else if (part._legacyTypeRef === Y_MAP_REF) {
-                items.push(readInline(part));
-            }
-        }
-        if (items.length > 0)
-            block.content = items;
-    }
-    const children = node.getAttr('children');
-    if (children != null && children._legacyTypeRef === Y_ARRAY_REF && children.length > 0) {
-        const kids = [];
-        for (let i = 0; i < children.length; i++) {
-            kids.push(readBlock(children.get(i)));
-        }
-        block.children = kids;
-    }
-    return block;
-};
-/**
- * Bind the legacy reader to the engine module. `readLegacyJSON(updates)`
- * applies the stored v1 update rows to a scratch doc (in order — pending
- * offline rows are simply later rows) and materializes the logical JSONDoc.
- * The scratch doc is discarded; nothing is written back to any store.
- */
-export const bindLegacyReader = (Y) => {
-    /**
-     * Materialize the logical JSON of a legacy v13 document from its stored
-     * update rows. Throws when the decoded doc is not the v13 Edytor schema.
-     */
-    const readLegacyJSON = (updates) => {
-        const raw = new Y.Doc();
-        Y.transact(raw, () => {
-            for (const update of updates) {
-                Y.applyUpdate(raw, update);
-            }
-        });
-        const doc = asEngineDoc(raw);
-        // Fail closed on un-integratable rows: pendingStructs/pendingDs are
-        // non-null while CRDT dependencies are missing — the materialized
-        // JSON would silently omit that content (gate-2 migration probe).
-        const pending = doc.store?.pendingStructs ?? null;
-        const pendingDs = doc.store?.pendingDs ?? null;
-        if (pending !== null || pendingDs !== null) {
-            throw new PendingLegacyUpdatesError(pending?.missing ?? new Map(), pendingDs !== null);
-        }
-        return readLegacyJSONFromDoc(doc);
-    };
-    /**
-     * Materialize from an already-populated doc (e.g. one built by tests).
-     * Throws when the doc is not the v13 Edytor schema.
-     */
-    const readLegacyJSONFromDoc = (doc) => {
-        if (!isLegacyDoc(doc)) {
-            throw new Error('Not a legacy v13 Edytor document: missing `content` root with a sequence `children` attribute.');
-        }
-        const root = doc.get(LEGACY_ROOT_KEY);
-        const children = root.getAttr('children');
-        const out = [];
-        for (let i = 0; i < children.length; i++) {
-            out.push(readBlock(children.get(i)));
-        }
-        return { children: out };
-    };
-    return { readLegacyJSON, readLegacyJSONFromDoc, isLegacyDoc };
-};