edytor 0.0.11 → 0.1.0-next.16

package/dist/block/block.utils.js

@@ -1,499 +1,366 @@
-import { Block } from './block.svelte.js';
-import { Text } from '../text/text.svelte.js';
-import { prevent } from '../utils.js';
+import { id } from '../utils.js';
+import { cloneJson, jsonBlockToSpec, jsonContentToItems } from '../utils/json.js';
 import { InlineBlock } from './inlineBlock.svelte.js';
-import * as Y from 'yjs';
-export function batch(operation, func) {
-    return function (payload) {
-        let finalPayload = payload;
-        for (const plugin of this.edytor.plugins) {
-            // @ts-expect-error
-            const normalizedPayload = plugin.onBeforeOperation?.({
-                operation,
-                payload,
-                block: this,
-                prevent
-            });
-            if (normalizedPayload) {
-                finalPayload = normalizedPayload;
-                break;
-            }
-        }
-        const result = this.edytor.transact(() => func.bind(this)(finalPayload));
-        for (const plugin of this.edytor.plugins) {
-            plugin.onAfterOperation?.({
-                operation,
-                payload,
-                block: this
-            });
-        }
-        return result;
+/**
+ * Bind an operation onto its wrapper: every call is dispatched as a command
+ * (`session/commands.ts`): admission, hooks before any write (on the command
+ * and, when `prepare` answers one document plan, on each planned step), one
+ * transaction, normalization, the result. `func` receives the prepared plan
+ * and answers the op's document result; `resolve` turns it into wrappers
+ * after the commit patched them.
+ */
+export function batch(operation, func, prepare, resolve) {
+    return function (...[payload]) {
+        const out = this.edytor.dispatcher.dispatch(operation, payload, { block: this }, (p, plan) => func.call(this, p, plan), prepare && ((p) => prepare.call(this, p)));
+        return resolve ? resolve.call(this, out, payload) : out;
     };
 }
-export function addChildBlock({ block, index = this.yChildren.length }) {
-    const newBlock = new Block({ parent: this, edytor: this.edytor, block });
-    this.yChildren.insert(index, [newBlock.yBlock]);
-    return newBlock;
+/**
+ * The handle of block `id` (null: refused at preparation, or gone; undefined:
+ * the command did not run). Inside an outer transaction too: the index shows
+ * the block that transaction created.
+ */
+export function blockOf(id) {
+    return id === undefined ? undefined : (id && this.edytor.idToBlock.get(id)) || null;
 }
-export function addChildBlocks({ blocks, index = this.yChildren.length }) {
-    const newBlocks = blocks.map((block) => new Block({ parent: this, edytor: this.edytor, block }));
-    this.yChildren.insert(index, newBlocks.map((block) => block.yBlock));
-    return newBlocks;
-}
-export function insertBlockAfter({ block }) {
-    if (!this.parent) {
+const REFUSED = { status: 'refused', ids: [] };
+/**
+ * An op's body over its prepared plan: write it and request normalization of
+ * the blocks it touched (captured before the write). Answers the applied
+ * plan, or null when it was refused.
+ */
+const applyPlan = (block, plan, touched) => {
+    if (!('writes' in plan))
         return null;
-    }
-    this.yChildren.delete(0, this.children.length);
-    return this.parent.addChildBlock({
-        block: {
-            ...block,
-            children: this.value.children
-        },
-        index: this.index + 1
-    });
+    block.edytor.facade.apply(plan);
+    for (const parent of touched)
+        parent?.normalizeChildren();
+    return plan;
+};
+/** The document's name for `block`'s child list: `null` for the root. */
+const ref = (block) => (block.isRoot ? null : block.id);
+/**
+ * Dispatch `operation` on `block` as the one plan `prepare` answers (a
+ * composed command: hooks see it and each planned step, one transaction).
+ * `then` runs in that transaction once the plan applied, with the payload
+ * hooks left. Answers the applied plan, or null when refused.
+ */
+export const dispatchPlan = (block, operation, payload, prepare, touched = [block.parent], then) => block.edytor.dispatcher.dispatch(operation, payload, { block }, (p, plan = prepare(p)) => {
+    const applied = applyPlan(block, plan, touched);
+    if (applied)
+        then?.(p);
+    return applied;
+}, prepare) ?? null;
+/** One child at `index` (a default-kind block without `block`); see {@link addChildBlocks}. */
+export function addChildBlock({ block, index }) {
+    const blocks = [block || { type: this.edytor.defaultChild(this) }];
+    return addChildBlocks.call(this, { blocks, index })[0];
 }
-export function insertBlockBefore({ block }) {
-    if (!this.parent) {
-        return null;
-    }
-    return this.parent.addChildBlock({
-        block: {
-            ...block,
-            children: this.value.children
-        },
-        index: this.index
-    });
+/** Children at `index`, clamped to the child list (at its end by default); ids kept or minted. */
+export function addChildBlocks({ blocks, index = this.children.length }) {
+    index = Math.max(0, Math.min(index, this.children.length));
+    const specs = blocks.map((block) => ({ ...block, id: block.id ?? id('b') }));
+    this.insertChildren(index, specs);
+    this.normalizeChildren();
+    return specs.map((spec) => this.edytor.idToBlock.block(spec.id));
 }
-export function splitBlock({ index, text }) {
-    if (!text || !this.parent) {
-        return null;
-    }
-    const splittedContent = text.splitText({ index });
-    const indexOfContent = this.content.indexOf(text);
-    const remainingContent = this.content.slice(indexOfContent + 1).map((part) => part.value);
-    const content = [splittedContent, ...remainingContent].flat();
-    const hasChildren = this.children.length >= 1;
-    // Add the current children to the new block if any
-    this.yContent.delete(indexOfContent + 1, this.content.length - indexOfContent - 1);
-    const newBlock = this.parent.addChildBlock({
-        block: {
-            type: this.edytor.getDefaultBlock(this.parent),
-            content,
-            children: this.value.children
-        },
-        index: this.parent.children.indexOf(this) + 1
-    });
-    // If the block has children, we need to remove its children and insert them into the new block
-    if (hasChildren) {
-        this.yChildren.delete(0, this.children.length);
-    }
-    return newBlock;
+/** Insert `block` as a sibling of `this`, `after` it or before it. */
+const prepareSibling = (self, block, after) => self.parent
+    ? self.edytor.facade.prepare.insertBlocks({ parent: ref(self.parent), index: self.index + (after ? 1 : 0) }, [jsonBlockToSpec(block)])
+    : REFUSED;
+export function prepareInsertAfter({ block }) {
+    return prepareSibling(this, block, true);
 }
-export function removeBlock({ keepChildren = false } = { keepChildren: false }) {
-    if (!this.parent) {
-        return;
-    }
-    // Get the current index from yChildren array since this.index may be stale when removing multiple blocks at once
-    const index = this.parent.yChildren.toArray().indexOf(this.yBlock);
-    if (this.yBlock._item?.deleted) {
-        return;
-    }
-    this.parent.yChildren.delete(index, 1);
-    if (keepChildren && this.hasChildren) {
-        this.parent.yChildren.insert(this.index, this.value.children.map((child) => {
-            const newBlock = new Block({
-                parent: this.parent,
-                edytor: this.edytor,
-                block: child
-            });
-            return newBlock.yBlock;
-        }));
-    }
+export function prepareInsertBefore({ block }) {
+    return prepareSibling(this, block, false);
 }
-export function mergeBlockBackward() {
-    if (!this.parent) {
-        return null;
-    }
-    const { closestPreviousBlock, isEmpty } = this;
-    const { children = [] } = this.value;
-    if (!closestPreviousBlock) {
-        return this.isEmpty ? this.mergeBlockForward() : null;
-    }
-    // Add the current content to the previous block content
-    closestPreviousBlock.pushContentIntoBlock({ value: this.content });
-    if (!isEmpty) {
-        // If the current block has children, we need to unnest them and insert them into the current parent
-        if (children.length > 0) {
-            // Unnest children if any
-            this.parent.yChildren.insert(this.index, children.map((child) => {
-                const newBlock = new Block({
-                    parent: this.parent,
-                    edytor: this.edytor,
-                    block: child
-                });
-                return newBlock.yBlock;
-            }));
-        }
-    }
-    // Remove the current block from its position
-    this.parent.yChildren.delete(this.index + this.children.length, 1);
-    return closestPreviousBlock;
+/** Apply `plan` under `this`'s parent; the id it answers first (inserted or surviving). */
+function resultOf(plan) {
+    return applyPlan(this, plan, [this.parent])?.ids[0] ?? null;
 }
-export function mergeBlockForward() {
-    if (!this.parent) {
-        return null;
-    }
-    const nextBlock = this.closestNextBlock;
-    if (!nextBlock) {
-        return null;
-    }
-    this.pushContentIntoBlock({ value: nextBlock.content });
-    if (nextBlock.children.length > 0 && nextBlock.parent) {
-        nextBlock.parent.yChildren.insert(nextBlock.index + 1, nextBlock.children.map((child) => {
-            const newBlock = new Block({
-                parent: nextBlock.parent,
-                edytor: this.edytor,
-                block: child.value
-            });
-            return newBlock.yBlock;
-        }));
-    }
-    nextBlock.parent?.yChildren.delete(nextBlock.index, 1);
-    return nextBlock;
+export function insertBlockAfter(payload, plan = prepareInsertAfter.call(this, payload)) {
+    return resultOf.call(this, plan);
 }
-export function moveBlock({ path }) {
-    if (!path.length || path.some((p) => isNaN(p) || p < 0) || !this.parent) {
-        return null;
-    }
-    const lastIndex = path.pop();
-    let currentBlock = this.edytor.root;
-    while (path.length > 0) {
-        const index = path.shift();
-        if (typeof index !== 'number' || isNaN(index))
-            break;
-        currentBlock = currentBlock.children[index];
-    }
-    if (!currentBlock) {
-        return null;
-    }
-    this.edytor.idToBlock.delete(this.id);
-    this.parent.yChildren.delete(this.index, 1);
-    const newBlock = new Block({
-        parent: currentBlock,
-        edytor: this.edytor,
-        block: this.value
-    });
-    currentBlock.yChildren.insert(lastIndex, [newBlock.yBlock]);
-    return newBlock;
+export function insertBlockBefore(payload, plan = prepareInsertBefore.call(this, payload)) {
+    return resultOf.call(this, plan);
 }
-export function unNestBlock() {
-    const { parent, index } = this;
-    if (!parent) {
-        return null;
-    }
-    const grandParent = parent.parent;
-    if (!grandParent) {
-        return null;
-    }
-    const newBlock = new Block({
-        parent: grandParent,
-        edytor: this.edytor,
-        block: this.value
-    });
-    grandParent.yChildren.insert(parent.index + 1, [newBlock.yBlock]);
-    parent.yChildren.delete(index, 1);
-    return newBlock;
-}
-export function nestBlock() {
-    const previousBlock = this.previousBlock;
-    if (!previousBlock ||
-        previousBlock?.definition?.void ||
-        previousBlock?.definition?.island ||
-        !this.parent) {
-        return null;
-    }
-    const newBlock = new Block({
-        parent: previousBlock,
-        edytor: this.edytor,
-        block: { ...this.value, children: [] }
-    });
-    previousBlock.yChildren.insert(previousBlock.children.length, [newBlock.yBlock]);
-    if (this.value.children && this.value.children.length) {
-        previousBlock.yChildren.insert(previousBlock.children.length + 1, this.value.children.map((child) => {
-            const newBlock = new Block({
-                parent: previousBlock,
-                edytor: this.edytor,
-                block: child
-            });
-            return newBlock.yBlock;
-        }));
-    }
-    this.parent.yChildren.delete(this.index, 1);
-    return newBlock;
+export function prepareDuplicate() {
+    if (!this.parent || !this.isInTree)
+        return REFUSED;
+    return this.edytor.facade.prepare.duplicateBlock(this.id, (_, kind) => id(kind === 'block' ? 'b' : 'i'));
 }
-export function setBlock({ value }) {
-    this.edytor.doc.transact(() => {
-        if (value.type) {
-            this.type = value.type;
-        }
-        if (value.data) {
-            this.yBlock.set('data', value.data);
-        }
-        if (value.content) {
-            let newContentCount = value.content.length;
-            let oldContentCount = this.content.length;
-            const contentToRemove = oldContentCount - newContentCount;
-            contentToRemove && this.yContent.delete(newContentCount, contentToRemove);
-            const groupedContent = groupContent(value.content);
-            this.yContent.insert(0, groupedContent.map((part) => {
-                if ('type' in part) {
-                    const newInlineBlock = new InlineBlock({
-                        parent: this,
-                        block: part
-                    });
-                    return newInlineBlock.yBlock;
-                }
-                else {
-                    const newText = new Text({
-                        parent: this,
-                        content: part
-                    });
-                    return newText.yText;
-                }
-            }));
-        }
-        else {
-            this.yContent.delete(0, this.content.length);
-        }
-        if (value.children) {
-            let newChildrenCount = value.children.length;
-            let oldChildrenCount = this.children.length;
-            const childrenToRemove = oldChildrenCount - newChildrenCount;
-            this.children = value.children.map((child, i) => {
-                const existingChild = this.children[i];
-                if (existingChild) {
-                    existingChild.setBlock({ value: child });
-                    return existingChild;
-                }
-                else {
-                    return this.addChildBlock({ block: child, index: i });
-                }
-            });
-            childrenToRemove && this.yChildren.delete(newChildrenCount, childrenToRemove);
-        }
-        else {
-            this.yChildren.delete(0, this.children.length);
-        }
+export function duplicateBlock(_ = {}, plan = prepareDuplicate.call(this)) {
+    return resultOf.call(this, plan);
+}
+export function prepareSplit({ index, text }) {
+    if (!text || !this.parent || !this.model)
+        return REFUSED;
+    // G5: the sibling takes its parent's default child type and no data — a
+    // list-like kind (`continues`) keeps its own, with its first preset's data.
+    const { continues, presets } = this.definition;
+    const tail = continues
+        ? { type: this.type, data: { ...(presets?.[0]?.data ?? {}) } }
+        : { type: this.edytor.defaultChild(this.parent), data: {} };
+    const offset = text.segStart + index;
+    return this.edytor.facade.prepare.splitBlock(this.model.id, offset, id('b'), tail);
+}
+/**
+ * A split whose children stay with the block (a container's header): the
+ * tail, of `tail`'s kind, becomes the block's first child (`child`) or its
+ * next sibling. One plan: the document's split step, placed here, without
+ * the move that gives the tail the children.
+ */
+export function prepareSplitKeepingChildren({ index, text }, tail, child) {
+    if (!text || !this.parent || !this.model)
+        return REFUSED;
+    const { facade } = this.edytor;
+    const born = id('b');
+    const split = facade.prepare.splitBlock(this.model.id, text.segStart + index, born, tail);
+    const step = 'writes' in split ? split.writes[0] : undefined;
+    if (step?.op !== 'splitBlock')
+        return REFUSED;
+    if (!child)
+        return facade.compose({ ...split, writes: [step] });
+    // The rank of a first child, and the document's answer on placing the kind there.
+    const slot = facade.prepare.insertBlocks({ parent: this.model.id, index: 0 }, [
+        { id: born, type: tail.type }
+    ]);
+    const first = 'writes' in slot ? slot.writes[0] : undefined;
+    if (first?.op !== 'insertBlocks')
+        return REFUSED;
+    const placed = { ...step, parent: this.model.id, rank: first.ranks[0] };
+    return facade.compose({ ...split, writes: [placed] });
+}
+export function splitBlock(payload, plan = prepareSplit.call(this, payload)) {
+    return applyPlan(this, plan, [this.parent])?.effect.creates[0] ?? null;
+}
+export function prepareRemove({ keepChildren = true } = {}) {
+    if (!this.parent || !this.model || !this.isInTree)
+        return REFUSED;
+    return this.edytor.facade.prepare.deleteBlock(this.model.id, { keepChildren });
+}
+export function removeBlock(payload = {}, plan = prepareRemove.call(this, payload)) {
+    applyPlan(this, plan, [this.parent]);
+}
+export function prepareMergeBackward() {
+    return this.parent && this.model
+        ? this.edytor.facade.prepare.mergeBackward(this.model.id)
+        : REFUSED;
+}
+export function prepareMergeForward() {
+    return this.parent && this.model
+        ? this.edytor.facade.prepare.mergeForward(this.model.id)
+        : REFUSED;
+}
+export function mergeBlockBackward(_ = {}, plan = prepareMergeBackward.call(this)) {
+    return resultOf.call(this, plan);
+}
+export function mergeBlockForward(_ = {}, plan = prepareMergeForward.call(this)) {
+    return resultOf.call(this, plan);
+}
+/** The destination parent a view-tree path (`[...parentPath, index]`) names. */
+const parentAt = (edytor, path) => {
+    let parent = edytor.root;
+    for (const index of path.slice(0, -1))
+        parent = parent?.children[index];
+    return [parent, path.at(-1)];
+};
+export function prepareMove({ path }) {
+    // Admission: the caller path is a view-tree address — validate its shape
+    // and resolve it to the destination PARENT block + index. Structural
+    // permission is the document's (`canPlace`: island seals, void/island
+    // destinations, moves into the block's own subtree).
+    if (!path.length || path.some((p) => isNaN(p) || p < 0) || !this.parent)
+        return REFUSED;
+    const [parent, index] = parentAt(this.edytor, path);
+    if (!parent || !this.model)
+        return REFUSED;
+    return this.edytor.facade.prepare.moveBlock(this.model.id, { parent: ref(parent), index });
+}
+export function moveBlock(payload, plan = prepareMove.call(this, payload)) {
+    return applyPlan(this, plan, [this.parent, parentAt(this.edytor, payload.path)[0]]) ? this : null;
+}
+/**
+ * Grouped move — the operation-layer counterpart of `moveBlock` for
+ * drags/multi-moves (D5). `path` is the same view-tree address shape:
+ * the prefix resolves the destination PARENT block, the last element is
+ * the FINAL index — already discounted for the moved members by the
+ * caller (the `facade.moveBlocks` contract, which counts the
+ * destination's children with the moved members excluded). Structural
+ * permission stays in the facade.
+ */
+export function prepareMoves({ blocks, path }) {
+    if (!path.length || path.some((p) => isNaN(p) || p < 0) || !blocks.length)
+        return REFUSED;
+    const [parent, index] = parentAt(this.edytor, path);
+    if (!parent || blocks.some((block) => block.isRoot))
+        return REFUSED;
+    return this.edytor.facade.prepare.moveBlocks(blocks.map((block) => block.id), { parent: ref(parent), index });
+}
+export function moveBlocks(payload, plan = prepareMoves.call(this, payload)) {
+    const { blocks, path } = payload;
+    const parents = new Set([...blocks.map((block) => block.parent), parentAt(this.edytor, path)[0]]);
+    return applyPlan(this, plan, [...parents]) ? blocks : [];
+}
+/**
+ * The facade owns the refusal rules (`unNestBlock`: top-level blocks,
+ * island-sealed blocks and sealed destinations).
+ */
+export function prepareUnNest() {
+    return this.parent && this.model
+        ? this.edytor.facade.prepare.unNestBlock(this.model.id)
+        : REFUSED;
+}
+export function unNestBlock(_ = {}, plan = prepareUnNest.call(this)) {
+    return applyPlan(this, plan, [this.parent, this.parent?.parent, this]) ? this : null;
+}
+/**
+ * Admission resolves the nest target — the previous sibling — and the
+ * facade owns permission: `nestBlock` refuses void/island/inside-island
+ * targets and island-sealed sources (`canPlace`).
+ */
+export function prepareNest() {
+    const target = this.previousBlock?.id;
+    return this.parent && this.model && target != null
+        ? this.edytor.facade.prepare.nestBlock(this.model.id, target)
+        : REFUSED;
+}
+export function nestBlock(_ = {}, plan = prepareNest.call(this)) {
+    return applyPlan(this, plan, [this.parent, this.previousBlock]) ? this : null;
+}
+export function prepareSet({ value }) {
+    if (!this.model)
+        return REFUSED;
+    // Spec preparation is pure JSON → `ContentItem`/`BlockSpec` conversion:
+    // the document stores the items verbatim and derives the content
+    // invariant on projection.
+    return this.edytor.facade.prepare.setBlock(this.model.id, {
+        ...(value.type !== undefined ? { type: value.type } : {}),
+        ...(value.data !== undefined ? { data: cloneJson(value.data) } : {}),
+        ...(value.content !== undefined ? { content: jsonContentToItems(value.content) } : {}),
+        ...(value.children !== undefined
+            ? { children: value.children.map((child) => jsonBlockToSpec(child)) }
+            : {})
     });
 }
+export function setBlock(payload, plan = prepareSet.call(this, payload)) {
+    if (!applyPlan(this, plan, [this]))
+        return;
+    this.normalizeContent();
+}
 export function pushContentIntoBlock({ value }) {
-    const content = this.content.filter((part) => part instanceof Text ? !part.yText._item?.deleted : !part.yBlock._item?.deleted);
-    let index = content.length;
+    const model = this.model;
+    if (!model)
+        return;
     for (const part of value) {
         if (part instanceof InlineBlock) {
-            // is an inline block needed to be added
-            const newInlineBlock = new InlineBlock({
-                parent: this,
-                block: part
-            });
-            this.yContent.insert(index, [newInlineBlock.yBlock]);
-            index++;
+            const { id, type, data } = part;
+            model.insertInline(model.length, { id, type, ...(data ? { data: cloneJson(data) } : {}) });
         }
         else {
-            const lastPart = content[index - 1];
-            if (lastPart instanceof Text) {
-                const delta = part.yText.toDelta();
-                lastPart.yText.applyDelta([{ retain: lastPart.yText.length }, ...delta]);
-            }
-            else {
-                const newText = new Text({
-                    parent: this,
-                    content: part.value
-                });
-                this.yContent.insert(index, [newText.yText]);
-                index++;
-            }
+            for (const { text, marks } of part.value)
+                if (text.length)
+                    model.insertText(model.length, text, marks);
         }
     }
-    console.log(this.yContent.toArray());
+    this.normalizeContent();
 }
-export function removeInlineBlock({ index }) {
+export function prepareRemoveInline({ index }) {
     const part = this.content.at(index);
-    if (part && part instanceof InlineBlock) {
-        this.yContent.delete(index, 1);
+    return part instanceof InlineBlock && this.model
+        ? this.edytor.facade.prepare.removeInline(this.model.id, part.id)
+        : REFUSED;
+}
+export function removeInlineBlock(payload, plan = prepareRemoveInline.call(this, payload)) {
+    if (applyPlan(this, plan, []))
         this.normalizeContent();
-    }
 }
-export const groupContent = (content) => {
-    const isInlineJSONBlock = (part) => {
-        return part ? 'type' in part : false;
-    };
-    // this function group JSONBlock.content texts together in order to avoid having successive inline Y.Text as it would be ineficient.
-    if (!content)
-        return [[{ text: '' }]];
-    const groupedContent = content.reduce((acc, part) => {
-        const isInlineBlock = 'type' in part;
-        if (isInlineBlock) {
-            if (isInlineJSONBlock(acc.at(-1))) {
-                // Make sure that two consecutive inline blocks are separated by a text block
-                acc.push([{ text: '' }]);
-            }
-            acc.push(part);
-        }
-        else {
-            const lastPart = acc.at(-1);
-            if (acc.length && lastPart && Array.isArray(lastPart)) {
-                lastPart.push(part);
-            }
-            else {
-                acc.push([part]);
-            }
-        }
-        return acc;
-    }, []);
-    if (isInlineJSONBlock(groupedContent.at(0))) {
-        // Make sure that the first part is an inline block
-        groupedContent.unshift([{ text: '' }]);
-    }
-    if (isInlineJSONBlock(groupedContent.at(-1))) {
-        // Make sure that the last part is a text block
-        groupedContent.push([{ text: '' }]);
-    }
-    return groupedContent;
-};
+export function preparePatch({ ops, atom }) {
+    const target = this.isRoot ? null : atom === undefined ? this.id : { block: this.id, atom };
+    return this.edytor.facade.prepare.patchData(target, ops);
+}
+export function patchData(payload, plan = preparePatch.call(this, payload)) {
+    applyPlan(this, plan, []);
+}
+/**
+ * Insert an inline atom at `index` of `text`. Answers the atom's id; the
+ * batched operation resolves it to the text after the atom once committed
+ * ({@link textAfterAtom}), where the caret's pending marks follow.
+ */
 export function addInlineBlock({ index, block, text }) {
-    // TODO
-    const newInlineBlock = new InlineBlock({
-        parent: this,
-        block
-    });
-    const newText = new Text({
-        parent: this,
-        content: text.splitText({ index })
+    const atom = { ...block, id: block.id ?? id('i') };
+    this.model?.insertInline(text.segStart + index, {
+        id: atom.id,
+        type: atom.type,
+        ...(atom.data ? { data: cloneJson(atom.data) } : {})
     });
-    this.yContent.insert(text.index + 1, [newInlineBlock.yBlock, newText.yText]);
     this.normalizeContent();
-    return newText;
+    return atom.id;
 }
+/** The text after atom `atom` of this block; the caret's pending marks follow it there (L4). */
+export function textAfterAtom(atom) {
+    if (atom === undefined)
+        return undefined;
+    const at = this.content.findIndex((part) => part.id === atom);
+    const after = at < 0 ? undefined : this.content[at + 1];
+    if (!after || after instanceof InlineBlock)
+        return null;
+    const { selection } = this.edytor;
+    const pending = selection.pending;
+    const caret = pending && selection.textValue(after, 0);
+    if (caret && caret.kind === 'text')
+        selection.select(Object.freeze({ ...caret, pending }));
+    return after;
+}
+/**
+ * Normalization runs at the end of the command's transaction
+ * (`Dispatcher.drain`): a normalizer reads handles over the index; when a
+ * plugin hook answers work, the work runs in the same transaction and the
+ * block is requested again (bounded by the dispatcher's pass limit, D25).
+ */
 export function normalizeContent() {
-    const content = this.yContent.toArray().filter((part) => !part._item?.deleted);
-    // Ensure content starts with Text
-    if (content.length === 0 || !(content[0] instanceof Y.Text)) {
-        const emptyText = new Text({
-            parent: this,
-            content: [{ text: '' }]
-        });
-        this.yContent.insert(0, [emptyText.yText]);
-        return this.normalizeContent();
-    }
-    // Ensure content ends with Text
-    if (!(content[content.length - 1] instanceof Y.Text)) {
-        const emptyText = new Text({
-            parent: this,
-            content: [{ text: '' }]
-        });
-        this.yContent.insert(content.length, [emptyText.yText]);
-        return this.normalizeContent();
-    }
-    // First handle consecutive text blocks
-    const consecutiveTexts = content.reduce((acc, part, index) => {
-        const nextPart = content[index + 1];
-        if (part instanceof Y.Text && nextPart instanceof Y.Text) {
-            acc.push([part, nextPart]);
-        }
-        return acc;
-    }, []);
-    if (consecutiveTexts.length > 0) {
-        const [first, second] = consecutiveTexts[0];
-        const delta = second.toDelta();
-        first.applyDelta([{ retain: first.length }, ...delta]);
-        this.yContent.delete(content.indexOf(second), 1);
-        return this.normalizeContent();
-    }
-    // Then handle consecutive inline blocks
-    const consecutiveInlineBlocks = content.reduce((acc, part, index) => {
-        const nextPart = content[index + 1];
-        if (part instanceof Y.Map && nextPart instanceof Y.Map) {
-            acc.push([part, nextPart]);
-        }
-        return acc;
-    }, []);
-    if (consecutiveInlineBlocks.length > 0) {
-        const [first, second] = consecutiveInlineBlocks[0];
-        const emptyText = new Text({
-            parent: this,
-            content: [{ text: '' }]
-        });
-        const index = content.indexOf(second);
-        this.yContent.insert(index, [emptyText.yText]);
-        return this.normalizeContent();
-    }
-    const pluginNormalization = this.definition?.normalizeContent?.({ block: this });
-    if (pluginNormalization) {
-        pluginNormalization();
+    if (this.edytor.dispatcher.defer(this, normalizeContent))
+        return;
+    // The v14 content model maintains the part invariants by construction —
+    // projected content always derives to text-first/text-last/non-adjacent
+    // parts — so the only remaining normalization is the plugin hook.
+    const work = this.definition?.normalizeContent?.({ block: this });
+    if (work) {
+        this.edytor.dispatcher.write(work);
         this.normalizeContent();
     }
 }
-export function suggestText({ value }) {
-    if (typeof value === 'string') {
-        this.suggestions = [[{ text: value }]];
-    }
-    else if (value) {
-        this.suggestions = groupContent(value);
-    }
-    else {
-        this.suggestions = null;
+export function normalizeChildren() {
+    if (this.edytor.dispatcher.defer(this, normalizeChildren))
+        return;
+    // An emptied root writes nothing: the view shows its virtual paragraph (`doc.empty.virtual`).
+    const work = this.definition?.normalizeChildren?.({ block: this });
+    if (work) {
+        this.edytor.dispatcher.write(work);
+        this.normalizeChildren();
     }
 }
+/** @deprecated A thin wrapper over an `{ end: block.id }` suggestion (`edytor.suggestions`). */
+export function suggestText({ value }) {
+    this.suggestions =
+        typeof value === 'string'
+            ? [[{ text: value }]]
+            : (value?.map((part) => ('type' in part ? part : [part])) ?? null);
+}
+/** @deprecated Accepts this block's latest `{ end }` suggestion (`suggestion.accept()`). */
 export function acceptSuggestedText() {
-    if (!this.suggestions) {
-        return;
-    }
-    const editableSuggestions = this.suggestions.map((part) => {
-        if ('type' in part) {
-            return new InlineBlock({
-                parent: this,
-                block: part.value
-            });
-        }
-        else {
-            return new Text({
-                parent: this,
-                content: part.value
-            });
-        }
-    });
-    this.yContent.insert(this.content.length, editableSuggestions.map((suggestion) => 'yBlock' in suggestion ? suggestion.yBlock : suggestion.yText));
-    this.suggestions = null;
-    this.normalizeContent();
+    this.edytor.suggestions.at(this.id).end.at(-1)?.accept();
 }
-export function deleteContentAtRange({ start, end }) {
-    const [startIndex, startOffset] = start;
-    const [endIndex, endOffset] = end;
-    let numberToDelete = 0;
-    this.content.slice(startIndex, endIndex + 1).forEach((part, index) => {
-        const isFirstPart = index === 0;
-        const isLastPart = index === endIndex - startIndex;
-        if (part instanceof Text) {
-            if (isFirstPart) {
-                // Delete from offset to end
-                part.yText.delete(startOffset, part.yText.length - startOffset);
-            }
-            else if (isLastPart) {
-                // Delete from start to offset
-                part.yText.delete(0, endOffset);
-            }
-            else {
-                numberToDelete++;
-                // Delete entire text element
-            }
-        }
-        else {
-            // For inline blocks, always delete the entire element
-            numberToDelete++;
-        }
-    });
-    this.yContent.delete(startIndex + 1, numberToDelete);
-    this.normalizeContent();
+export function prepareDeleteRange({ start: [startIndex, startOffset], end: [endIndex, endOffset] }) {
+    const parts = this.edytor.idToBlock.parts(this.id);
+    const [startPart, endPart] = [parts.at(startIndex), parts.at(endIndex)];
+    if (!startPart || !endPart || !this.model)
+        return REFUSED;
+    const at = startPart.start + startOffset;
+    const length = Math.max(0, endPart.start + endOffset - at);
+    return this.edytor.facade.prepare.deleteText(this.model.id, at, length);
+}
+export function deleteContentAtRange(payload, plan = prepareDeleteRange.call(this, payload)) {
+    if (applyPlan(this, plan, []))
+        this.normalizeContent();
 }