edytor 1.0.0-rc.2 → 1.0.0

package/dist/crdt/data.d.ts

@@ -21,15 +21,11 @@
  * Read rule: the leaves are read as a tree; a path with live items is an
  * array (sorted by rank, then id), one with keys an object (it beats a
  * primitive leaf at the same path: Ada sets `a = 1` while Bob sets
- * `a.b = 2`), else its leaf. The legacy whole `data` attr (documents
- * written before 0.1.0-next.6) is a base each leaf shadows at, above and
- * under its path; an array leaf with values (next.6's atomic arrays, and
- * every array of the attr) reads as items with ids and ranks derived from
- * the array (as any array assigned where no item is), so two replicas
- * exploding it write the same items. A patch
- * writes its leaves over the attr while it still reads right, else deletes
- * it and writes every leaf (residual: a peer's concurrent set of a key it
- * held, or its removal of an item, may then lose to the exploded value).
+ * `a.b = 2`), else its leaf. A leaf holding an object or an array (an
+ * atomic path's, `data.atomic`, or an array 0.1.0-next.6 wrote) reads as
+ * its keys or as items with ids and ranks derived from the array (as any
+ * array assigned where no item is), so two replicas writing into it write
+ * the same items; a patch opens it only along its path.
  */
 import type { EngineNode } from './engine-api.js';
 type JsonObj = Record<string, unknown>;
@@ -83,10 +79,9 @@ export declare const applyPatch: (data: JsonObj, patches: readonly DataPatch[])
  * The attr writes that give `node` the data `patches` make of its own (new
  * items get ids from `rand`, ranks from `client`), or `null` when a patch
  * fits no value there: only the leaves of the keys and items a patch
- * touches change, so a concurrent edit of another key or item is kept. A
- * legacy base (the attr, an atomic array leaf) stays under the leaves while
- * they still read as the patched value, else it is exploded: every leaf
- * written, the attr deleted. An unchanged value writes nothing.
+ * touches change, so a concurrent edit of another key or item is kept. An
+ * atomic path is written as one leaf and the leaves under it are deleted.
+ * An unchanged value writes nothing.
  */
 export declare const patchWrites: (node: EngineNode, patches: readonly DataPatch[], client?: number, rand?: () => number, atomic?: readonly string[]) => LeafWrite[] | null;
 /** Write `writes` on `node` (a detached one too: a block or atom being created). */

package/dist/crdt/data.js

@@ -1,4 +1,4 @@
-import { DATA, DATA_LEAF_PREFIX } from './schema.js';
+import { DATA_LEAF_PREFIX } from './schema.js';
 import { rankAfter } from './placement/rank.js';
 import { hash32 } from './rand.js';
 import { jsonEquals } from '../utils/json.js';
@@ -33,8 +33,21 @@ const itemsOf = (t) => {
 const isArr = (t) => Array.isArray(t.v) || itemsOf(t).length > 0;
 /** The item `seg` names among `items`: by its id (`~…`) or by its index. */
 const itemAt = (items, seg) => itemish(seg) ? items.find((i) => i.id === seg) : items[index(seg)];
-/** The JSON `t` reads as (`undefined` for nothing). */
+/** Whether `t` holds a non-empty object or array as one leaf (no subtree under it). */
+const closed = (t) => t.k.size === 0 && t.v !== null && typeof t.v === 'object' && Object.keys(t.v).length > 0;
+/** `t` with a container leaf's value as its subtree: its keys, or derived items. */
+const open = (t) => {
+    if (closed(t)) {
+        const value = t.v;
+        t.v = undefined;
+        derived.assign(t, value);
+    }
+    return t;
+};
+/** The JSON `t` reads as (`undefined` for nothing): a fresh value. */
 const valueOf = (t) => {
+    if (closed(t))
+        return valueOf(open(tree(t.v)));
     const items = itemsOf(t);
     if (items.length)
         return items.map(({ id }) => valueOf(t.k.get(id) ?? tree()) ?? null);
@@ -176,7 +189,7 @@ const edits = (rand, client = 0) => {
     };
     /** Make `t` read as `value`, writing only what differs: objects key by key, arrays item by item. */
     const assign = (t, value) => {
-        if (Array.isArray(value) && itemsOf(t).length)
+        if (Array.isArray(value) && itemsOf(open(t)).length)
             return arrange(t, value);
         // Anything else replaces what `t` held, but an object's equal keys.
         const object = isObject(value) && Object.keys(value).length > 0;
@@ -228,7 +241,7 @@ const edits = (rand, client = 0) => {
         for (const k of path) {
             if (!t)
                 return t;
-            if (isArr(t)) {
+            if (isArr(open(t))) {
                 const item = itemAt(itemsOf(t), k);
                 t = item && kid(t, item.id);
             }
@@ -239,7 +252,7 @@ const edits = (rand, client = 0) => {
                 t = kid(t, enc(segmentKey(k)));
             }
         }
-        return t;
+        return t && open(t);
     };
     /** Apply `patch` to `root`; `false` when it fits no value there. */
     const apply = (root, { path, value, splice, order }) => {
@@ -314,41 +327,6 @@ const leavesOfValue = (value, prefix = DATA_LEAF_PREFIX) => {
 };
 /** A new node's data, as leaves. */
 export const dataLeaves = (data) => leavesOfValue(isObject(data) ? data : {});
-/**
- * `leaves` over the bases they shadow (each leaf at, above and under its
- * path): the legacy attr, and each array leaf with values (as items).
- */
-const effective = (base, leaves) => {
-    /** `key` and the paths above it longer than `floor`. */
-    const above = (key, floor = 0) => {
-        const out = [];
-        for (let i = key.length; i > floor; i = key.lastIndexOf('/', i - 1))
-            out.push(key.slice(0, i));
-        return out;
-    };
-    const near = new Set([...leaves.keys()].flatMap((key) => above(key)));
-    const out = new Map();
-    const under = (prefix, value) => {
-        for (const [key, v] of leavesOfValue(value, prefix))
-            if (!near.has(key) && !above(key, prefix.length - 1).some((p) => leaves.has(p)))
-                out.set(key, v);
-    };
-    if (isObject(base))
-        under(DATA_LEAF_PREFIX, base);
-    for (const [key, v] of leaves) {
-        out.set(key, v);
-        if (Array.isArray(v) && v.length) {
-            under(`${key}/`, v);
-            out.set(key, []);
-        }
-        else if (isObject(v) && Object.keys(v).length) {
-            // An object written as one leaf (an atomic path, `data.atomic`) reads as its keys.
-            under(`${key}/`, v);
-            out.set(key, {});
-        }
-    }
-    return out;
-};
 /** A path of the data as a leaf key (`d/` and its pointer). */
 export const leafKey = (path) => DATA_LEAF_PREFIX + path.map((k) => enc(k)).join('/');
 /**
@@ -370,23 +348,22 @@ const collapse = (leaves, atomic) => {
     }
     return leavesFrom(root);
 };
-const read = (base, leaves) => valueOf(treeOf(effective(base, leaves)));
 /** `node`'s data (`undefined` when it has none). */
-export const readData = (node) => read(node.getAttr(DATA), leavesOf(node));
+export const readData = (node) => valueOf(treeOf(leavesOf(node)));
 /**
  * The ids of the items of the array at `path` (keys, item indexes or ids)
  * in `node`'s data, in order; `[]` where no array is.
  */
 export const itemIds = (node, path) => {
-    let t = treeOf(effective(node.getAttr(DATA), leavesOf(node)));
+    let t = treeOf(leavesOf(node));
     for (const k of path)
-        if (t && isArr(t)) {
+        if (t && isArr(open(t))) {
             const item = itemAt(itemsOf(t), k);
             t = item && t.k.get(item.id);
         }
         else
             t = itemish(k) ? undefined : t?.k.get(enc(segmentKey(k)));
-    return t ? itemsOf(t).map(({ id }) => id) : [];
+    return t ? itemsOf(open(t)).map(({ id }) => id) : [];
 };
 /** `data` with `patches` applied in order, as a fresh value (a root patch replaces it); `null` when one fits no value. */
 export const applyPatch = (data, patches) => {
@@ -399,40 +376,23 @@ export const applyPatch = (data, patches) => {
  * The attr writes that give `node` the data `patches` make of its own (new
  * items get ids from `rand`, ranks from `client`), or `null` when a patch
  * fits no value there: only the leaves of the keys and items a patch
- * touches change, so a concurrent edit of another key or item is kept. A
- * legacy base (the attr, an atomic array leaf) stays under the leaves while
- * they still read as the patched value, else it is exploded: every leaf
- * written, the attr deleted. An unchanged value writes nothing.
+ * touches change, so a concurrent edit of another key or item is kept. An
+ * atomic path is written as one leaf and the leaves under it are deleted.
+ * An unchanged value writes nothing.
  */
 export const patchWrites = (node, patches, client = 0, rand, atomic = []) => {
-    const [base, now] = [node.getAttr(DATA), leavesOf(node)];
-    const was = effective(base, now);
-    const root = treeOf(was);
+    const now = leavesOf(node);
+    const root = treeOf(now);
     const before = valueOf(root);
     const { apply } = edits(rand, client);
     if (!patches.every((p) => apply(root, p)))
         return null;
-    const value = valueOf(root);
-    if (jsonEquals(before, value))
+    if (jsonEquals(before, valueOf(root)))
         return [];
-    // An atomic path is written as one leaf, and every leaf stored under it goes.
     const want = collapse(leavesFrom(root), atomic);
-    const under = (key) => atomic.some((a) => key.startsWith(`${a}/`));
-    const diff = (from) => [...new Set([...from.keys(), ...want.keys()])]
-        .filter((key) => !jsonEquals(from.get(key), want.get(key)))
+    return [...new Set([...now.keys(), ...want.keys()])]
+        .filter((key) => !jsonEquals(now.get(key), want.get(key)))
         .map((key) => [key, want.get(key)]);
-    const own = [
-        ...diff(collapse(was, atomic)),
-        ...[...now.keys()]
-            .filter((key) => under(key) && !want.has(key))
-            .map((key) => [key, undefined])
-    ];
-    const after = new Map(now);
-    for (const [key, value] of own)
-        value === undefined ? after.delete(key) : after.set(key, value);
-    if (jsonEquals(read(base, after), value))
-        return own;
-    return [...(base === undefined ? [] : [[DATA, undefined]]), ...diff(now)];
 };
 /** Write `writes` on `node` (a detached one too: a block or atom being created). */
 export const writeLeaves = (node, writes) => {

package/dist/crdt/doc/anchors.js

@@ -4,11 +4,11 @@
  * resolved to the block that displays it now (`resolveAnchor`).
  */
 import { isLiveIn } from '../placement/model.js';
-import { DEAD, displayOf, locate, ownedLength } from '../text/model.js';
+import { anchorAt as textAnchorAt, DEAD, displayOf, locate, ownedLength, resolveAnchor as textResolveAnchor } from '../text/model.js';
 import { followRedone } from '../structs.js';
 /** The anchors of one facade. */
 export const docAnchors = (c) => {
-    const { Y, doc, T, view } = c;
+    const { Y, doc, view } = c;
     // ── anchors ─────────────────────────────────────────────────
     // An anchor is the home text id plus a relative position; the stream
     // containing the position says which block displays it. Both reads use
@@ -31,7 +31,7 @@ export const docAnchors = (c) => {
         const hit = locate(segs, Math.max(0, Math.min(offset, ownedLength(segs))), affinity);
         if (hit === null)
             return { b: blockId, a: { i: null, a: assoc } };
-        return { b: hit.seg.t, a: T.anchorAt(hit.seg.text, hit.idx, assoc) };
+        return { b: hit.seg.t, a: textAnchorAt(hit.seg.text, hit.idx, assoc) };
     };
     /**
      * `anchor` rebound to the copy this replica's last undo/redo
@@ -64,7 +64,7 @@ export const docAnchors = (c) => {
                 ? { blockId: anchor.b, offset: 0 }
                 : null;
         }
-        const i = T.resolveAnchor(doc, text, anchor.a);
+        const i = textResolveAnchor(doc, text, anchor.a);
         if (i === null)
             return null;
         const s = own.streamAt(anchor.b, i);

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

@@ -1,12 +1,16 @@
 import type { BlockId, InlineSpec } from '../placement/model.js';
 import type { Prepared } from './types.js';
 import type { OpsContext } from './steps.js';
+/** An inline atom to insert: its id is minted when it names none. */
+export type NewInline = Omit<InlineSpec, 'id'> & {
+    id?: string;
+};
 /** The content ops of one facade, prepared. */
 export declare const contentOps: (c: OpsContext) => {
     insertText: (id: BlockId, offset: number, text: string, marks?: Record<string, unknown>) => Prepared;
     deleteText: (id: BlockId, offset: number, length: number) => Prepared;
     formatRange: (id: BlockId, offset: number, length: number, marks: Record<string, unknown>) => Prepared;
     clearMarks: (id: BlockId, offset: number, length: number) => Prepared;
-    insertInline: (id: BlockId, offset: number, atom: InlineSpec) => Prepared;
+    insertInline: (id: BlockId, offset: number, atom: NewInline) => Prepared;
     removeInline: (id: BlockId, inlineId: string) => Prepared;
 };

package/dist/crdt/doc/content.js

@@ -3,6 +3,7 @@
  * inside voids — the caption contract), and marks over a range.
  */
 import { sanitizeWireJson, jsonEquals } from '../../utils/json.js';
+import { id as newId } from '../../utils.js';
 import { ref, sanitizeInline } from './plan.js';
 /** The content ops of one facade, prepared. */
 export const contentOps = (c) => {
@@ -50,9 +51,10 @@ export const contentOps = (c) => {
         }
         return formatRange(id, offset, length, clears);
     };
+    /** An atom without an id gets a fresh one. */
     const insertInline = (id, offset, atom) => {
         id = ref(id);
-        const clean = sanitizeInline(atom);
+        const clean = sanitizeInline({ ...atom, id: atom.id ?? newId('i') });
         if (!contentTarget(id))
             return REFUSED;
         return plan([id], [{ op: 'insertInline', id, offset: clamp(id, offset, 0)[0], atom: clean }]);

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

@@ -12,3 +12,4 @@ export declare const deleteOps: (c: OpsContext) => {
         keepChildren?: boolean;
     }) => Prepared;
 };
+export type DeleteOps = ReturnType<typeof deleteOps>;

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

@@ -1,13 +1,4 @@
-/**
- * The write funnel: every facade write goes through `write` (disposal and the
- * document's writable guard), and every prepared plan through `apply` — one
- * transaction, its result read from what the transaction wrote, and the
- * frame's one attribution and lineage pass.
- */
-import type { BlockId } from '../placement/model.js';
 import type { BlockAttributionApi } from '../attribution/block.js';
-import type { AttributionActor } from '../attribution/index.js';
-import type { JSONBlock } from '../../utils/json.js';
 import type { EdytorDocConfig, OpResult, Prepared } from './types.js';
 import type { DocBase, DocReads } from './reads.js';
 /**
@@ -20,12 +11,6 @@ import type { DocBase, DocReads } from './reads.js';
 export declare class EdytorDocDisposedError extends Error {
     constructor(service?: string);
 }
-/**
- * The lineage ring depth, validated — `NaN`/`Infinity`/fractional/negative
- * values would silently disable the ring's trim bound. The one check every
- * entry path (facade creation, document attach and reattach) runs.
- */
-export declare const lineageDepthOf: (depth: number | undefined) => number;
 /** What the write funnel writes with: the reads, the attribution writer and the facade's configuration. */
 export type FunnelContext = DocBase & DocReads & {
     BA: BlockAttributionApi;
@@ -35,14 +20,6 @@ export type FunnelContext = DocBase & DocReads & {
 export declare const writeFunnel: (c: FunnelContext) => {
     write: <R>(fn: () => R) => R;
     apply: (p: Prepared) => OpResult;
-    actorOf: () => AttributionActor | undefined;
-    lineageDepth: number;
-    lineagePending: (id: BlockId, force?: boolean) => {
-        a?: string;
-        by: string;
-        t: number;
-        j: JSONBlock;
-    } | undefined;
     /** Disposal is terminal for writes. */
     dispose: () => void;
     disposed: () => boolean;

package/dist/crdt/doc/funnel.js

@@ -1,7 +1,15 @@
+/**
+ * The write funnel: every facade write goes through `write` (disposal and the
+ * document's writable guard), and every prepared plan through `apply` — one
+ * transaction, its result read from what the transaction wrote, and the
+ * frame's one attribution pass.
+ */
+import { blockNodeOf, buildInline, materializeSpec, ownText, view as modelView, writePlacement, writeSplit } from '../placement/model.js';
 import { ENTRY_FACET } from '../text/runs.js';
 import { AT, DEL_PREFIX, ID, LAST_CHANGED_ATTR, TYPE } from '../schema.js';
 import { writeLeaves } from '../data.js';
 import { NOOP } from './plan.js';
+import { claimInto, deleteRange, formatRangeIn, insertIntoText } from '../text/model.js';
 /**
  * Raised when a mutating facade op runs after `dispose()` — disposal is
  * terminal for writes (reads stay dead-safe: a stale handle may still be
@@ -15,21 +23,9 @@ export class EdytorDocDisposedError extends Error {
         this.name = 'EdytorDocDisposedError';
     }
 }
-/**
- * The lineage ring depth, validated — `NaN`/`Infinity`/fractional/negative
- * values would silently disable the ring's trim bound. The one check every
- * entry path (facade creation, document attach and reattach) runs.
- */
-export const lineageDepthOf = (depth) => {
-    const d = depth ?? 0;
-    if (!Number.isInteger(d) || d < 0) {
-        throw new RangeError(`lineage.depth must be a non-negative integer, got ${JSON.stringify(d)}`);
-    }
-    return d;
-};
 /** The write funnel of one facade. */
 export const writeFunnel = (c) => {
-    const { doc, M, T, runsView, dataNode, blockJSON, BA, config } = c;
+    const { doc, runsView, dataNode, BA, config } = c;
     /**
      * Terminal flag — set by `dispose()`. Mutating ops funnel through
      * `write`, so gating there covers every facade write + `transact` +
@@ -56,39 +52,14 @@ export const writeFunnel = (c) => {
     // is observed, never predicted.
     //
     // Each apply opens a frame that tracks the index's folds. When it
-    // closes, ONE pass over the facets the fold saw stamps attribution and
-    // commits lineage: a block whose registry entry was created gets
-    // its `createdBy` record; a block whose content, claims, type or data
+    // closes, ONE pass over the facets the fold saw stamps attribution: a
+    // block whose registry entry was created gets its `createdBy` record; a block whose content, claims, type or data
     // changed gets a contributor stamp; moves and delete marks stamp
     // nothing. Two intents the effects cannot name are recorded by their
     // steps: a split-born block inherits its source's contributors, and a
-    // merge survivor unions the absorbed block's. Lineage is captured
-    // before the first write for each target a step names, and committed
-    // only for targets the effects show changed, deleted or absorbed. With
-    // no configured `actor` the funnel writes no attribution at all.
+    // merge survivor unions the absorbed block's. With no configured
+    // `actor` the funnel writes no attribution at all.
     const actorOf = () => config.actor?.();
-    const lineageDepth = lineageDepthOf(config.lineageDepth);
-    /**
-     * Capture `id`'s displaced state when the current actor is NOT the `l`
-     * winner (`force`: destructive paths, where the state is lost whoever
-     * owns `l`). First capture in a frame wins — it is the pre-frame state.
-     */
-    const lineagePending = (id, force = false) => {
-        const actor = actorOf();
-        const node = M.blockNodeOf(doc, id);
-        if (lineageDepth <= 0 || actor === undefined || node === null)
-            return undefined;
-        const l = node.getAttr(LAST_CHANGED_ATTR);
-        if (!force && l === actor.id)
-            return undefined;
-        const j = blockJSON(id);
-        return { ...(typeof l === 'string' ? { a: l } : {}), by: actor.id, t: Date.now(), j };
-    };
-    const capture = (f, id, force = false) => {
-        const pending = f.lineage.has(id) ? undefined : lineagePending(id, force);
-        if (pending !== undefined)
-            f.lineage.set(id, pending);
-    };
     /** The frame's one attribution pass over the facets the fold saw it write. */
     const close = (f, folded) => {
         const actor = actorOf();
@@ -96,79 +67,72 @@ export const writeFunnel = (c) => {
             return;
         const created = new Set();
         const changed = new Set();
-        const gone = new Set(f.unions.map(([, from]) => from));
         for (const [id, facets] of folded.touched) {
-            if (facets.has(ENTRY_FACET) && M.blockNodeOf(doc, id) !== null)
+            if (facets.has(ENTRY_FACET) && blockNodeOf(doc, id) !== null)
                 created.add(id);
             else
-                for (const facet of facets) {
-                    if (facet.startsWith(DEL_PREFIX))
-                        gone.add(id);
-                    else if (![ENTRY_FACET, AT, ID, LAST_CHANGED_ATTR].includes(facet))
+                for (const facet of facets)
+                    if (!facet.startsWith(DEL_PREFIX) &&
+                        ![ENTRY_FACET, AT, ID, LAST_CHANGED_ATTR].includes(facet))
                         changed.add(id);
-                }
         }
         for (const id of created) {
-            const node = M.blockNodeOf(doc, id);
+            const node = blockNodeOf(doc, id);
             if (node !== null)
                 BA.stampCreated(doc, node, id, actor.id, f.inherit.get(id));
         }
         for (const id of changed) {
-            const node = created.has(id) ? null : M.blockNodeOf(doc, id);
+            const node = created.has(id) ? null : blockNodeOf(doc, id);
             if (node !== null)
                 BA.stampChange(doc, node, id, actor.id);
         }
         for (const [into, from] of f.unions)
             BA.unionContributors(doc, into, from);
-        for (const [id, pending] of f.lineage) {
-            if (changed.has(id) || gone.has(id))
-                BA.appendLineage(doc, id, pending, lineageDepth);
-        }
     };
     /**
      * A streamless block gets its own text before the first write that
-     * needs a stream (`M.ownText`: a writer derived from its dead
+     * needs a stream (`ownText`: a writer derived from its dead
      * incarnation); its attribution record follows the re-minted nonce.
      */
     const needStream = (id) => {
-        if ((M.view(doc).own.display(id) ?? []).length > 0)
+        if ((modelView(doc).own.display(id) ?? []).length > 0)
             return;
-        const { from, to } = M.ownText(doc, id);
+        const { from, to } = ownText(doc, id);
         BA.retarget(doc, id, from, to);
     };
     /** One planned step, written (the plan decided it; writers never refuse). */
     const writeStep = (w, f) => {
         // Structural steps need no view: delete marks and placements write one node.
         if (w.op === 'deleteBlock')
-            return w.marks.forEach((id) => M.blockNodeOf(doc, id).setAttr(DEL_PREFIX + doc.clientID, true));
+            return w.marks.forEach((id) => blockNodeOf(doc, id).setAttr(DEL_PREFIX + doc.clientID, true));
         if (w.op === 'splitBlock' || w.op === 'insertText' || w.op === 'insertInline')
             needStream(w.id);
-        const { blocks, own } = M.view(doc);
-        const node = (id) => M.blockNodeOf(doc, id);
+        const { blocks, own } = modelView(doc);
+        const node = (id) => blockNodeOf(doc, id);
         switch (w.op) {
             case 'insertBlocks':
-                return w.specs.forEach((sp, i) => M.materializeSpec(doc, sp, w.parent, w.ranks[i]));
+                return w.specs.forEach((sp, i) => materializeSpec(doc, sp, w.parent, w.ranks[i]));
             case 'moveBlocks':
-                return w.ids.forEach((id, i) => M.writePlacement(doc, node(id), w.parent, w.ranks[i]));
+                return w.ids.forEach((id, i) => writePlacement(doc, node(id), w.parent, w.ranks[i]));
             case 'splitBlock':
                 f.inherit.set(w.newId, w.id);
-                return M.writeSplit(doc, w.id, w.offset, w.newId, w.tail, { p: w.parent, r: w.rank });
+                return writeSplit(doc, w.id, w.offset, w.newId, w.tail, { p: w.parent, r: w.rank });
             case 'mergeBlocks':
                 f.unions.push([w.into, w.from]);
-                return T.claimInto(blocks, own, w.from, w.into);
+                return claimInto(blocks, own, w.from, w.into);
             case 'setBlockType':
                 return void node(w.id).setAttr(TYPE, w.type);
             case 'patchData':
                 return writeLeaves(dataNode(w.id, w.inlineId), w.leaves);
             case 'insertText':
-                return T.insertIntoText(doc, blocks, own, w.id, w.offset, w.text, w.marks);
+                return insertIntoText(doc, blocks, own, w.id, w.offset, w.text, w.marks);
             case 'insertInline':
-                return T.insertIntoText(doc, blocks, own, w.id, w.offset, M.buildInline(w.atom));
+                return insertIntoText(doc, blocks, own, w.id, w.offset, buildInline(w.atom));
             case 'deleteText':
             case 'removeInline':
-                return T.deleteRange(doc, blocks, own, w.id, w.offset, 'length' in w ? w.length : 1);
+                return deleteRange(doc, blocks, own, w.id, w.offset, 'length' in w ? w.length : 1);
             case 'formatRange':
-                return T.formatRangeIn(doc, blocks, own, w.id, w.offset, w.length, w.marks);
+                return formatRangeIn(doc, blocks, own, w.id, w.offset, w.length, w.marks);
         }
     };
     /**
@@ -185,20 +149,8 @@ export const writeFunnel = (c) => {
         }
         return write(() => doc.transact(() => {
             const frame = runsView.track();
-            const f = { lineage: new Map(), inherit: new Map(), unions: [] };
+            const f = { inherit: new Map(), unions: [] };
             try {
-                // Lineage captures every target's pre-write state before the
-                // first write; destructive steps capture whoever owns `l`.
-                for (const w of p.writes) {
-                    if (w.op === 'deleteBlock')
-                        capture(f, w.id, true);
-                    else if (w.op === 'mergeBlocks') {
-                        capture(f, w.from, true);
-                        capture(f, w.into);
-                    }
-                    else if ('id' in w && w.id !== undefined)
-                        capture(f, w.id);
-                }
                 for (const w of p.writes)
                     writeStep(w, f);
             }
@@ -215,9 +167,6 @@ export const writeFunnel = (c) => {
     return {
         write,
         apply,
-        actorOf,
-        lineageDepth,
-        lineagePending,
         /** Disposal is terminal for writes. */
         dispose: () => {
             disposed = true;

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

@@ -25,7 +25,7 @@
  * ```
  */
 import type { EngineDoc } from '../engine-api.js';
-export declare const SCHEMA_VERSION: 5;
+export declare const SCHEMA_VERSION: 6;
 export declare const SCHEMA_NAME: "edytor-doc";
 export declare const META_KEY: "meta";
 /**
@@ -87,20 +87,19 @@ export declare class SchemaMismatchError extends Error {
  */
 export declare const assertSchema: (doc: EngineDoc, docName?: string) => void;
 /**
- * Error raised by {@link assertUsableDoc} — the doc cannot host a v14 facade.
- * `kind` distinguishes a foreign engine object (a real v13 `yjs` Doc — a
- * different CRDT implementation entirely) from a v14 doc that decodes the
- * legacy v13 Edytor schema (applied v13 update rows awaiting migration).
+ * Error raised by {@link assertUsableDoc} — the doc cannot host a v14 facade:
+ * a foreign engine object (a v13 `yjs` Doc — a different CRDT implementation
+ * entirely).
  */
 export declare class UnsupportedDocError extends Error {
-    readonly kind: 'foreign' | 'legacy';
-    constructor(kind: 'foreign' | 'legacy');
+    readonly kind: 'foreign';
+    constructor(kind: 'foreign');
 }
 /**
  * Document-boundary guard run by {@link EdytorDocBinding.create} before the
  * runs view attaches. The facade only speaks the v14 unified-node surface —
  * without this gate a foreign doc dies obscurely inside `buildView`
- * (`registry.forEachAttr is not a function`), and a legacy-schema doc would be
- * silently misread. Both fail fast with an actionable error instead.
+ * (`registry.forEachAttr is not a function`); it fails fast with an
+ * actionable error instead.
  */
 export declare const assertUsableDoc: (doc: EngineDoc) => void;

package/dist/crdt/doc/gate.js

@@ -1,5 +1,4 @@
 import { isNodeLike, SCHEMA } from '../schema.js';
-import { isLegacyDoc } from '../migration/legacy-schema.js';
 export const SCHEMA_VERSION = SCHEMA.version;
 export const SCHEMA_NAME = SCHEMA.name;
 export const META_KEY = SCHEMA.roots.meta;
@@ -75,21 +74,15 @@ export const assertSchema = (doc, docName = 'doc') => {
         throw new SchemaMismatchError(docName, problem);
 };
 /**
- * Error raised by {@link assertUsableDoc} — the doc cannot host a v14 facade.
- * `kind` distinguishes a foreign engine object (a real v13 `yjs` Doc — a
- * different CRDT implementation entirely) from a v14 doc that decodes the
- * legacy v13 Edytor schema (applied v13 update rows awaiting migration).
+ * Error raised by {@link assertUsableDoc} — the doc cannot host a v14 facade:
+ * a foreign engine object (a v13 `yjs` Doc — a different CRDT implementation
+ * entirely).
  */
 export class UnsupportedDocError extends Error {
     kind;
     constructor(kind) {
-        super(kind === 'legacy'
-            ? 'Document carries the legacy v13 Edytor schema (`content` root) — ' +
-                'migrate it via `crdt.migration` before attaching an editor.'
-            : 'Document is not a v14 engine doc — the `blocks` registry is not a ' +
-                'unified Y.Node. Use `crdt.createDoc()` (or `new Y.Doc()` from ' +
-                '`edytor/crdt`); a v13 `yjs` Doc must be migrated via ' +
-                '`crdt.migration` (from its stored updates), not passed to the runtime.');
+        super('Document is not a v14 engine doc — the `blocks` registry is not a ' +
+            'unified Y.Node. Use `crdt.createDoc()` (or `new Y.Doc()` from `edytor/crdt`).');
         this.kind = kind;
         this.name = 'UnsupportedDocError';
     }
@@ -98,8 +91,8 @@ export class UnsupportedDocError extends Error {
  * Document-boundary guard run by {@link EdytorDocBinding.create} before the
  * runs view attaches. The facade only speaks the v14 unified-node surface —
  * without this gate a foreign doc dies obscurely inside `buildView`
- * (`registry.forEachAttr is not a function`), and a legacy-schema doc would be
- * silently misread. Both fail fast with an actionable error instead.
+ * (`registry.forEachAttr is not a function`); it fails fast with an
+ * actionable error instead.
  */
 export const assertUsableDoc = (doc) => {
     let registry;
@@ -112,7 +105,4 @@ export const assertUsableDoc = (doc) => {
     if (!isNodeLike(registry) || typeof registry.forEachAttr !== 'function') {
         throw new UnsupportedDocError('foreign');
     }
-    if (isLegacyDoc(doc)) {
-        throw new UnsupportedDocError('legacy');
-    }
 };