edytor 1.0.0-rc.3 → 2.0.0

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,15 +1,13 @@
 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 DataPatch } from '../data.js';
 import { type JSONBlock } from '../../utils/json.js';
 import type { BlockRole, DataTarget, JsonObj, OrderPolicy } from './types.js';
 /** What every part of a document facade is built over: one doc, its engine layers, its index and its roles. */
 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. */
@@ -28,6 +26,12 @@ export declare const docReads: (c: DocBase) => {
     blockDataOf: (id: BlockId) => Record<string, unknown> | undefined;
     docData: () => JsonObj;
     dataItemIds: (target: DataTarget, path: readonly string[]) => string[];
+    dataPreview: (target: DataTarget, pending: readonly DataPatch[]) => {
+        data: {
+            [x: string]: unknown;
+        };
+        ids: (path: readonly string[]) => string[];
+    } | null;
     childrenIds: (parent: BlockId | null) => BlockId[];
     positionOf: (id: BlockId) => Destination | null;
     pathOf: (id: BlockId) => number[] | null;
@@ -48,7 +52,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 { itemIds, previewData, readData } from '../data.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
@@ -69,16 +69,25 @@ export const docReads = (c) => {
         const node = dataNode(id && ref(id), atom && ref(atom));
         return node && Array.isArray(path) ? itemIds(node, path) : [];
     };
+    /**
+     * A block's, an atom's or the document's data once `pending` patches are
+     * applied, without writing them, and its array items' ids (`previewData`):
+     * what a view reads of its data writes not yet dispatched.
+     */
+    const dataPreview = (target, pending) => {
+        const [id, atom] = typeof target === 'object' && target ? [target.block, target.atom] : [target ?? undefined];
+        return previewData(dataNode(id && ref(id), atom && ref(atom)), pending);
+    };
     /** 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 +139,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 +173,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 +195,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 +291,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 {
@@ -312,6 +311,7 @@ export const docReads = (c) => {
         blockDataOf,
         docData,
         dataItemIds,
+        dataPreview,
         childrenIds,
         positionOf,
         pathOf,
@@ -329,7 +329,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. */

package/dist/crdt/doc/steps.js

@@ -7,11 +7,11 @@
  */
 import { randOf } from '../rand.js';
 import { TYPE } from '../schema.js';
-import { promotedRank, sourceRank, SOURCE_SIDE } from '../placement/model.js';
-import { refused, effectOf } from './plan.js';
+import { blockNodeOf, positionInView, promotedRank, ranksAt, SOURCE_SIDE, sourceRank } from '../placement/model.js';
+import { REFUSED, effectOf } from './plan.js';
 /** The step writers of one facade. */
 export const planSteps = (c) => {
-    const { doc, M, runsView, roles, rendersContentOf, view, blockTypeOf, childrenIds, positionOf, ancestorsOf, is, isIsland, itemKindOf, isLayout, displayLength, contentItems, live, isContainer, fitted, emptiable, rendersContent, defaultChild } = c;
+    const { doc, runsView, roles, rendersContentOf, view, blockTypeOf, childrenIds, positionOf, ancestorsOf, is, isIsland, itemKindOf, isLayout, displayLength, contentItems, live, isContainer, fitted, emptiable, rendersContent, defaultChild } = c;
     // ── prepared ops ─────────────────────────────────────────────
     // Every op is `prepare` (pure: `refused`, or a plan of named steps plus
     // its effect summary, against the current version) then `apply(plan)`;
@@ -19,7 +19,6 @@ export const planSteps = (c) => {
     // whole command before any write and a refusal refuses before one.
     // Each prepare normalizes its inputs once, here at ingress: ids
     // and strings as the wire would deliver them, payloads cloned.
-    const REFUSED = refused(null);
     /** `exitRanks` parts, in their order at one block. */
     const [HEAD, KEPT, WITH, SELF, AFTER] = [0, 1, 2, 3, 5];
     const plan = (ids, writes) => ({
@@ -41,7 +40,7 @@ export const planSteps = (c) => {
         const all = v.kids.get(parent) ?? [];
         // The moving blocks' own slots left out: index → the list's index past them.
         const gone = exclude
-            .map((id) => M.positionInView(v, id))
+            .map((id) => positionInView(v, id))
             .filter((p) => p !== null && p.parent === parent)
             .map((p) => p.index)
             .sort((a, b) => a - b);
@@ -53,7 +52,7 @@ export const planSteps = (c) => {
         };
         const at = Math.max(0, Math.min(index, all.length - gone.length));
         const pair = [at > 0 ? all[raw(at - 1)] : undefined, all[raw(at)]];
-        return M.ranksAt(pair, 1, count, doc.clientID, randOf(doc), run);
+        return ranksAt(pair, 1, count, doc.clientID, randOf(doc), run);
     };
     /**
      * Move `ids` to `ranks` under `parent` (`index`: the slot hooks see).
@@ -146,7 +145,7 @@ export const planSteps = (c) => {
      * an outdent settles back to a paragraph is written back.
      */
     const attr = (id, key, value) => {
-        const same = M.blockNodeOf(doc, id).getAttr(key) === value;
+        const same = blockNodeOf(doc, id).getAttr(key) === value;
         if (same && (runsView.displayType(id) ?? value) === value)
             return [];
         return [{ op: 'setBlockType', id, type: value }];
@@ -334,6 +333,18 @@ export const planSteps = (c) => {
     const atomOf = (id, atom) => live(id) ? spans(id).find(({ item }) => item.kind === 'inline' && item.id === atom) : undefined;
     /** Text items overlapping `[at, end)` of `id` (inline atoms carry no marks). */
     const textIn = (id, at, end) => spans(id).flatMap((s) => (s.item.kind === 'text' && s.at < end && s.end > at ? [s.item] : []));
+    /** Push the steps writing `items` into `id` from `at` (text runs and atoms in order); the end offset. */
+    const writeContent = (writes, id, at, items = []) => {
+        for (const item of items) {
+            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;
+            }
+        }
+        return at;
+    };
     /** `writes`, then every container the `leaving` blocks leave with no child removed. */
     const emptied = (leaving, writes, kept) => emptyingAll(leaving.map((id) => positionOf(id).parent), leaving, writes, kept);
     return {
@@ -363,8 +374,8 @@ export const planSteps = (c) => {
         remove,
         merge,
         clamp,
-        spans,
         atomOf,
-        textIn
+        textIn,
+        writeContent
     };
 };

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

@@ -91,16 +91,6 @@ export type EdytorDocConfig = {
      * stay byte-identical to the unattributed schema.
      */
     actor?: () => AttributionActor | undefined;
-    /**
-     * Opt-in per-block lineage depth (`attribution.history`). `> 0` captures
-     * a subtree checkpoint just before a write displaces the block's current
-     * `lastChangedBy` owner — handoffs, deletes, and undo/redo touches —
-     * ring-trimmed to this many entries on the block's `b/<id>` record.
-     * `0`/absent disables the feature entirely: no captures, no list items,
-     * byte-identical writes. Requires `actor` — unattributed facades never
-     * capture.
-     */
-    lineageDepth?: number;
     /**
      * The document's `writable` guard — called at the write funnel;
      * throws while the document is read-only, so an edit is refused rather