edytor 1.0.0-rc.2 → 1.0.0

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

@@ -1,3 +1,4 @@
+import { type JSONBlock, type JSONInlineBlock, type JSONText } from '../../utils/json.js';
 import { type DataPatch } from '../data.js';
 import { type BlockId, type BlockSpec, type ContentItem } from '../placement/model.js';
 import type { Prepared, PlanStep, DataTarget } from './types.js';
@@ -6,14 +7,13 @@ import type { OpsContext } from './steps.js';
 export declare const metaOps: (c: OpsContext) => {
     dataSteps: (target: DataTarget, patches: DataPatch[]) => PlanStep[] | null;
     replaceData: (data: unknown) => DataPatch[];
-    leafSets: (data: unknown, current: unknown) => DataPatch[];
-    retypeSteps: (id: BlockId, type: string) => PlanStep[];
     setBlockType: (id: BlockId, type: string) => Prepared;
     patchData: (target: DataTarget, patches: readonly DataPatch[]) => Prepared;
     setBlock: (id: BlockId, value: {
         type?: string;
         data?: Record<string, unknown>;
-        content?: ContentItem[];
-        children?: BlockSpec[];
+        content?: (ContentItem | JSONText | JSONInlineBlock)[];
+        children?: (BlockSpec | JSONBlock)[];
     }) => Prepared;
 };
+export type MetaOps = ReturnType<typeof metaOps>;

package/dist/crdt/doc/meta.js

@@ -5,13 +5,13 @@
  */
 import { randOf } from '../rand.js';
 import { TYPE } from '../schema.js';
-import { sanitizeSpec, sanitizeWireJson } from '../../utils/json.js';
+import { asBlockSpec, asContentItem, sanitizeSpec, sanitizeWireJson } from '../../utils/json.js';
 import { patchWrites, leafKey, isObject } from '../data.js';
-import { promotedRank } from '../placement/model.js';
+import { collides, promotedRank, ranksAt } from '../placement/model.js';
 import { ref, refused, sanitizeItem } from './plan.js';
 /** The meta ops of one facade, prepared. */
 export const metaOps = (c) => {
-    const { doc, M, roles, roleOf, dataNode, view, blockTypeOf, blockDataOf, childrenIds, positionOf, is, isVoid, displayLength, live, contentTarget, REFUSED, plan, moveTo, attr, leavingIsland, settle, remove, atomOf } = c;
+    const { doc, roles, roleOf, dataNode, view, blockTypeOf, blockDataOf, childrenIds, positionOf, is, isVoid, displayLength, live, contentTarget, REFUSED, plan, moveTo, attr, leavingIsland, settle, remove, atomOf, writeContent } = c;
     /**
      * The data step of `patches` (sanitized) on a block, one of its atoms or
      * the document (`crdt/data.ts`): none when it changes nothing, `null`
@@ -52,11 +52,10 @@ export const metaOps = (c) => {
      */
     const leafSets = (data, current) => {
         const out = [];
-        const plainObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
         const walk = (v, at, path) => {
-            if (plainObject(v) && Object.keys(v).length > 0 && (path.length === 0 || plainObject(at)))
+            if (isObject(v) && Object.keys(v).length > 0 && (path.length === 0 || isObject(at)))
                 for (const [k, x] of Object.entries(v))
-                    walk(x, plainObject(at) ? at[k] : undefined, [...path, k]);
+                    walk(x, isObject(at) ? at[k] : undefined, [...path, k]);
             else if (path.length > 0)
                 out.push({ path, value: v });
         };
@@ -158,15 +157,15 @@ export const metaOps = (c) => {
      */
     const setBlock = (id, value) => {
         id = ref(id);
-        const content = value.content?.map(sanitizeItem);
-        const children = value.children?.map(sanitizeSpec);
+        const content = value.content?.map((item) => sanitizeItem(asContentItem(item)));
+        const children = value.children?.map((child) => sanitizeSpec(asBlockSpec(child)));
         if (!live(id) || (content !== undefined && !contentTarget(id)))
             return REFUSED;
         const type = value.type === undefined ? undefined : ref(value.type);
         const toVoid = type === undefined ? isVoid(id) : roles.childless(type);
         if (children?.length && toVoid)
             return REFUSED;
-        if (children !== undefined && M.collides(doc, children))
+        if (children !== undefined && collides(doc, children))
             return refused('id-collision');
         const data = value.data === undefined ? [] : dataSteps(id, leafSets(value.data, blockDataOf(id)));
         if (data === null)
@@ -183,21 +182,13 @@ export const metaOps = (c) => {
             const length = displayLength(id);
             if (length > 0)
                 writes.push({ op: 'deleteText', id, offset: 0, length });
-            let at = 0;
-            for (const item of content) {
-                if (item.kind === 'inline')
-                    writes.push({ op: 'insertInline', id, offset: at++, atom: item });
-                else if (item.text !== '') {
-                    writes.push({ op: 'insertText', id, offset: at, text: item.text, marks: item.marks });
-                    at += item.text.length;
-                }
-            }
+            writeContent(writes, id, 0, content);
         }
         if (children !== undefined) {
             for (const kid of childrenIds(id))
                 writes.push(remove(kid));
             // Every current child is deleted, so the new ones rank from an empty list.
-            const ranks = M.ranksAt([], 0, children.length, doc.clientID, randOf(doc));
+            const ranks = ranksAt([], 0, children.length, doc.clientID, randOf(doc));
             if (children.length > 0)
                 writes.push({ op: 'insertBlocks', parent: id, index: 0, specs: children, ranks });
         }
@@ -206,8 +197,6 @@ export const metaOps = (c) => {
     return {
         dataSteps,
         replaceData,
-        leafSets,
-        retypeSteps,
         setBlockType,
         patchData,
         setBlock

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

@@ -1,6 +1,6 @@
 import { type JSONBlock } from '../../utils/json.js';
-import type { BlockId, BlockSpec, Destination } from '../placement/model.js';
-import type { Prepared, PlanStep, Plan } from './types.js';
+import { type BlockId, type BlockSpec, type Destination } from '../placement/model.js';
+import type { Prepared } from './types.js';
 import type { OpsContext } from './steps.js';
 /** The moves ops of one facade, prepared. */
 export declare const moveOps: (c: OpsContext) => {
@@ -12,10 +12,10 @@ export declare const moveOps: (c: OpsContext) => {
         parent: string | null;
         levels: string[];
     };
-    splitOut: (ids: readonly BlockId[], levels: readonly BlockId[], specs: BlockSpec[], keep: boolean, retype?: readonly PlanStep[]) => Plan;
     liftOut: (id: BlockId, kind: string, { keep, after }?: {
         keep?: boolean;
         after?: readonly BlockSpec[];
     }) => Prepared;
-    duplicateBlock: (id: BlockId, freshId: (oldId: string, kind: "block" | "inline") => string) => Prepared;
+    duplicateBlock: (id: BlockId, freshId?: (oldId: string, kind: "block" | "inline") => string) => Prepared;
 };
+export type MoveOps = ReturnType<typeof moveOps>;

package/dist/crdt/doc/moves.js

@@ -5,10 +5,11 @@
  */
 import { id as newId } from '../../utils.js';
 import { asBlockSpec, sanitizeSpec } from '../../utils/json.js';
+import { collides } from '../placement/model.js';
 import { ref } from './plan.js';
 /** The moves ops of one facade, prepared. */
 export const moveOps = (c) => {
-    const { doc, M, blockTypeOf, blockDataOf, childrenIds, positionOf, isVoid, isIsland, isLine, contentItems, live, canPlace, isContainer, fits, kindToCopy, REFUSED, HEAD, KEPT, WITH, SELF, AFTER, plan, ranksFor, moveTo, move, exitRanks, leaving, settledKind, settle, landing, emptying, emptied } = c;
+    const { doc, blockTypeOf, blockDataOf, childrenIds, positionOf, isVoid, isIsland, isLine, contentItems, live, canPlace, isContainer, fits, kindToCopy, REFUSED, HEAD, KEPT, WITH, SELF, AFTER, plan, ranksFor, moveTo, move, exitRanks, leaving, settledKind, settle, landing, emptying, emptied } = c;
     /**
      * Insert blocks (specs may carry children/content/data; the batch is
      * all-or-nothing). A spec is a `BlockSpec` or the `JSONBlock` that
@@ -26,7 +27,7 @@ export const moveOps = (c) => {
             return REFUSED;
         if (clean.length === 0)
             return plan([], []);
-        if ((parent !== null && !live(parent)) || M.collides(doc, clean))
+        if ((parent !== null && !live(parent)) || collides(doc, clean))
             return REFUSED;
         const ranks = ranksFor(parent, dest.index, clean.length, [], true);
         return plan(clean.map((s) => s.id), [{ op: 'insertBlocks', parent, index: dest.index, specs: clean, ranks }]);
@@ -198,7 +199,7 @@ export const moveOps = (c) => {
         kind = ref(kind);
         const specs = after.map(sanitizeSpec);
         const { parent, levels } = landingOf(id, kind, keep);
-        if (!positionOf(id) || M.collides(doc, specs) || !canPlace([id], parent, () => kind))
+        if (!positionOf(id) || collides(doc, specs) || !canPlace([id], parent, () => kind))
             return REFUSED;
         return splitOut([id], levels, specs, keep);
     };
@@ -211,7 +212,7 @@ export const moveOps = (c) => {
      * minted; a block id it does not answer refuses the copy. `ids`: the
      * copy's root.
      */
-    const duplicateBlock = (id, freshId) => {
+    const duplicateBlock = (id, freshId = (_, kind) => newId(kind === 'block' ? 'b' : 'i')) => {
         id = ref(id);
         const pos = positionOf(id);
         if (pos === null)
@@ -247,7 +248,6 @@ export const moveOps = (c) => {
         unNestBlocks,
         unNestBlock,
         landingOf,
-        splitOut,
         liftOut,
         duplicateBlock
     };

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

@@ -11,6 +11,8 @@ export declare const EMPTY_IDS: readonly BlockId[];
 export type Refusal = null | string;
 export declare const NOOP: OpResult;
 export declare const refused: (reason: Refusal) => OpResult;
+/** A refusal that names no reason (one shared value). */
+export declare const REFUSED: OpResult;
 /** Each prepared op, applied: the op itself. */
 export type Applied<P> = {
     [K in keyof P]: P[K] extends (...args: infer A) => Prepared ? (...args: A) => OpResult : never;

package/dist/crdt/doc/plan.js

@@ -3,6 +3,8 @@ import { sanitizeWireJson, sanitizeWireString } from '../../utils/json.js';
 export const EMPTY_IDS = Object.freeze([]);
 export const NOOP = Object.freeze({ status: 'noop', ids: EMPTY_IDS });
 export const refused = (reason) => Object.freeze({ status: 'refused', ids: EMPTY_IDS, ...(reason !== null && { reason }) });
+/** A refusal that names no reason (one shared value). */
+export const REFUSED = refused(null);
 export const applied = (prepare, apply) => Object.fromEntries(Object.entries(prepare).map(([name, op]) => [name, (...args) => apply(op(...args))]));
 /** The effect summary of `writes`. */
 export const effectOf = (writes) => {

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

@@ -1,6 +1,5 @@
 import type { EngineApi, EngineDoc, EngineNode } from '../engine-api.js';
-import { type BlockId, type ContentItem, type Destination, type ModelView, type PlacementModel } from '../placement/model.js';
-import { type TextEngine } from '../text/model.js';
+import { type BlockId, type ContentItem, type Destination, type ModelView } from '../placement/model.js';
 import type { DisplayRoles, RunView } from '../text/runs.js';
 import { type JSONBlock } from '../../utils/json.js';
 import type { BlockRole, DataTarget, JsonObj, OrderPolicy } from './types.js';
@@ -8,8 +7,6 @@ import type { BlockRole, DataTarget, JsonObj, OrderPolicy } from './types.js';
 export type DocBase = {
     Y: EngineApi;
     doc: EngineDoc;
-    M: PlacementModel;
-    T: TextEngine;
     /** The doc's index (`text/runs.ts`): the one owner of derived state. */
     runsView: RunView;
     /** The role table the display and every guard ask of a block's shown kind. */
@@ -48,7 +45,6 @@ export declare const docReads: (c: DocBase) => {
     isLayoutItem: (id: BlockId) => boolean;
     holdsLayout: (id: BlockId) => boolean;
     insideItem: (id: BlockId, v?: ModelView) => boolean;
-    rowKindOf: (id: BlockId) => string | undefined;
     isTable: (id: BlockId) => boolean;
     isRowKind: (type: string | undefined) => boolean;
     isCellKind: (type: string | undefined) => boolean;

package/dist/crdt/doc/reads.js

@@ -6,28 +6,28 @@
  */
 import { DEV } from 'esm-env';
 import { DOC_DATA_ROOT, TYPE } from '../schema.js';
-import { displayParentOf, displaySlotOf, isLiveIn } from '../placement/model.js';
-import { DEAD, ownedLength } from '../text/model.js';
+import { blockNodeOf, displayParentOf, displaySlotOf, isLive, isLiveIn, positionInView, positionOf as modelPositionOf } from '../placement/model.js';
+import { DEAD, findAtom, ownedLength } from '../text/model.js';
 import { holdsPending } from '../structs.js';
 import { itemIds, readData } from '../data.js';
-import { unlistedOrder } from '../tables.js';
+import { columnIds, listedColumns, unlistedOrder } from '../tables.js';
 import { cloneJsonSafe } from '../../utils/json.js';
 import { ref } from './plan.js';
 /** The reads of the facade over `c.doc`. */
 export const docReads = (c) => {
-    const { doc, M, T, runsView, roles } = c;
+    const { doc, runsView, roles } = c;
     /** The node a data patch writes: block `id`, its atom `inlineId`, or the document's data root. */
     const dataNode = (id, inlineId) => id === undefined
         ? doc.get(DOC_DATA_ROOT)
         : inlineId === undefined
-            ? (M.blockNodeOf(doc, id) ?? undefined)
-            : T.findAtom(view().own, id, inlineId)?.node;
+            ? (blockNodeOf(doc, id) ?? undefined)
+            : findAtom(view().own, id, inlineId)?.node;
     /** The one serializer: `id`'s subtree in the public `JSONBlock` shape. */
     const blockJSON = (id) => {
         const type = blockTypeOf(id);
         // A registered block always has a type once its updates are all in:
         // `''` is the absent-id shape, or an out-of-order delivery's transient.
-        if (DEV && type === undefined && M.blockNodeOf(doc, id) !== null && !holdsPending(doc))
+        if (DEV && type === undefined && blockNodeOf(doc, id) !== null && !holdsPending(doc))
             throw new Error(`[edytor-doc] block ${id} has no type`);
         const block = {
             type: type ?? '',
@@ -46,11 +46,11 @@ export const docReads = (c) => {
     const view = () => runsView.view();
     // ── reads ────────────────────────────────────────────────────────
     const blockTypeOf = (id) => {
-        const t = runsView.displayType(id) ?? M.blockNodeOf(doc, id)?.getAttr(TYPE);
+        const t = runsView.displayType(id) ?? blockNodeOf(doc, id)?.getAttr(TYPE);
         return typeof t === 'string' ? t : undefined;
     };
     const blockDataOf = (id) => {
-        const node = M.blockNodeOf(doc, id);
+        const node = blockNodeOf(doc, id);
         const d = node && readData(node);
         // `cloneJsonSafe`: the read path stays total even when the stored
         // attr holds a non-JSON value that bypassed boundary validation
@@ -71,14 +71,14 @@ export const docReads = (c) => {
     };
     /** Ordered visible children of `parent` (`null` = root) — canonical read. */
     const childrenIds = (parent) => (view().kids.get(parent) ?? []).map((k) => k.id);
-    const positionOf = (id) => M.positionOf(doc, id);
+    const positionOf = (id) => modelPositionOf(doc, id);
     /** Index path from the root (`[i, j, …]`), or null when hidden/absent. */
     const pathOf = (id) => {
         const v = view();
         const path = [];
         let cur = id;
         while (cur !== null) {
-            const pos = M.positionInView(v, cur);
+            const pos = positionInView(v, cur);
             if (!pos)
                 return null;
             path.unshift(pos.index);
@@ -130,28 +130,29 @@ export const docReads = (c) => {
         const parent = positionOf(id)?.parent;
         return parent != null && isLines(parent);
     };
-    /** The item kind of `id` when it is a layout (its role says `layout`): its default child. */
-    const itemKindOf = (id) => {
+    /** The child kind `role` gives `id`'s kind: a layout's item kind, a table's row kind. */
+    const childKindOf = (role) => (id) => {
         const type = blockTypeOf(id);
-        return type === undefined ? undefined : roles.layout(type);
+        return type === undefined ? undefined : roles[role](type);
+    };
+    /** `id` is of its parent's `kindOf` kind, directly in it (a column, a row). */
+    const childOf = (kindOf) => (id) => {
+        const parent = positionOf(id)?.parent;
+        return parent != null && blockTypeOf(id) === kindOf(parent);
     };
+    /** The item kind of `id` when it is a layout (its role says `layout`): its default child. */
+    const itemKindOf = childKindOf('layout');
     /** `id` is a layout (`layout.*`). */
     const isLayout = (id) => itemKindOf(id) !== undefined;
     /** `id` is a layout item: of its layout's item kind, directly in it (a column). */
-    const isLayoutItem = (id) => {
-        const parent = positionOf(id)?.parent;
-        return parent != null && blockTypeOf(id) === itemKindOf(parent);
-    };
+    const isLayoutItem = childOf(itemKindOf);
     /** `id` is a layout or holds one in its shown subtree (`layout.nest`). */
     const holdsLayout = (id) => isLayout(id) || childrenIds(id).some(holdsLayout);
     /** `id` is a layout item or sits inside one. */
     const insideItem = (id, v) => [id, ...ancestorsOf(id, v)].some(isLayoutItem);
     // ── tables (`table.*`) ────────────────────────────────────────────
     /** The row kind of `id` when it is a table (its role says `table`): its default child. */
-    const rowKindOf = (id) => {
-        const type = blockTypeOf(id);
-        return type === undefined ? undefined : roles.table(type);
-    };
+    const rowKindOf = childKindOf('table');
     /** `id` is a table (`table.*`). */
     const isTable = (id) => rowKindOf(id) !== undefined;
     /** `type` is a row kind of a table kind the roles declare (`tableRow`). */
@@ -163,10 +164,7 @@ export const docReads = (c) => {
             return row !== undefined && roles.defaultChild(row) === type;
         });
     /** `id` is a table's row: of its table's row kind, directly in it. */
-    const isTableRow = (id) => {
-        const parent = positionOf(id)?.parent;
-        return parent != null && blockTypeOf(id) === rowKindOf(parent);
-    };
+    const isTableRow = childOf(rowKindOf);
     /** `id` is a table's cell: of its row's cell kind, directly in a row of a table. */
     const isTableCell = (id) => {
         const row = positionOf(id)?.parent;
@@ -188,20 +186,13 @@ export const docReads = (c) => {
      * (its cells show in their own order, `table.columns`).
      */
     const tableColumns = (table) => {
-        const columns = blockDataOf(table)?.columns;
-        if (!Array.isArray(columns))
-            return null;
-        const seen = new Set();
-        const out = [];
-        for (const c of columns) {
-            const id = c?.id;
-            if (typeof id !== 'string' || seen.has(id))
-                continue;
-            seen.add(id);
-            const width = c.width;
-            out.push(typeof width === 'number' && Number.isFinite(width) ? { id, width } : { id });
-        }
-        return out;
+        const data = blockDataOf(table);
+        const ids = columnIds(data);
+        return (ids &&
+            listedColumns(data).map((id) => {
+                const width = data.columns[ids.indexOf(id)].width;
+                return typeof width === 'number' && Number.isFinite(width) ? { id, width } : { id };
+            }));
     };
     /**
      * `table` as a grid (`table.pad`): its column ids in order and each shown
@@ -291,17 +282,16 @@ export const docReads = (c) => {
      * absent/deleted blocks. This is the transaction-aware counterpart
      * of the commit-synced {@link runsView} read surface.
      *
-     * The range reader emits BORROWED `marks`/`data` (cursor format
-     * state / the replicated inline attr) — every item's payload is
-     * swapped for the view's canonical frozen instance before it crosses
-     * the public boundary, so callers can't mutate engine state through
-     * the snapshot. Item wrappers and the array stay fresh and mutable.
+     * The items are the block's maintained runs: their payloads are the
+     * index's canonical frozen instances (`===` the ones `runs` publishes),
+     * so callers can't mutate engine state through the snapshot. Item
+     * wrappers and the array stay fresh and mutable.
      */
     const contentItems = (id) => runsView.contentItems(id);
     /** Registry membership — the block exists (may be delete-marked or merged away). */
-    const hasBlock = (id) => M.blockNodeOf(doc, id) !== null;
-    /** The one liveness answer (`M.isLive`): `id` renders in `project()`. O(depth). */
-    const live = (id) => M.isLive(doc, id);
+    const hasBlock = (id) => blockNodeOf(doc, id) !== null;
+    /** The one liveness answer (`isLive`): `id` renders in `project()`. O(depth). */
+    const live = (id) => isLive(doc, id);
     /** A live block that can hold content: it has a claims list (a streamless block gets its own text on first write). */
     const contentTarget = (id) => live(id) && view().blocks.get(id)?.claimsNode !== undefined;
     return {
@@ -329,7 +319,6 @@ export const docReads = (c) => {
         isLayoutItem,
         holdsLayout,
         insideItem,
-        rowKindOf,
         isTable,
         isRowKind,
         isCellKind,

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

@@ -19,20 +19,29 @@
  * Seeding is explicit: reads never create or normalize state.
  */
 import type { EngineApi, EngineDoc } from '../engine-api.js';
-import type { PlacementModel, BlockSpec } from '../placement/model.js';
+import { type BlockSpec } from '../placement/model.js';
 import type { BlockAttributionApi } from '../attribution/block.js';
 import type { JsonObj } from './types.js';
 import { type JSONBlock } from '../../utils/json.js';
 /** Origin of the seed update's apply — non-local, like any integrated update. */
 export declare const SEED_ORIGIN: unique symbol;
-/** The version record and seed writers over the bound engine layers. */
-export declare const bindSeed: (Y: EngineApi, M: PlacementModel, BA: BlockAttributionApi) => {
-    stamp: (doc: EngineDoc) => void;
-    restore: (doc: EngineDoc, content: BlockSpec[]) => void;
+/**
+ * Stamp the version record, absent only: never downgrade a higher
+ * version written by a newer peer — the version gate decides compatibility.
+ */
+export declare const stamp: (doc: EngineDoc) => void;
+/**
+ * Restore definition (migration only): stamp the version
+ * record (absent only) and make `content` the whole document under its
+ * own ids, rewritten in place where they exist (the model's
+ * `restoreBlocks`). Writes no attribution.
+ */
+export declare const restore: (doc: EngineDoc, content: BlockSpec[]) => void;
+/** The seed writers over the engine's block attribution. */
+export declare const bindSeed: (Y: EngineApi, BA: BlockAttributionApi) => {
     init: (doc: EngineDoc, opts?: {
         content?: BlockSpec[];
         defaultType?: string;
     }) => void;
-    seedUpdate: (value: JSONBlock[], defaultType?: string, data?: JsonObj) => Uint8Array;
     seed: (doc: EngineDoc, value?: JSONBlock[], defaultType?: string, data?: JsonObj) => void;
 };

package/dist/crdt/doc/seed.js

@@ -1,3 +1,4 @@
+import { insertBlock, insertBlocks, restoreBlocks } from '../placement/model.js';
 import { hash32, setDocRand } from '../rand.js';
 import { keepingReplaced } from '../incarnations.js';
 import { asEngineDoc, asYDoc } from '../structs.js';
@@ -7,29 +8,29 @@ import { jsonBlockToSpec, sanitizeSpec, sanitizeWireJson, sanitizeWireString } f
 import { isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION } from './gate.js';
 /** Origin of the seed update's apply — non-local, like any integrated update. */
 export const SEED_ORIGIN = Symbol('edytor:seed');
-/** The version record and seed writers over the bound engine layers. */
-export const bindSeed = (Y, M, BA) => {
-    /**
-     * Stamp the version record, absent only: never downgrade a higher
-     * version written by a newer peer — the version gate decides compatibility.
-     */
-    const stamp = (doc) => {
-        const meta = doc.get(META_KEY);
-        if (meta.getAttr(SCHEMA.metaAttrs.version) !== undefined)
-            return;
-        meta.setAttr(SCHEMA.metaAttrs.version, SCHEMA_VERSION);
-        meta.setAttr(SCHEMA.metaAttrs.schema, SCHEMA_NAME);
-    };
-    /**
-     * Restore definition (migration only): stamp the version
-     * record (absent only) and make `content` the whole document under its
-     * own ids, rewritten in place where they exist (the model's
-     * `restoreBlocks`). Writes no attribution.
-     */
-    const restore = (doc, content) => doc.transact(() => {
-        stamp(doc);
-        M.restoreBlocks(doc, content.map(sanitizeSpec));
-    });
+/**
+ * Stamp the version record, absent only: never downgrade a higher
+ * version written by a newer peer — the version gate decides compatibility.
+ */
+export const stamp = (doc) => {
+    const meta = doc.get(META_KEY);
+    if (meta.getAttr(SCHEMA.metaAttrs.version) !== undefined)
+        return;
+    meta.setAttr(SCHEMA.metaAttrs.version, SCHEMA_VERSION);
+    meta.setAttr(SCHEMA.metaAttrs.schema, SCHEMA_NAME);
+};
+/**
+ * Restore definition (migration only): stamp the version
+ * record (absent only) and make `content` the whole document under its
+ * own ids, rewritten in place where they exist (the model's
+ * `restoreBlocks`). Writes no attribution.
+ */
+export const restore = (doc, content) => doc.transact(() => {
+    stamp(doc);
+    restoreBlocks(doc, content.map(sanitizeSpec));
+});
+/** The seed writers over the engine's block attribution. */
+export const bindSeed = (Y, BA) => {
     /**
      * Stamp the version record (absent only) and, into an EMPTY registry,
      * bulk-insert `content` — the local materializer: the seed's scratch
@@ -48,12 +49,12 @@ export const bindSeed = (Y, M, BA) => {
                 return;
             // Bulk path: one sibling read + a local rank chain for the
             // whole batch. All-or-nothing: a dup spec id refuses the batch.
-            if (!M.insertBlocks(doc, { parent: null, index: Number.MAX_SAFE_INTEGER }, specs)) {
+            if (!insertBlocks(doc, { parent: null, index: Number.MAX_SAFE_INTEGER }, specs)) {
                 // Malformed initial content (e.g. a duplicated id) — fall back
                 // to per-spec insertion so valid blocks still load.
                 console.error('[edytor-doc] initial content refused by bulk insert; retrying per-spec (duplicate block ids are skipped)');
                 for (const spec of specs) {
-                    M.insertBlock(doc, { parent: null, index: Number.MAX_SAFE_INTEGER }, spec);
+                    insertBlock(doc, { parent: null, index: Number.MAX_SAFE_INTEGER }, spec);
                 }
             }
         });
@@ -105,5 +106,5 @@ export const bindSeed = (Y, M, BA) => {
     };
     /** Apply the deterministic seed of `value` with the non-local {@link SEED_ORIGIN}. */
     const seed = (doc, value = [], defaultType, data) => Y.applyUpdate(asYDoc(doc), seedUpdate(value, defaultType, data), SEED_ORIGIN);
-    return { stamp, restore, init, seedUpdate, seed };
+    return { init, seed };
 };

package/dist/crdt/doc/split-merge.d.ts

@@ -1,12 +1,10 @@
-import type { BlockId, SplitTail } from '../placement/model.js';
+import { type BlockId, type SplitTail } from '../placement/model.js';
 import type { Prepared } from './types.js';
 import type { OpsContext } from './steps.js';
 /** The split-merge ops of one facade, prepared. */
 export declare const splitMergeOps: (c: OpsContext) => {
     splitBlock: (id: BlockId, offset: number, newId: BlockId, tail?: SplitTail) => Prepared;
     mergeBlocks: (fromId: BlockId, intoId: BlockId) => Prepared;
-    mergeUnnesting: (from: BlockId, into: BlockId) => Prepared;
-    gone: (id: BlockId, container: BlockId) => Prepared;
     mergeBackward: (id: BlockId) => Prepared;
     mergeForward: (id: BlockId) => Prepared;
 };

package/dist/crdt/doc/split-merge.js

@@ -7,10 +7,11 @@
 import { isIncarnationId } from '../incarnations.js';
 import { sanitizeWireJson } from '../../utils/json.js';
 import { readData } from '../data.js';
+import { blockNodeOf, isSelfOrDescendant } from '../placement/model.js';
 import { ref } from './plan.js';
 /** The split-merge ops of one facade, prepared. */
 export const splitMergeOps = (c) => {
-    const { doc, M, view, childrenIds, positionOf, isVoid, isCellKind, blockTypeOf, insideIsland, isLayoutItem, next, previous, displayLength, contentTarget, isContainer, fits, canMerge, rendersContent, kindToCopy, REFUSED, plan, ranksFor, moveTo, move, pieceRanks, leaving, settledKind, settle, landing, emptying, emptied, merge, clamp } = c;
+    const { doc, view, childrenIds, positionOf, isVoid, isCellKind, blockTypeOf, insideIsland, isLayoutItem, next, previous, displayLength, contentTarget, isContainer, fits, canMerge, rendersContent, kindToCopy, REFUSED, plan, ranksFor, moveTo, move, pieceRanks, leaving, settledKind, settle, landing, emptying, emptied, merge, clamp } = c;
     /**
      * Split `id` at content `offset` into a new sibling `newId` (one boundary
      * item and the claims that follow it, no text copied; children follow).
@@ -30,7 +31,7 @@ export const splitMergeOps = (c) => {
         // A table's cell holds its lines as line breaks: it never splits (`table.split`).
         if (isCellKind(blockTypeOf(id)))
             return REFUSED;
-        if (isIncarnationId(born) || M.blockNodeOf(doc, born) !== null)
+        if (isIncarnationId(born) || blockNodeOf(doc, born) !== null)
             return REFUSED;
         const [at] = clamp(id, offset, 0);
         // An empty tail type is the one a view reads mid-retype: copy the kind.
@@ -69,7 +70,7 @@ export const splitMergeOps = (c) => {
         const v = view();
         if (!canMerge(from, into) || !contentTarget(into))
             return REFUSED;
-        if (M.isSelfOrDescendant(v.placements, v.own, into, from))
+        if (isSelfOrDescendant(v.placements, v.own, into, from))
             return REFUSED;
         const kids = childrenIds(from);
         const retype = settle(from, kids, into);
@@ -175,8 +176,6 @@ export const splitMergeOps = (c) => {
     return {
         splitBlock,
         mergeBlocks,
-        mergeUnnesting,
-        gone,
         mergeBackward,
         mergeForward
     };

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

@@ -1,5 +1,5 @@
 import { TYPE } from '../schema.js';
-import { type BlockId } from '../placement/model.js';
+import { type BlockId, type ContentItem } from '../placement/model.js';
 import type { Plan, PlanStep } from './types.js';
 import type { DocBase, DocReads } from './reads.js';
 import type { DocCapability } from './capability.js';
@@ -36,13 +36,8 @@ export declare const planSteps: (c: StepsContext) => {
     remove: (id: BlockId, kept?: readonly BlockId[]) => PlanStep;
     merge: (from: BlockId, into: BlockId) => PlanStep;
     clamp: (id: BlockId, offset: number, length: number) => [number, number];
-    spans: (id: BlockId) => {
-        item: import("../index.js").ContentItem;
-        at: number;
-        end: number;
-    }[];
     atomOf: (id: BlockId, atom: string) => {
-        item: import("../index.js").ContentItem;
+        item: ContentItem;
         at: number;
         end: number;
     } | undefined;
@@ -51,6 +46,7 @@ export declare const planSteps: (c: StepsContext) => {
         text: string;
         marks?: Record<string, unknown>;
     }[];
+    writeContent: (writes: PlanStep[], id: BlockId, at: number, items?: readonly ContentItem[]) => number;
 };
 export type PlanSteps = ReturnType<typeof planSteps>;
 /** What every op family is prepared over: the reads, the capability and the step writers. */