smartrte-core 0.2.1 → 1.0.0-beta.2

package/dist/foundation/surface/input.js

@@ -0,0 +1,1761 @@
+import { createNodeId, isTextNode } from "../identity.js";
+import { backspaceAtListItemStart, deleteAtListItemEnd, enterInList, listItemAt, setListChecked, } from "../list/index.js";
+import { resolveShortcut } from "../plugin/dispatch.js";
+import { applyOperations } from "../operations.js";
+import { nodeAtPath, comparePos, inlineGraphemeBoundaries } from "../positions.js";
+import { createScopeIndex } from "../scope/index.js";
+import { TransactionBuilder } from "../editor.js";
+import { executeMarkTool, canonicalMarkOrder, inlineToolDeclarations, insertHardBreak, markKey, marksAtInsertion, } from "../marks/index.js";
+import { exitCodeBlock, insertCodeBlockNewline, } from "../block/index.js";
+import { tokenizeCompositionOwner } from "../atom/index.js";
+import { deleteClipboardSelection, insertClipboardFragment, parseClipboardPayload, reportParsedClipboard, reportRejectedClipboard, remintClipboardFragmentIds, serializeClipboardRepresentations, sliceClipboardSelection, } from "../clipboard/index.js";
+import { cellSelectionFromIds } from "../table/selection.js";
+import { occupancyGridFor } from "../table/grid.js";
+import { insertTableRowCommand } from "../table/commands.js";
+import { FoundationTransactionMap } from "../mapping.js";
+import { resolvePrecedingContentTarget } from "../structural/contentTarget.js";
+import { SMART_UI_ATTRIBUTE } from "../modelDom.js";
+import { suggestDeleteRangeOperation, suggestInsertOperation } from "../suggestions/index.js";
+const samePos = (left, right) => comparePos(left, right) === 0;
+const normalizedRange = (selection) => comparePos(selection.anchor, selection.head) <= 0
+    ? { from: selection.anchor, to: selection.head }
+    : { from: selection.head, to: selection.anchor };
+const collapsed = (selection) => samePos(selection.anchor, selection.head);
+const inlineText = (owner) => (owner.children || []).map((node) => isTextNode(node) ? node.text : "\uFFFC").join("");
+const tokenUnits = (tokens) => {
+    const units = [];
+    tokens.forEach((token) => {
+        if (token.kind === "atom")
+            units.push({ char: "\uFFFC", marks: [], key: `atom:${token.nodeId}`, kind: "atom" });
+        else
+            for (let index = 0; index < token.text.length; index += 1) {
+                units.push({ char: token.text[index], marks: [...token.marks], key: token.marks.map(markKey).join("|"), kind: "text" });
+            }
+    });
+    return units;
+};
+const ownerAt = (editor, pos) => {
+    const node = nodeAtPath(editor.document, pos.path);
+    if (!node || isTextNode(node))
+        throw new Error("Input position must resolve to an inline owner.");
+    return node;
+};
+/**
+ * Returns editable inline owners in logical document order. This is used only
+ * when a deletion crosses a structural boundary; ordinary character deletion
+ * remains path-local. Structural containers (lists, quotes, cells) are
+ * intentionally transparent here, while atomic nodes remain opaque.
+ */
+const editableOwners = (node, path, schema, output = []) => {
+    if (isTextNode(node) || schema.nodes[node.type]?.atomic === true)
+        return output;
+    if (isInlineOwnerNode(node, schema)) {
+        output.push({ node, path: [...path] });
+        return output;
+    }
+    node.children?.forEach((child, index) => editableOwners(child, [...path, index], schema, output));
+    return output;
+};
+const emptyParagraph = (id) => ({ type: "paragraph", id, children: [] });
+const isInlineOwnerNode = (node, schema) => {
+    if (isTextNode(node) || schema.nodes[node.type]?.atomic === true)
+        return false;
+    if (["paragraph", "heading", "code_block"].includes(node.type))
+        return true;
+    return /(?:^|[|(\s])(?:inline|text)(?:[+*?]|$)/.test(schema.nodes[node.type]?.content || "");
+};
+/** Finds the nearest editable inline owner inside a structural sibling. */
+const editableOwnerPosition = (node, path, direction, schema) => {
+    if (isTextNode(node) || schema.nodes[node.type]?.atomic === true)
+        return null;
+    if (isInlineOwnerNode(node, schema))
+        return {
+            path: [...path],
+            offset: direction > 0 ? 0 : inlineText(node).length,
+        };
+    const children = node.children || [];
+    const indexes = Array.from({ length: children.length }, (_, index) => index);
+    if (direction < 0)
+        indexes.reverse();
+    for (const index of indexes) {
+        const found = editableOwnerPosition(children[index], [...path, index], direction, schema);
+        if (found)
+            return found;
+    }
+    return null;
+};
+/**
+ * DOM selections can legally collapse on a structural element boundary (for
+ * example, the editable root at child offset `children.length`).  Structural
+ * positions are useful for operations, but they are not caret owners. Resolve
+ * those boundary points to the nearest inline owner before they enter the
+ * canonical selection state. Direct editable siblings are preferred over an
+ * owner nested inside a structural sibling so a caret between quotes lands in
+ * the boundary paragraph rather than inside the preceding quote.
+ */
+const editablePositionForStructuralBoundary = (editor, position, bias) => {
+    const node = nodeAtPath(editor.document, position.path);
+    if (!node || isTextNode(node) || isInlineOwnerNode(node, editor.schema))
+        return position;
+    const children = node.children || [];
+    const offset = Math.max(0, Math.min(position.offset, children.length));
+    const direct = (index, direction) => {
+        const child = children[index];
+        if (!child || isTextNode(child) || !isInlineOwnerNode(child, editor.schema))
+            return null;
+        return {
+            path: [...position.path, index],
+            offset: direction < 0 ? inlineText(child).length : 0,
+        };
+    };
+    const directOrder = bias < 0 ? [offset - 1, offset] : [offset, offset - 1];
+    for (const index of directOrder) {
+        const found = direct(index, bias);
+        if (found)
+            return found;
+    }
+    const nestedOrder = bias < 0 ? [offset - 1, offset] : [offset, offset - 1];
+    for (const index of nestedOrder) {
+        const child = children[index];
+        if (!child || isTextNode(child))
+            continue;
+        const found = editableOwnerPosition(child, [...position.path, index], bias, editor.schema);
+        if (found)
+            return found;
+    }
+    return null;
+};
+const textSegments = (owner) => {
+    let offset = 0;
+    return (owner.children || []).map((node, index) => {
+        const from = offset;
+        offset += isTextNode(node) ? node.text.length : 1;
+        return { node, index, from, to: offset };
+    });
+};
+/**
+ * Split an inline owner without flattening its children.  Enter is a block
+ * operation, but the content crossing the split still belongs to the same
+ * inline runs: marks, hard breaks, and inline atoms must survive byte-for-byte
+ * on the new block.  Text children are copied only when they are cut in two;
+ * unsplit children retain their identity until the operation boundary clones
+ * the inserted node.
+ */
+const splitInlineChildren = (children, offset) => {
+    const before = [];
+    const after = [];
+    let consumed = 0;
+    let split = false;
+    for (const child of children) {
+        if (split) {
+            after.push(child);
+            continue;
+        }
+        const width = isTextNode(child) ? child.text.length : 1;
+        const local = offset - consumed;
+        if (local >= width) {
+            before.push(child);
+            consumed += width;
+            continue;
+        }
+        if (isTextNode(child)) {
+            if (local > 0)
+                before.push({ ...child, text: child.text.slice(0, local) });
+            if (local < width)
+                after.push({ ...child, text: child.text.slice(local) });
+        }
+        else if (local === 0) {
+            after.push(child);
+        }
+        else {
+            // Inline atoms occupy one indivisible unit. A valid position cannot be
+            // inside one; this branch is only the defensive side of that contract.
+            before.push(child);
+        }
+        split = true;
+        consumed += width;
+    }
+    return [before, after];
+};
+const queueInlineDeletion = (builder, ownerPath, owner, from, to) => {
+    const segments = textSegments(owner).filter((segment) => segment.from < to && segment.to > from).reverse();
+    segments.forEach((segment) => {
+        if (isTextNode(segment.node)) {
+            const localFrom = Math.max(from, segment.from) - segment.from;
+            const localTo = Math.min(to, segment.to) - segment.from;
+            const text = segment.node.text.slice(localFrom, localTo);
+            if (text)
+                builder.operations.push({
+                    type: "deleteText",
+                    pos: { path: [...ownerPath], offset: segment.from + localFrom },
+                    text,
+                    ...(segment.node.marks?.length ? { marks: [...segment.node.marks] } : {}),
+                });
+        }
+        else if (from <= segment.from && to >= segment.to) {
+            builder.operations.push({ type: "removeNode", pos: { path: [...ownerPath], offset: segment.index }, node: segment.node });
+        }
+    });
+};
+const isDocumentStart = (editor, pos) => {
+    if (pos.offset !== 0)
+        return false;
+    let node = editor.document;
+    for (const index of pos.path) {
+        if (index !== 0 || isTextNode(node) || !node.children?.[index])
+            return false;
+        node = node.children[index];
+    }
+    return true;
+};
+const isDocumentEnd = (editor, pos) => {
+    let node = editor.document;
+    if (pos.path.length === 0)
+        return pos.offset === editor.document.children.length;
+    for (const index of pos.path) {
+        if (isTextNode(node) || !node.children?.[index] || index !== node.children.length - 1)
+            return false;
+        node = node.children[index];
+    }
+    const limit = isTextNode(node) ? 0 : isInlineOwnerNode(node, editor.schema)
+        ? inlineText(node).length
+        : node.children?.length || 0;
+    return pos.offset === limit;
+};
+const isWholeDocumentRange = (editor, range) => {
+    return isDocumentStart(editor, range.from) && isDocumentEnd(editor, range.to);
+};
+/**
+ * Clearing a whole-document selection must still leave the schema-valid
+ * editable anchor the browser expects. Keep the operation explicit rather
+ * than relying on repair(), because transaction validation deliberately runs
+ * before repair and a doc node is required to contain at least one block.
+ */
+const queueWholeDocumentDeletion = (editor, builder) => {
+    const children = editor.document.children || [];
+    for (let index = children.length - 1; index >= 0; index -= 1) {
+        builder.operations.push({ type: "removeNode", pos: { path: [], offset: index }, node: children[index] });
+    }
+    const paragraph = emptyParagraph(createNodeId());
+    builder.operations.push({ type: "insertNode", pos: { path: [], offset: 0 }, node: paragraph });
+    return { path: [0], offset: 0 };
+};
+const queueRangeDeletion = (editor, builder, range) => {
+    const fromOwner = ownerAt(editor, range.from);
+    const toOwner = ownerAt(editor, range.to);
+    if (range.from.path.length === range.to.path.length && range.from.path.every((part, index) => part === range.to.path[index])) {
+        queueInlineDeletion(builder, range.from.path, fromOwner, range.from.offset, range.to.offset);
+        return { path: [...range.from.path], offset: range.from.offset };
+    }
+    const parentPath = range.from.path.slice(0, -1);
+    const toParentPath = range.to.path.slice(0, -1);
+    if (parentPath.length !== toParentPath.length || parentPath.some((part, index) => part !== toParentPath[index])) {
+        throw new Error("Cross-parent text deletion is outside the canonical test surface contract.");
+    }
+    const fromIndex = range.from.path[range.from.path.length - 1];
+    const toIndex = range.to.path[range.to.path.length - 1];
+    if (fromOwner.type !== toOwner.type || fromIndex >= toIndex)
+        throw new Error("Cross-block deletion requires compatible forward sibling blocks.");
+    queueInlineDeletion(builder, range.to.path, toOwner, 0, range.to.offset);
+    queueInlineDeletion(builder, range.from.path, fromOwner, range.from.offset, inlineText(fromOwner).length);
+    const parent = nodeAtPath(editor.document, parentPath);
+    if (!parent || isTextNode(parent) || !parent.children)
+        throw new Error("Cross-block deletion parent is invalid.");
+    for (let index = toIndex - 1; index > fromIndex; index -= 1) {
+        builder.operations.push({ type: "removeNode", pos: { path: [...parentPath], offset: index }, node: parent.children[index] });
+    }
+    builder.operations.push({
+        type: "mergeNode",
+        pos: { path: [...parentPath], offset: fromIndex + 1 },
+        depth: 0,
+        retiredId: toOwner.id,
+        splitOffset: textSegments(fromOwner).filter((segment) => segment.from < range.from.offset).length,
+    });
+    return { path: [...range.from.path], offset: range.from.offset };
+};
+const samePath = (left, right) => left.length === right.length && left.every((part, index) => part === right[index]);
+const pathStartsWith = (path, prefix) => prefix.length < path.length && prefix.every((part, index) => path[index] === part);
+const firstEditableOwnerId = (node, schema) => {
+    if (isTextNode(node) || schema.nodes[node.type]?.atomic === true)
+        return null;
+    if (isInlineOwnerNode(node, schema))
+        return node.id;
+    for (const child of node.children || []) {
+        const found = firstEditableOwnerId(child, schema);
+        if (found)
+            return found;
+    }
+    return null;
+};
+const scopeTargetIds = (scope) => {
+    if (scope.kind === "list-selection")
+        return scope.items.map((item) => item.itemId);
+    if (scope.kind === "block-range")
+        return [...scope.blockIds];
+    if (scope.kind === "container-tree")
+        return [scope.rootId];
+    if (scope.kind === "atomic-node")
+        return [scope.nodeId];
+    if (scope.kind === "mixed")
+        return scope.parts.flatMap(scopeTargetIds);
+    return [];
+};
+/**
+ * Deletes a structural selection by IDs rather than by assuming both inline
+ * endpoints share one parent.  The old range path was intentionally narrow
+ * for character deletion; it threw for list items and for node selections of
+ * blockquote/code nodes, which the browser quite legitimately reports as
+ * different scope kinds.
+ */
+const structuralDeletionPlan = (editor, selection, range) => {
+    const ids = [];
+    if (selection.type === "node" || selection.type === "cell") {
+        const parent = nodeAtPath(editor.document, range.from.path);
+        if (!parent || isTextNode(parent) || !parent.children)
+            return null;
+        for (let index = range.from.offset; index < range.to.offset; index += 1) {
+            const child = parent.children[index];
+            if (child && !isTextNode(child))
+                ids.push(child.id);
+        }
+    }
+    else {
+        const scope = editor.resolveScope({ want: "list-selection" }, selection);
+        if ("kind" in scope)
+            ids.push(...scopeTargetIds(scope));
+        if (!ids.length) {
+            const blocks = editor.resolveScope({ want: "block-range" }, selection);
+            if ("kind" in blocks)
+                ids.push(...scopeTargetIds(blocks));
+        }
+        if (!ids.length) {
+            const containers = editor.resolveScope({ want: "container-tree" }, selection);
+            if ("kind" in containers)
+                ids.push(...scopeTargetIds(containers));
+        }
+    }
+    const uniqueIds = [...new Set(ids)];
+    if (!uniqueIds.length)
+        return null;
+    const located = uniqueIds.flatMap((id) => {
+        const position = editor.positions.positionOf(id);
+        if (!position)
+            return [];
+        return [{ id, position, node: position.parent.children?.[position.pos.offset] }];
+    }).filter((entry) => Boolean(entry.node && !isTextNode(entry.node)));
+    if (!located.length)
+        return null;
+    // If a parent itself is selected, descendants are already removed with it;
+    // emitting both would address stale paths in one transaction.
+    const targetPaths = located.map((entry) => ({ ...entry, path: [...entry.position.pos.path, entry.position.pos.offset] }));
+    const targets = targetPaths.filter((entry) => !targetPaths.some((candidate) => candidate !== entry && pathStartsWith(entry.path, candidate.path)));
+    const byParent = new Map();
+    targets.forEach((entry) => {
+        const key = entry.position.pos.path.join("/");
+        byParent.set(key, [...(byParent.get(key) || []), entry]);
+    });
+    // Select-all is a structural range at the document root. Keep the explicit
+    // empty-document anchor instead of leaving repair to invent one later.
+    const root = nodeAtPath(editor.document, []);
+    const rootGroup = byParent.get("");
+    if (root && !isTextNode(root) && rootGroup && rootGroup.length === (root.children || []).length
+        && rootGroup.every((entry) => entry.position.pos.path.length === 0)) {
+        const operations = [];
+        for (let index = (root.children || []).length - 1; index >= 0; index -= 1) {
+            operations.push({ type: "removeNode", pos: { path: [], offset: index }, node: root.children[index] });
+        }
+        const paragraph = emptyParagraph(createNodeId());
+        operations.push({ type: "insertNode", pos: { path: [], offset: 0 }, node: paragraph });
+        return { operations, preferredOwnerIds: [paragraph.id] };
+    }
+    const operations = [];
+    const preferredOwnerIds = [];
+    byParent.forEach((entries) => {
+        const parent = entries[0].position.parent;
+        const children = parent.children || [];
+        const indexes = entries.map((entry) => entry.position.pos.offset).sort((left, right) => left - right);
+        const allChildren = indexes.length === children.length && indexes.every((value, index) => value === index);
+        if (allChildren && parent.type === "list") {
+            const listPosition = editor.positions.positionOf(parent.id);
+            if (listPosition) {
+                const paragraph = emptyParagraph(createNodeId());
+                operations.push({ type: "replaceNode", pos: listPosition.pos, before: parent, after: paragraph });
+                preferredOwnerIds.push(paragraph.id);
+                return;
+            }
+        }
+        if (allChildren && (parent.type === "list_item" || parent.type === "blockquote" || parent.type === "table_cell")) {
+            const parentPosition = editor.positions.positionOf(parent.id);
+            if (parentPosition) {
+                const paragraph = emptyParagraph(createNodeId());
+                operations.push({ type: "replaceNode", pos: parentPosition.pos, before: parent, after: { ...parent, children: [paragraph] } });
+                preferredOwnerIds.push(paragraph.id);
+                return;
+            }
+        }
+        // Descending offsets keep every remaining path stable when several
+        // siblings are deleted from the same list/table/document container.
+        [...entries].sort((left, right) => right.position.pos.offset - left.position.pos.offset).forEach((entry) => {
+            operations.push({ type: "removeNode", pos: entry.position.pos, node: entry.node });
+        });
+        const next = children[indexes[indexes.length - 1] + 1] || children[indexes[0] - 1];
+        if (next && !isTextNode(next)) {
+            const owner = firstEditableOwnerId(next, editor.schema);
+            if (owner)
+                preferredOwnerIds.push(owner);
+        }
+    });
+    if (!operations.length)
+        return null;
+    return { operations, preferredOwnerIds };
+};
+const previousWord = (text, offset) => {
+    const prefix = text.slice(0, offset);
+    const match = prefix.match(/(?:\s+|[\p{L}\p{N}_]+|[^\p{L}\p{N}_\s]+)$/u);
+    return Math.max(0, offset - (match?.[0].length || 1));
+};
+const nextWord = (text, offset) => {
+    const match = text.slice(offset).match(/^(?:\s+|[\p{L}\p{N}_]+|[^\p{L}\p{N}_\s]+)/u);
+    return Math.min(text.length, offset + (match?.[0].length || 1));
+};
+export class FoundationInputPipeline {
+    constructor(editor, renderer, root, options = {}) {
+        this.editor = editor;
+        this.renderer = renderer;
+        this.root = root;
+        this.options = options;
+        this.composition = null;
+        this.unhandled = [];
+        this.destroyed = false;
+        this.internalDrag = null;
+        this.tableDragAnchor = null;
+        this.trackChanges = { enabled: false, authorId: "anonymous" };
+        this.beforeInputListener = (event) => this.handleBeforeInput(event);
+        this.keyDownListener = (event) => this.handleKeyDown(event);
+        this.compositionStartListener = (event) => this.handleCompositionStart(event);
+        this.compositionUpdateListener = (event) => this.handleCompositionUpdate(event);
+        this.compositionEndListener = (event) => this.handleCompositionEnd(event);
+        this.tableMouseDownListener = (event) => {
+            const target = event.target instanceof Element ? event.target.closest(`[${SMART_UI_ATTRIBUTE}="check-control"]`) : null;
+            if (target) {
+                // A projected checkbox must not move the editable selection to the
+                // button itself. The click handler below keeps the existing model
+                // selection while toggling the item.
+                event.preventDefault();
+                this.root.focus();
+                return;
+            }
+            if (this.composition)
+                return;
+            // Only the primary (left) button starts a drag-selection gesture. A
+            // right-click's mousedown/mouseup pair (button 2) also reaches this
+            // same native listener - without this guard, a real-world imprecise
+            // right-click whose mousedown and mouseup landed in different cells
+            // (easy near a shared cell border, where a human hand's natural
+            // few-pixel wobble between press and release is enough) silently
+            // formed a genuine multi-cell selection the user never intended to
+            // make, rendered as a highlight spanning well past what a single
+            // right-click should ever select.
+            if (event.button !== 0) {
+                this.tableDragAnchor = null;
+                return;
+            }
+            const cell = this.cellFromNode(event.target);
+            this.tableDragAnchor = cell;
+        };
+        this.tableMouseUpListener = (event) => {
+            const anchor = this.tableDragAnchor;
+            this.tableDragAnchor = null;
+            if (!anchor || this.composition)
+                return;
+            const head = this.cellFromNode(event.target);
+            if (!head || head.tableId !== anchor.tableId || head.id === anchor.id)
+                return;
+            const selection = cellSelectionFromIds(anchor.id, head.id, this.editor.positions);
+            if (!selection)
+                return;
+            event.preventDefault();
+            this.editor.setSelection(selection, { source: "api" });
+            this.renderer.render(this.editor.document, selection);
+        };
+        this.clickListener = (event) => {
+            const checkControl = event.target instanceof Element
+                ? event.target.closest(`[${SMART_UI_ATTRIBUTE}="check-control"]`)
+                : null;
+            if (checkControl) {
+                event.preventDefault();
+                const itemElement = checkControl.closest('[data-smart-type="list_item"]');
+                const mapped = itemElement ? this.renderer.mapping.domToNode(itemElement) : null;
+                if (!mapped || isTextNode(mapped.node) || mapped.node.type !== "list_item")
+                    return;
+                const itemPosition = this.editor.positions.positionOf(mapped.nodeId);
+                const list = itemPosition?.parent;
+                if (!itemPosition || !list || list.type !== "list" || list.attrs?.checkable !== true)
+                    return;
+                const ownerId = firstEditableOwnerId(mapped.node, this.editor.schema);
+                const content = ownerId ? this.editor.positions.contentRangeOf(ownerId) : null;
+                if (!content)
+                    return;
+                const point = content.from;
+                const scope = this.editor.resolveScope({ want: "list-selection" }, { type: "text", anchor: point, head: point });
+                if (!("kind" in scope) || (scope.kind !== "list-selection" && scope.kind !== "mixed"))
+                    return;
+                const operations = setListChecked(this.editor.document, scope, { checked: mapped.node.attrs?.checked !== true }, this.commandContext());
+                if (!operations.length)
+                    return;
+                const selection = this.editor.selection;
+                this.editor.transact((builder) => {
+                    builder.operations.push(...operations);
+                    builder.setSelection(selection);
+                }, { source: "input", addToHistory: true });
+                this.renderer.render(this.editor.document, this.editor.selection);
+                return;
+            }
+            const target = event.target instanceof Element ? event.target.closest("[data-smart-atomic]") : null;
+            const mapped = target ? this.renderer.mapping.domToNode(target) : null;
+            if (!mapped || isTextNode(mapped.node) || this.editor.schema.nodes[mapped.node.type]?.selectable !== true)
+                return;
+            const range = this.editor.positions.rangeOf(mapped.nodeId);
+            if (!range)
+                return;
+            this.editor.setSelection({ type: "node", anchor: range.from, head: range.to }, { source: "api" });
+            this.renderer.render(this.editor.document, this.editor.selection);
+        };
+        this.selectionChangeListener = () => this.syncSelectionFromDom();
+        this.pasteListener = (event) => this.handlePaste(event);
+        this.copyListener = (event) => this.handleCopy(event);
+        this.cutListener = (event) => this.handleCut(event);
+        this.dragStartListener = (event) => this.handleDragStart(event);
+        this.dropListener = (event) => this.handleDrop(event);
+        this.ownerDocument = root.ownerDocument;
+        root.addEventListener("beforeinput", this.beforeInputListener);
+        root.addEventListener("keydown", this.keyDownListener);
+        root.addEventListener("compositionstart", this.compositionStartListener);
+        root.addEventListener("compositionupdate", this.compositionUpdateListener);
+        root.addEventListener("compositionend", this.compositionEndListener);
+        root.addEventListener("click", this.clickListener);
+        root.addEventListener("mousedown", this.tableMouseDownListener);
+        root.addEventListener("mouseup", this.tableMouseUpListener);
+        this.ownerDocument.addEventListener("selectionchange", this.selectionChangeListener);
+        root.addEventListener("paste", this.pasteListener);
+        root.addEventListener("copy", this.copyListener);
+        root.addEventListener("cut", this.cutListener);
+        root.addEventListener("dragstart", this.dragStartListener);
+        root.addEventListener("drop", this.dropListener);
+        renderer.render(editor.document, editor.selection);
+        editor.resolveScope({ want: "describe" });
+    }
+    get unhandledInputTypes() { return this.unhandled; }
+    cellFromNode(input) {
+        const node = input instanceof Node ? input : null;
+        const element = node?.nodeType === Node.ELEMENT_NODE ? node : node?.parentElement;
+        const cell = element?.closest('[data-smart-type="table_cell"]');
+        if (!cell)
+            return null;
+        const table = cell.closest('[data-smart-type="table"]');
+        const mappedCell = this.renderer.mapping.domToNode(cell);
+        const mappedTable = table ? this.renderer.mapping.domToNode(table) : null;
+        if (!mappedCell || isTextNode(mappedCell.node) || !mappedTable || isTextNode(mappedTable.node))
+            return null;
+        return { id: mappedCell.nodeId, tableId: mappedTable.nodeId };
+    }
+    payloadFromTransfer(transfer) {
+        const representations = Object.fromEntries(Array.from(transfer.types).filter((type) => type !== "Files").map((type) => [type, transfer.getData(type)]));
+        return {
+            html: representations["text/html"], plainText: representations["text/plain"],
+            native: representations["application/x-smart-rte+json"], types: Array.from(transfer.types), representations,
+        };
+    }
+    writeTransfer(transfer, document) {
+        const representations = serializeClipboardRepresentations(document);
+        Object.entries(representations).forEach(([type, value]) => transfer.setData(type, value));
+    }
+    selectionForPoint(event) {
+        const pointDocument = this.ownerDocument;
+        const caret = pointDocument.caretPositionFromPoint?.(event.clientX, event.clientY);
+        const fallback = !caret ? pointDocument.caretRangeFromPoint?.(event.clientX, event.clientY) : null;
+        const pos = caret ? this.renderer.mapping.domToPos(caret.offsetNode, caret.offset)
+            : fallback ? this.renderer.mapping.domToPos(fallback.startContainer, fallback.startOffset) : null;
+        const target = pos || this.editor.selection.head;
+        return { type: "text", anchor: target, head: target };
+    }
+    commitClipboard(result, source) {
+        if (!result.operations.length)
+            return;
+        const preview = applyOperations(this.editor.document, result.operations);
+        const lookup = createScopeIndex().positions(preview, this.editor.schema);
+        const content = lookup.contentRangeOf(result.selectionTarget.ownerId);
+        const position = lookup.positionOf(result.selectionTarget.ownerId);
+        const base = content?.from || position?.pos || this.editor.selection.head;
+        const target = content && content.from.path.length === content.to.path.length
+            && content.from.path.every((part, index) => part === content.to.path[index])
+            ? { path: [...content.from.path], offset: Math.min(result.selectionTarget.offset, content.to.offset) }
+            : { path: [...base.path], offset: base.offset };
+        this.editor.transact((builder) => {
+            builder.operations.push(...result.operations);
+            builder.setSelection({ type: "text", anchor: target, head: target });
+        }, { source, addToHistory: true });
+        this.renderer.render(this.editor.document, this.editor.selection);
+    }
+    handleCopy(event) {
+        if (!event.clipboardData || collapsed(this.editor.selection))
+            return;
+        event.preventDefault();
+        this.writeTransfer(event.clipboardData, sliceClipboardSelection(this.editor.document, this.editor.selection));
+    }
+    handleCut(event) {
+        if (!event.clipboardData || collapsed(this.editor.selection))
+            return;
+        event.preventDefault();
+        this.writeTransfer(event.clipboardData, sliceClipboardSelection(this.editor.document, this.editor.selection));
+        const deletion = deleteClipboardSelection(this.editor.document, this.editor.selection, this.editor.positions);
+        this.commitClipboard({ ...deletion, definingAncestorId: null }, "cut");
+    }
+    handlePaste(event) {
+        event.preventDefault();
+        if (!event.clipboardData) {
+            this.unhandled.push("paste-without-clipboard-data");
+            return;
+        }
+        const payload = this.payloadFromTransfer(event.clipboardData);
+        try {
+            const parsed = parseClipboardPayload(payload, { ownerDocument: this.ownerDocument, schema: this.editor.schema });
+            this.options.onClipboardDiagnostic?.(reportParsedClipboard(payload, parsed));
+            const fragment = remintClipboardFragmentIds(parsed.document, createNodeId);
+            const result = insertClipboardFragment(this.editor.document, this.editor.selection, fragment, {
+                schema: this.editor.schema, positions: this.editor.positions, idFactory: createNodeId,
+            });
+            this.commitClipboard(result, "paste");
+        }
+        catch (error) {
+            this.options.onClipboardDiagnostic?.(reportRejectedClipboard(payload, error));
+            this.unhandled.push("paste-rejected");
+        }
+    }
+    handleDragStart(event) {
+        if (!event.dataTransfer || collapsed(this.editor.selection))
+            return;
+        const fragment = sliceClipboardSelection(this.editor.document, this.editor.selection);
+        this.internalDrag = { selection: this.editor.selection, fragment };
+        this.writeTransfer(event.dataTransfer, fragment);
+        event.dataTransfer.effectAllowed = "move";
+    }
+    handleDrop(event) {
+        event.preventDefault();
+        if (!event.dataTransfer) {
+            this.unhandled.push("drop-without-data-transfer");
+            return;
+        }
+        const targetSelection = this.selectionForPoint(event);
+        const files = Array.from(event.dataTransfer.files || []);
+        if (files.length) {
+            this.options.onFiles?.(files, targetSelection);
+            return;
+        }
+        if (this.internalDrag) {
+            const deletion = deleteClipboardSelection(this.editor.document, this.internalDrag.selection, this.editor.positions);
+            const preview = applyOperations(this.editor.document, deletion.operations);
+            const mappedSelection = new FoundationTransactionMap(deletion.operations).mapSelection(targetSelection);
+            const lookup = createScopeIndex().positions(preview, this.editor.schema);
+            if (this.internalDrag.selection.type === "node" && this.internalDrag.fragment.children.length === 1) {
+                const moving = this.internalDrag.fragment.children[0];
+                const targetOwner = nodeAtPath(preview, mappedSelection.head.path);
+                if (targetOwner && !isTextNode(targetOwner) && mappedSelection.head.path.length) {
+                    const parentPath = mappedSelection.head.path.slice(0, -1);
+                    const ownerIndex = mappedSelection.head.path[mappedSelection.head.path.length - 1];
+                    const insertionOffset = ownerIndex + (mappedSelection.head.offset > 0 ? 1 : 0);
+                    this.internalDrag = null;
+                    this.commitClipboard({
+                        operations: [...deletion.operations, { type: "insertNode", pos: { path: parentPath, offset: insertionOffset }, node: moving }],
+                        selectionTarget: { ownerId: isTextNode(moving) ? targetOwner.id : moving.id, offset: 0 },
+                        definingAncestorId: null,
+                    }, "drop");
+                    return;
+                }
+            }
+            const insertion = insertClipboardFragment(preview, mappedSelection, this.internalDrag.fragment, {
+                schema: this.editor.schema, positions: lookup, idFactory: createNodeId,
+            });
+            this.internalDrag = null;
+            this.commitClipboard({ ...insertion, operations: [...deletion.operations, ...insertion.operations] }, "drop");
+            return;
+        }
+        const parsed = parseClipboardPayload(this.payloadFromTransfer(event.dataTransfer), { ownerDocument: this.ownerDocument, schema: this.editor.schema });
+        const fragment = remintClipboardFragmentIds(parsed.document, createNodeId);
+        const result = insertClipboardFragment(this.editor.document, targetSelection, fragment, {
+            schema: this.editor.schema, positions: this.editor.positions, idFactory: createNodeId,
+        });
+        this.commitClipboard(result, "drop");
+    }
+    commit(builderFn, options = {}) {
+        this.editor.transact((builder) => builder.setSelection(builderFn(builder)), {
+            source: "input",
+            addToHistory: true,
+            ...(options.compositionId ? { compositionId: options.compositionId } : {}),
+        });
+        this.renderer.render(this.editor.document, this.editor.selection);
+    }
+    commandContext() {
+        return { schema: this.editor.schema, positions: this.editor.positions };
+    }
+    commitStructuralResult(result, source = "input") {
+        if (!result.operations.length)
+            return;
+        const preview = applyOperations(this.editor.document, result.operations);
+        const lookup = createScopeIndex().positions(preview, this.editor.schema);
+        const content = lookup.contentRangeOf(result.selectionTarget.ownerId);
+        if (!content)
+            throw new Error(`List input selection owner "${result.selectionTarget.ownerId}" was not preserved.`);
+        const target = { path: [...content.from.path], offset: result.selectionTarget.offset };
+        this.editor.transact((builder) => {
+            builder.operations.push(...result.operations);
+            builder.setSelection({ type: "text", anchor: target, head: target });
+        }, { source, addToHistory: true });
+        this.renderer.render(this.editor.document, this.editor.selection);
+    }
+    /** First content-bearing child of a table cell, or the cell itself if somehow childless. */
+    firstOwnerOf(cell) {
+        const first = cell.children?.[0];
+        return first && !isTextNode(first) ? first.id : cell.id;
+    }
+    /**
+     * Tab/Shift+Tab cell-to-cell navigation (Phase 11 Tier 2 - previously
+     * "Tables own Tab navigation" was just a bare `return`, a genuinely
+     * missing feature, not a missing test). `grid.anchors` is already in
+     * reading order, so stepping ±1 through it is next/previous cell;
+     * stepping past the last cell appends a row via insertTableRowCommand and
+     * lands in its first cell, matching the reference precedent Tab already
+     * uses for a list item with no legal indent - always claim the key.
+     */
+    handleTableTab(tableId, currentCellId, backward) {
+        const resolvedTable = this.editor.positions.positionOf(tableId);
+        const tableNode = resolvedTable?.parent.children?.[resolvedTable.pos.offset];
+        if (!tableNode || isTextNode(tableNode) || tableNode.id !== tableId)
+            return;
+        const grid = occupancyGridFor(tableNode);
+        const index = grid.anchors.findIndex((cell) => cell.cellId === currentCellId);
+        if (index === -1)
+            return;
+        if (backward) {
+            if (index === 0)
+                return;
+            const target = grid.anchors[index - 1];
+            const ownerId = this.firstOwnerOf(target.node);
+            const content = this.editor.positions.contentRangeOf(ownerId);
+            if (content) {
+                this.editor.setSelection({ type: "text", anchor: content.from, head: content.from }, { source: "keyboard" });
+                this.renderer.render(this.editor.document, this.editor.selection);
+            }
+            return;
+        }
+        if (index < grid.anchors.length - 1) {
+            const target = grid.anchors[index + 1];
+            const ownerId = this.firstOwnerOf(target.node);
+            const content = this.editor.positions.contentRangeOf(ownerId);
+            if (content) {
+                this.editor.setSelection({ type: "text", anchor: content.from, head: content.from }, { source: "keyboard" });
+                this.renderer.render(this.editor.document, this.editor.selection);
+            }
+            return;
+        }
+        // Past the last cell: append a row (no crossing rowspans at the bottom
+        // edge, so cellIds[0]/paragraphIds[0] are guaranteed the new row's
+        // first column-0 cell/paragraph).
+        const cellIds = Array.from({ length: grid.columns }, () => createNodeId());
+        const paragraphIds = Array.from({ length: grid.columns }, () => createNodeId());
+        const tableGridScope = this.editor.resolveScope({ want: "table-grid" });
+        if (!("kind" in tableGridScope) || tableGridScope.kind !== "table-grid")
+            return;
+        const operations = insertTableRowCommand(this.editor.document, tableGridScope, { position: "after", rowId: createNodeId(), cellIds, paragraphIds }, this.commandContext());
+        if (!operations.length)
+            return;
+        const preview = applyOperations(this.editor.document, operations);
+        const lookup = createScopeIndex().positions(preview, this.editor.schema);
+        const content = lookup.contentRangeOf(paragraphIds[0]);
+        if (!content)
+            return;
+        this.editor.transact((builder) => {
+            builder.operations.push(...operations);
+            builder.setSelection({ type: "text", anchor: content.from, head: content.from });
+        }, { source: "keyboard", addToHistory: true });
+        this.renderer.render(this.editor.document, this.editor.selection);
+    }
+    /**
+     * Every prefix of a valid SmartPos.path addresses a real ancestor node
+     * (the same property ownerAt already relies on), so walking path prefixes
+     * from longest to shortest finds the nearest enclosing table_cell/table
+     * without any DOM lookup - the model-level equivalent of cellFromNode,
+     * usable from a plain SmartPos rather than a DOM event target.
+     */
+    tableAncestorsAt(pos) {
+        let cellId = null;
+        for (let length = pos.path.length; length >= 0; length -= 1) {
+            const node = nodeAtPath(this.editor.document, pos.path.slice(0, length));
+            if (!node || isTextNode(node))
+                continue;
+            if (!cellId && node.type === "table_cell")
+                cellId = node.id;
+            if (node.type === "table")
+                return cellId ? { tableId: node.id, cellId } : null;
+        }
+        return null;
+    }
+    /**
+     * Shift+Arrow rectangular cell-selection expansion (Phase 11 Tier 2 -
+     * previously no table-grid branch existed anywhere in arrow-key handling
+     * at all). Returns false when not applicable (anchor/head aren't both in
+     * the same table), letting the caller fall through to ordinary text-range
+     * arrow handling unchanged. Steps from the head cell's own top-left
+     * anchor corner - a reasonable v1 simplification for merged-cell edges,
+     * matching the existing renderer projection's own merge-snapping
+     * (surface/renderer.ts's syncCellSelectionProjection already snaps
+     * whatever rect the model selection implies through merged cells on
+     * render, so this does not need to duplicate that snapping here).
+     */
+    handleTableShiftArrow(rowDelta, colDelta) {
+        const selection = this.editor.selection;
+        const anchorInfo = this.tableAncestorsAt(selection.anchor);
+        const headInfo = this.tableAncestorsAt(selection.head);
+        if (!anchorInfo || !headInfo || anchorInfo.tableId !== headInfo.tableId)
+            return false;
+        const resolvedTable = this.editor.positions.positionOf(anchorInfo.tableId);
+        const tableNode = resolvedTable?.parent.children?.[resolvedTable.pos.offset];
+        if (!tableNode || isTextNode(tableNode) || tableNode.id !== anchorInfo.tableId)
+            return false;
+        const grid = occupancyGridFor(tableNode);
+        const headCell = grid.anchors.find((cell) => cell.cellId === headInfo.cellId);
+        if (!headCell)
+            return false;
+        const newRow = Math.min(grid.rows - 1, Math.max(0, headCell.top + rowDelta));
+        const newCol = Math.min(grid.columns - 1, Math.max(0, headCell.left + colDelta));
+        const target = grid.at(newRow, newCol);
+        if (!target)
+            return false;
+        const selectionResult = cellSelectionFromIds(anchorInfo.cellId, target.cellId, this.editor.positions);
+        if (!selectionResult)
+            return false;
+        this.editor.setSelection(selectionResult, { source: "keyboard" });
+        this.renderer.render(this.editor.document, this.editor.selection);
+        return true;
+    }
+    replaceSelection(text) {
+        const selection = this.editor.selection;
+        this.commit((builder) => {
+            if (this.trackChanges.enabled) {
+                const suggested = this.suggestReplaceSelection(builder, selection, text);
+                if (suggested)
+                    return suggested;
+            }
+            const caret = collapsed(selection) ? selection.head : queueRangeDeletion(this.editor, builder, normalizedRange(selection));
+            const marks = this.editor.storedMarks || marksAtInsertion(this.editor.document, caret, this.editor.schema);
+            if (text)
+                builder.operations.push({ type: "insertText", pos: caret, text, ...(marks.length ? { marks: [...marks] } : {}) });
+            const next = { path: [...caret.path], offset: caret.offset + text.length };
+            return { type: "text", anchor: next, head: next };
+        });
+    }
+    /**
+     * Ambient track-changes mode (Phase 12a §2.3 follow-up, 2026-08-25):
+     * typed text becomes a real, live "insert"-kind suggestion mark instead
+     * of a plain insertText, and content it replaces is marked "delete"
+     * instead of actually removed - the same reviewable-suggestion contract
+     * as the explicit Suggest deletion/Suggest insertion toolbar actions,
+     * just applied automatically to ordinary typing. Scoped to a selection
+     * that's collapsed or fully within one inline owner; returns null for a
+     * selection crossing multiple paragraphs, so the caller falls through to
+     * the real (non-suggested) path - proposing a delete that spans several
+     * paragraphs plus an insert needs per-owner handling this pass doesn't
+     * build (see docs/PHASE_ROADMAP_8B_12B.md's Phase 12a status note).
+     */
+    suggestReplaceSelection(builder, selection, text) {
+        const range = normalizedRange(selection);
+        if (!collapsed(selection) && !samePath(range.from.path, range.to.path))
+            return null;
+        const insertAt = collapsed(selection) ? selection.head : range.to;
+        if (!collapsed(selection))
+            builder.operations.push(suggestDeleteRangeOperation(range, { authorId: this.trackChanges.authorId }));
+        const marks = this.editor.storedMarks || marksAtInsertion(this.editor.document, insertAt, this.editor.schema);
+        if (text)
+            builder.operations.push(suggestInsertOperation(insertAt, text, { authorId: this.trackChanges.authorId }, marks));
+        const next = { path: [...insertAt.path], offset: insertAt.offset + text.length };
+        return { type: "text", anchor: next, head: next };
+    }
+    /**
+     * True exactly when queueRangeDeletion's own same-parent forward-sibling
+     * path can handle this range (see its cross-parent/type/order checks,
+     * which this mirrors) - i.e. the two endpoints are different children of
+     * the very same parent, with compatible owner types, in forward order.
+     * Deliberately does not attempt to be more permissive than
+     * queueRangeDeletion itself; anything this returns false for keeps
+     * falling through to structuralDeletionPlan exactly as before.
+     */
+    canMergeAsSiblings(range) {
+        const fromParent = range.from.path.slice(0, -1);
+        const toParent = range.to.path.slice(0, -1);
+        if (!samePath(fromParent, toParent))
+            return false;
+        const fromIndex = range.from.path[range.from.path.length - 1];
+        const toIndex = range.to.path[range.to.path.length - 1];
+        if (fromIndex >= toIndex)
+            return false;
+        let fromOwner;
+        let toOwner;
+        try {
+            fromOwner = ownerAt(this.editor, range.from);
+            toOwner = ownerAt(this.editor, range.to);
+        }
+        catch {
+            return false;
+        }
+        return fromOwner.type === toOwner.type;
+    }
+    deleteRange(range) {
+        if (samePos(range.from, range.to))
+            return;
+        this.commit((builder) => {
+            if (isWholeDocumentRange(this.editor, range)) {
+                const caret = queueWholeDocumentDeletion(this.editor, builder);
+                return { type: "text", anchor: caret, head: caret };
+            }
+            // A node/cell selection, or a text selection genuinely crossing
+            // structural parents (different list items, table cells, etc.), is
+            // not an inline range - resolve its semantic scope and remove the
+            // selected IDs; otherwise queueRangeDeletion would either silently do
+            // nothing (node selection) or throw on a legitimate nested list.
+            //
+            // A text selection whose endpoints are merely different SIBLINGS
+            // under the same parent (the ordinary "select from partway into one
+            // paragraph through partway into the next" gesture) is NOT such a
+            // case - queueRangeDeletion already handles it correctly (trims each
+            // end, removes any fully-covered siblings between them, merges the
+            // remainder). Routing it here instead was a real bug: block-range/
+            // container-tree scope resolution treats any block the selection
+            // merely touches as fully "in scope" (correct for a property-setting
+            // command like "make these headings," wrong for deletion, where
+            // partial coverage must mean trim-and-merge, not whole-block
+            // removal) - structuralDeletionPlan would then delete both siblings
+            // in their entirety, silently destroying the unselected prefix of
+            // the first and unselected suffix of the last. canMergeAsSiblings
+            // excludes exactly this case from the structural path.
+            const structural = (this.editor.selection.type !== "text"
+                || (!samePath(range.from.path, range.to.path) && !this.canMergeAsSiblings(range)))
+                ? structuralDeletionPlan(this.editor, this.editor.selection, range)
+                : null;
+            if (structural) {
+                builder.operations.push(...structural.operations);
+                const preview = applyOperations(this.editor.document, structural.operations);
+                const lookup = createScopeIndex().positions(preview, this.editor.schema);
+                const ownerId = structural.preferredOwnerIds.find((id) => lookup.exists(id))
+                    || firstEditableOwnerId(preview, this.editor.schema);
+                const content = ownerId ? lookup.contentRangeOf(ownerId) : null;
+                const caret = content?.from || { path: [], offset: 0 };
+                return { type: "text", anchor: caret, head: caret };
+            }
+            // Ambient track-changes mode: a same-owner range (the overwhelming
+            // majority of real Backspace/Delete presses - one character or word
+            // within one paragraph) is marked "delete" instead of removed. The
+            // multi-owner case above (structural) and the cross-block merge in
+            // deleteAcrossBlock are unaffected - see suggestReplaceSelection's
+            // doc comment for why that scope reduction is deliberate.
+            if (this.trackChanges.enabled && samePath(range.from.path, range.to.path)) {
+                builder.operations.push(suggestDeleteRangeOperation(range, { authorId: this.trackChanges.authorId }));
+                return { type: "text", anchor: range.from, head: range.from };
+            }
+            const caret = queueRangeDeletion(this.editor, builder, range);
+            return { type: "text", anchor: caret, head: caret };
+        });
+    }
+    /**
+     * Block atoms have no legal internal caret. When the browser reports a
+     * structural boundary beside one (including a node selection's head), move
+     * to the nearest editable block instead of manufacturing a position inside
+     * the atom. If the atom is at a container edge, create the empty paragraph
+     * that gives the user a real line to continue typing on.
+     */
+    moveFromStructuralBoundary(path, offset, direction) {
+        const parent = nodeAtPath(this.editor.document, path);
+        if (!parent || isTextNode(parent) || isInlineOwnerNode(parent, this.editor.schema))
+            return false;
+        const children = parent.children || [];
+        let cursor = direction < 0 ? offset - 1 : offset;
+        while (cursor >= 0 && cursor < children.length) {
+            const child = children[cursor];
+            if (!isTextNode(child) && this.editor.schema.nodes[child.type]?.atomic === true) {
+                cursor += direction;
+                continue;
+            }
+            const target = editableOwnerPosition(child, [...path, cursor], direction, this.editor.schema);
+            if (target) {
+                const model = { type: "text", anchor: target, head: target };
+                this.editor.setSelection(model, { source: "keyboard" });
+                this.renderer.render(this.editor.document, model);
+                return true;
+            }
+            cursor += direction;
+        }
+        // Only containers whose schema accepts blocks may receive the fallback
+        // paragraph. This keeps the operation valid inside a document, list item,
+        // quote, or table cell while refusing to put content inside an atom.
+        const content = this.editor.schema.nodes[parent.type]?.content || "";
+        if (parent.type !== "doc" && !/(?:^|[|(\s])block(?:[+*?]|$)/.test(content))
+            return false;
+        const insertionIndex = direction > 0
+            ? Math.max(0, Math.min(children.length, cursor))
+            : Math.max(0, Math.min(children.length, cursor + 1));
+        const paragraph = { type: "paragraph", id: createNodeId(), children: [] };
+        const target = { path: [...path, insertionIndex], offset: 0 };
+        this.editor.transact((builder) => {
+            builder.operations.push({ type: "insertNode", pos: { path: [...path], offset: insertionIndex }, node: paragraph });
+            builder.setSelection({ type: "text", anchor: target, head: target });
+        }, { source: "keyboard", addToHistory: true });
+        this.renderer.render(this.editor.document, this.editor.selection);
+        return true;
+    }
+    insertParagraph() {
+        const selection = this.editor.selection;
+        if (collapsed(selection)) {
+            const listResult = enterInList(this.editor.document, selection.head, {
+                itemId: createNodeId(), blockId: createNodeId(), emptyBlockId: createNodeId(), splitListId: createNodeId(),
+            }, this.commandContext());
+            if (listResult)
+                return this.commitStructuralResult(listResult);
+            const codeResult = insertCodeBlockNewline(this.editor.document, selection.head, {
+                exitOnTrailingEmptyLine: true,
+                paragraphId: createNodeId(),
+            });
+            if (codeResult)
+                return this.commitStructuralResult(codeResult);
+        }
+        this.commit((builder) => {
+            const caret = collapsed(selection) ? selection.head : queueRangeDeletion(this.editor, builder, normalizedRange(selection));
+            const owner = ownerAt(this.editor, caret);
+            const parentPath = caret.path.slice(0, -1);
+            const index = caret.path[caret.path.length - 1];
+            const text = inlineText(owner);
+            const tail = text.slice(caret.offset);
+            const [, tailChildren] = splitInlineChildren(owner.children || [], caret.offset);
+            const activeMarks = marksAtInsertion(this.editor.document, caret, this.editor.schema);
+            queueInlineDeletion(builder, caret.path, owner, caret.offset, text.length);
+            const nextNode = {
+                type: owner.type,
+                id: createNodeId(),
+                ...(owner.attrs ? { attrs: structuredClone(owner.attrs) } : {}),
+                children: tail ? tailChildren : [],
+            };
+            builder.operations.push({ type: "insertNode", pos: { path: parentPath, offset: index + 1 }, node: nextNode });
+            const next = { path: [...parentPath, index + 1], offset: 0 };
+            // An empty split still needs the marks active at the caret for the next
+            // insertion.  The transaction would otherwise clear stored marks as a
+            // side effect of its structural operations.
+            builder.setStoredMarks(activeMarks.length ? activeMarks : undefined);
+            return { type: "text", anchor: next, head: next };
+        });
+    }
+    insertLineBreak() {
+        const selection = this.editor.selection;
+        if (collapsed(selection)) {
+            const codeResult = insertCodeBlockNewline(this.editor.document, selection.head);
+            if (codeResult)
+                return this.commitStructuralResult(codeResult);
+        }
+        const operations = [];
+        const builder = new TransactionBuilder(selection, this.editor.storedMarks ? [...this.editor.storedMarks] : undefined);
+        const caret = collapsed(selection) ? selection.head : queueRangeDeletion(this.editor, builder, normalizedRange(selection));
+        operations.push(...builder.operations);
+        const preview = operations.length ? applyOperations(this.editor.document, operations) : this.editor.document;
+        operations.push(...insertHardBreak(preview, caret));
+        const next = { path: [...caret.path], offset: caret.offset + 1 };
+        this.editor.transact((transaction) => {
+            transaction.operations.push(...operations);
+            transaction.setSelection({ type: "text", anchor: next, head: next });
+        }, { source: "input", addToHistory: true });
+        this.renderer.render(this.editor.document, this.editor.selection);
+    }
+    deleteByInputType(inputType) {
+        const selection = this.editor.selection;
+        if (!collapsed(selection))
+            return this.deleteRange(normalizedRange(selection));
+        const owner = ownerAt(this.editor, selection.head);
+        const text = inlineText(owner);
+        const offset = selection.head.offset;
+        if (inputType === "deleteContentBackward" || inputType === "deleteContentForward") {
+            const structural = inputType.endsWith("Backward")
+                ? backspaceAtListItemStart(this.editor.document, selection.head, this.commandContext())
+                : deleteAtListItemEnd(this.editor.document, selection.head, this.commandContext());
+            if (structural)
+                return this.commitStructuralResult(structural);
+            const boundaries = inlineGraphemeBoundaries(owner.children || []);
+            const target = inputType.endsWith("Backward")
+                ? [...boundaries].reverse().find((boundary) => boundary < offset)
+                : boundaries.find((boundary) => boundary > offset);
+            if (target !== undefined)
+                return this.deleteRange(inputType.endsWith("Backward")
+                    ? { from: { ...selection.head, offset: target }, to: selection.head }
+                    : { from: selection.head, to: { ...selection.head, offset: target } });
+            return this.deleteAcrossBlock(inputType.endsWith("Backward") ? -1 : 1);
+        }
+        const backward = inputType.endsWith("Backward");
+        const target = inputType === "deleteSoftLineBackward" ? 0 : backward ? previousWord(text, offset) : nextWord(text, offset);
+        this.deleteRange(backward
+            ? { from: { ...selection.head, offset: target }, to: selection.head }
+            : { from: selection.head, to: { ...selection.head, offset: target } });
+    }
+    deleteAcrossBlock(direction) {
+        const position = this.editor.selection.head;
+        const current = nodeAtPath(this.editor.document, position.path);
+        if (!current || isTextNode(current) || !isInlineOwnerNode(current, this.editor.schema))
+            return;
+        // Preserve the existing atom selection affordance for a directly adjacent
+        // block atom. A block atom is selected first and deleted on the next key,
+        // rather than being silently consumed by a cross-container merge.
+        if (position.path.length) {
+            const parentPath = position.path.slice(0, -1);
+            const index = position.path[position.path.length - 1];
+            const parent = nodeAtPath(this.editor.document, parentPath);
+            const neighbor = parent && !isTextNode(parent) ? parent.children?.[index + direction] : undefined;
+            if (neighbor && !isTextNode(neighbor) && this.editor.schema.nodes[neighbor.type]?.atomic === true) {
+                const range = this.editor.positions.rangeOf(neighbor.id);
+                if (range) {
+                    this.editor.setSelection({ type: "node", anchor: range.from, head: range.to }, { source: "keyboard" });
+                    this.renderer.render(this.editor.document, this.editor.selection);
+                }
+                return;
+            }
+        }
+        const owners = editableOwners(this.editor.document, [], this.editor.schema);
+        const currentIndex = owners.findIndex((entry) => entry.node.id === current.id);
+        const adjacent = currentIndex >= 0 ? owners[currentIndex + direction] : undefined;
+        if (!adjacent)
+            return;
+        const target = direction < 0
+            ? resolvePrecedingContentTarget(this.editor.document, current.id, this.commandContext())
+            : null;
+        const targetOwner = direction < 0
+            ? target && nodeAtPath(this.editor.document, this.editor.positions.contentRangeOf(target.ownerId)?.from.path || [])
+            : adjacent.node;
+        const targetId = direction < 0 ? target?.ownerId : adjacent.node.id;
+        if (!targetOwner || isTextNode(targetOwner) || !targetId || targetOwner.id === current.id)
+            return;
+        const currentPosition = this.editor.positions.positionOf(current.id);
+        const targetPosition = this.editor.positions.positionOf(targetId);
+        if (!currentPosition || !targetPosition)
+            return;
+        // A blank line at a structural boundary is removed as a block, leaving
+        // the caret at the nearest visible content. This is the path exercised
+        // after Enter twice exits a depth-zero list. Do not merge an empty quote
+        // paragraph with the outside boundary paragraph: that would re-enter the
+        // quote's content instead of exiting its scope.
+        if (inlineText(current) === "") {
+            const targetRange = this.editor.positions.contentRangeOf(targetId);
+            if (!targetRange)
+                return;
+            const targetSelection = {
+                type: "text",
+                anchor: direction < 0 ? targetRange.to : targetRange.from,
+                head: direction < 0 ? targetRange.to : targetRange.from,
+            };
+            const operations = [{ type: "removeNode", pos: currentPosition.pos, node: current }];
+            const mappedSelection = new FoundationTransactionMap(operations).mapSelection(targetSelection);
+            this.editor.transact((builder) => {
+                builder.operations.push(...operations);
+                builder.setSelection(mappedSelection);
+            }, { source: "input", addToHistory: true });
+            this.renderer.render(this.editor.document, this.editor.selection);
+            return;
+        }
+        if (targetOwner.type !== current.type)
+            return;
+        const targetChildren = direction < 0
+            ? [...(targetOwner.children || []), ...(current.children || []).map((node) => structuredClone(node))]
+            : [...(current.children || []), ...(targetOwner.children || []).map((node) => structuredClone(node))];
+        // Backward deletion keeps the preceding owner; forward deletion keeps the
+        // current owner.  Keeping the owner at the caret is the identity contract
+        // used by ordinary cross-block deletion and prevents annotations on the
+        // active block from being retired merely because its content was joined.
+        const survivingOwner = direction < 0 ? targetOwner : current;
+        const removedOwner = direction < 0 ? current : targetOwner;
+        const survivingPosition = direction < 0 ? targetPosition : currentPosition;
+        const removedPosition = direction < 0 ? currentPosition : targetPosition;
+        const merged = { ...survivingOwner, children: targetChildren };
+        const survivingContent = this.editor.positions.contentRangeOf(survivingOwner.id);
+        if (!survivingContent)
+            return;
+        const selectionOffset = direction < 0 ? survivingContent.to.offset : inlineText(current).length;
+        const targetSelection = {
+            type: "text",
+            anchor: direction < 0
+                ? { path: [...survivingContent.to.path], offset: selectionOffset }
+                : { path: [...survivingContent.from.path], offset: selectionOffset },
+            head: direction < 0
+                ? { path: [...survivingContent.to.path], offset: selectionOffset }
+                : { path: [...survivingContent.from.path], offset: selectionOffset },
+        };
+        // The removed owner's content was just absorbed into survivingOwner
+        // (targetChildren, above) - mark it so an AnnotationRange anchored
+        // inside it (e.g. a comment) snaps to the survivor instead of silently
+        // failing to resolve. This is the real cross-block Backspace/Delete
+        // merge path (collapsed caret at a block boundary) - distinct from
+        // queueRangeDeletion's mergeNode operation, which only fires for a
+        // non-collapsed selection spanning multiple blocks. Same pattern as
+        // mergeTableCellsCommand/mergeItems.
+        const operations = [
+            { type: "replaceNode", pos: survivingPosition.pos, before: survivingOwner, after: merged },
+            { type: "removeNode", pos: removedPosition.pos, node: removedOwner, mergedInto: survivingOwner.id },
+        ];
+        // Forward deletion removes the current owner before the target's old
+        // path. Map the selection through both operations instead of retaining a
+        // stale path (the exact failure after Enter twice exits a list in a
+        // quote). Backward deletion uses the same mapping for symmetry.
+        const mappedSelection = new FoundationTransactionMap(operations).mapSelection(targetSelection);
+        this.editor.transact((builder) => {
+            builder.operations.push(...operations);
+            builder.setSelection(mappedSelection);
+        }, { source: "input", addToHistory: true });
+        this.renderer.render(this.editor.document, this.editor.selection);
+    }
+    handleBeforeInput(event) {
+        if (this.destroyed)
+            return;
+        const type = event.inputType;
+        // Browsers may dispatch beforeinput for a keyboard selection mutation
+        // before the asynchronous selectionchange event reaches the document.
+        // Refresh the model from the native selection first, otherwise Ctrl/Cmd+A
+        // followed immediately by Backspace/Delete is mistaken for a collapsed
+        // caret at the old location.
+        // A canonical node selection is already the semantic selection for the
+        // upcoming replacement/deletion.  The renderer projects it as a native
+        // range over the node's contents, which is intentionally not a text range
+        // to be re-imported here (doing so turns a selected quote/code node into a
+        // paragraph selection and leaves the node behind).
+        const preserveNodeSelection = this.editor.selection.type === "node"
+            && (type === "deleteContentBackward" || type === "deleteContentForward"
+                || type === "insertText" || type === "insertReplacementText");
+        if (!this.composition && !preserveNodeSelection)
+            this.syncSelectionFromDom();
+        if (this.composition && (type === "insertCompositionText" || type === "deleteCompositionText"))
+            return;
+        if (this.editor.selection.type === "node" && (type === "insertText" || type === "insertReplacementText"
+            || type === "deleteContentBackward" || type === "deleteContentForward")) {
+            const scope = this.editor.resolveScope({ want: "atomic-node" });
+            if ("kind" in scope && scope.kind === "atomic-node") {
+                event.preventDefault();
+                const resolved = this.editor.positions.positionOf(scope.nodeId);
+                const node = resolved?.parent.children?.[resolved.pos.offset];
+                if (!resolved || !node || isTextNode(node))
+                    return;
+                const group = this.editor.schema.nodes[node.type]?.group;
+                const text = type === "insertText" || type === "insertReplacementText" ? event.data || "" : "";
+                this.editor.transact((builder) => {
+                    if (group === "inline") {
+                        builder.operations.push({ type: "removeNode", pos: resolved.pos, node });
+                        if (text)
+                            builder.operations.push({ type: "insertText", pos: scope.range.from, text });
+                        const caret = { path: [...scope.range.from.path], offset: scope.range.from.offset + text.length };
+                        builder.setSelection({ type: "text", anchor: caret, head: caret });
+                    }
+                    else {
+                        const replacement = { type: "paragraph", id: createNodeId(), children: text ? [{ type: "text", text }] : [] };
+                        builder.operations.push({ type: "replaceNode", pos: resolved.pos, before: node, after: replacement });
+                        const caret = { path: [...resolved.pos.path, resolved.pos.offset], offset: text.length };
+                        builder.setSelection({ type: "text", anchor: caret, head: caret });
+                    }
+                }, { source: "input", addToHistory: true });
+                this.renderer.render(this.editor.document, this.editor.selection);
+                return;
+            }
+        }
+        if (type === "insertText" || type === "insertReplacementText") {
+            event.preventDefault();
+            this.replaceSelection(event.data || "");
+        }
+        else if (type === "insertParagraph") {
+            event.preventDefault();
+            this.insertParagraph();
+        }
+        else if (type === "insertLineBreak") {
+            event.preventDefault();
+            this.insertLineBreak();
+        }
+        else if (["formatBold", "formatItalic", "formatUnderline", "formatStrikeThrough"].includes(type)) {
+            event.preventDefault();
+            const id = type === "formatBold" ? "bold" : type === "formatItalic" ? "italic" : type === "formatUnderline" ? "underline" : "strikethrough";
+            const declaration = inlineToolDeclarations.find((tool) => tool.id === id);
+            executeMarkTool(this.editor, declaration, "toggle");
+            this.renderer.render(this.editor.document, this.editor.selection);
+        }
+        else if (["deleteContentBackward", "deleteContentForward", "deleteWordBackward", "deleteWordForward", "deleteSoftLineBackward"].includes(type)) {
+            event.preventDefault();
+            this.deleteByInputType(type);
+        }
+        else if (type === "historyUndo" || type === "historyRedo") {
+            event.preventDefault();
+            if (type === "historyUndo")
+                this.editor.undo();
+            else
+                this.editor.redo();
+            this.renderer.render(this.editor.document, this.editor.selection);
+        }
+        else if (["insertFromPaste", "insertFromDrop", "deleteByCut"].includes(type)) {
+            // Owned by paste/drop/cut events, which carry the actual transfer payload.
+            event.preventDefault();
+        }
+        else {
+            event.preventDefault();
+            this.unhandled.push(type || "unknown");
+            console.warn(`[Smart RTE canonical input] cancelled unsupported inputType: ${type || "unknown"}`);
+        }
+    }
+    moveCaret(direction, word = false) {
+        const selection = this.editor.selection;
+        const active = selection.head;
+        const activeOwner = nodeAtPath(this.editor.document, active.path);
+        if (activeOwner && !isTextNode(activeOwner) && !isInlineOwnerNode(activeOwner, this.editor.schema)) {
+            if (this.moveFromStructuralBoundary(active.path, active.offset, direction))
+                return;
+            return;
+        }
+        const owner = ownerAt(this.editor, active);
+        const text = inlineText(owner);
+        let offset = word
+            ? direction < 0 ? previousWord(text, active.offset) : nextWord(text, active.offset)
+            : direction < 0
+                ? [...inlineGraphemeBoundaries(owner.children || [])].reverse().find((value) => value < active.offset) ?? active.offset
+                : inlineGraphemeBoundaries(owner.children || []).find((value) => value > active.offset) ?? active.offset;
+        let path = active.path;
+        if (offset === active.offset) {
+            const parentPath = active.path.slice(0, -1);
+            const siblingIndex = active.path.length ? active.path[active.path.length - 1] + direction : -1;
+            const parent = active.path.length ? nodeAtPath(this.editor.document, parentPath) : undefined;
+            const neighbor = !parent || isTextNode(parent) ? undefined : parent.children?.[siblingIndex];
+            if (neighbor && !isTextNode(neighbor)) {
+                // Enter a structural sibling through its nearest editable owner. The
+                // previous implementation treated the structural node itself as an
+                // inline owner, which made quote/table edges unreachable and left the
+                // browser selection on an address with no caret.
+                const target = editableOwnerPosition(neighbor, [...parentPath, siblingIndex], direction, this.editor.schema);
+                if (target) {
+                    path = target.path;
+                    offset = target.offset;
+                }
+                else if (this.moveFromStructuralBoundary(parentPath, direction > 0 ? siblingIndex : siblingIndex + 1, direction)) {
+                    return;
+                }
+            }
+            else {
+                // A quote or table may be separated from the current owner by a
+                // structural ancestor. Walk logical owner order rather than only the
+                // immediate sibling array, so arrows cross nested containers and the
+                // editable boundary paragraphs installed by the normalizer.
+                const owners = editableOwners(this.editor.document, [], this.editor.schema);
+                const currentIndex = owners.findIndex((entry) => entry.path.length === active.path.length
+                    && entry.path.every((part, index) => part === active.path[index]));
+                const adjacent = currentIndex >= 0 ? owners[currentIndex + direction] : undefined;
+                if (adjacent) {
+                    path = adjacent.path;
+                    offset = direction < 0 ? inlineText(adjacent.node).length : 0;
+                }
+            }
+        }
+        const next = { path: [...path], offset };
+        const model = { type: "text", anchor: next, head: next };
+        this.editor.setSelection(model, { source: "keyboard" });
+        this.renderer.render(this.editor.document, model);
+    }
+    handleKeyDown(event) {
+        // Selectionchange is delivered asynchronously in Chromium.  A keyboard
+        // navigation key can therefore arrive immediately after Ctrl/Cmd+A while
+        // the native range is document-wide but the canonical selection still
+        // describes the previous owner.  Import the current native range before
+        // directional handling so ArrowUp/Down never operates on stale paths.
+        // Home/End and Enter's own modifier branches below (Ctrl/Cmd+Enter,
+        // Shift+Enter) read `this.editor.selection.head` synchronously too, and
+        // are exposed to the exact same race - most visibly, a real click
+        // immediately followed by End: Home/End's handler used to trust the
+        // still-stale selection, compute "end of the stale owner", and
+        // explicitly commit + render *that* wrong position - actively moving
+        // the real caret away from wherever the click had just placed it (for
+        // example out of a code block nested in a blockquote and onto an
+        // unrelated preceding paragraph), so a subsequent Enter then genuinely
+        // operated on the wrong position instead of merely reading it wrong.
+        // Plain Enter is additionally covered by the beforeinput handler's own
+        // resync, but the modifier branches here fire before that ever runs.
+        if (!this.composition && ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "Home", "End", "Enter"].includes(event.key)) {
+            this.syncSelectionFromDom();
+        }
+        const modifier = event.metaKey || event.ctrlKey;
+        if (event.key === "Enter" && modifier && !event.shiftKey) {
+            const result = exitCodeBlock(this.editor.document, this.editor.selection.head, createNodeId());
+            if (result) {
+                event.preventDefault();
+                this.commitStructuralResult(result, "keyboard");
+                return;
+            }
+        }
+        // WebKit does not consistently surface Shift+Enter as
+        // beforeinput(insertLineBreak). Own the intent at keydown so every browser
+        // produces the same atomic hard_break representation.
+        if (event.key === "Enter" && event.shiftKey && !modifier) {
+            event.preventDefault();
+            this.insertLineBreak();
+            return;
+        }
+        const shortcut = modifier ? { b: "bold", i: "italic", u: "underline" }[event.key.toLowerCase()] : undefined;
+        if (shortcut) {
+            event.preventDefault();
+            executeMarkTool(this.editor, inlineToolDeclarations.find((tool) => tool.id === shortcut), "toggle");
+            this.renderer.render(this.editor.document, this.editor.selection);
+            return;
+        }
+        if (modifier && event.key.toLowerCase() === "k") {
+            event.preventDefault();
+            this.root.dispatchEvent(new CustomEvent("smart-link-request", { bubbles: true }));
+            return;
+        }
+        if (modifier && event.key.toLowerCase() === "z") {
+            event.preventDefault();
+            if (event.shiftKey)
+                this.editor.redo();
+            else
+                this.editor.undo();
+            this.renderer.render(this.editor.document, this.editor.selection);
+            return;
+        }
+        if (modifier && event.key.toLowerCase() === "y") {
+            event.preventDefault();
+            this.editor.redo();
+            this.renderer.render(this.editor.document, this.editor.selection);
+            return;
+        }
+        if (event.key === "Tab") {
+            const active = this.editor.selection.head;
+            const description = this.editor.resolveScope({ want: "describe" });
+            const inTable = "inTable" in description && Boolean(description.inTable);
+            // Data-driven replacement for the old hardcoded code/list/table
+            // precedence if-chain: try each registered Tab contribution (block's
+            // code-indent, list's indent/outdent - priority 20 before 10, see
+            // block/plugin.ts and list/plugin.ts) in order, actually resolving its
+            // declared scope and running its real command, and only counting it as
+            // a match if that produces real operations. Nothing is declared for
+            // table-grid, so a table caret always falls through unmatched, same as
+            // before. `inTable` short-circuits list contributions specifically:
+            // a list nested inside a table cell still yields Tab to the table,
+            // exactly as the old chain did.
+            const resolved = resolveShortcut(this.editor.keyboardShortcuts, { key: "Tab", shiftKey: event.shiftKey }, (shortcut) => {
+                const command = this.editor.commands.get(shortcut.commandId);
+                if (!command)
+                    return null;
+                if (inTable && (shortcut.commandId === "list.indent" || shortcut.commandId === "list.outdent"))
+                    return null;
+                const wanted = shortcut.scopeKinds[0];
+                if (wanted === "mixed" || wanted === "empty")
+                    return null;
+                const scope = this.editor.resolveScope({ want: wanted });
+                if (!("kind" in scope) || scope.kind !== wanted)
+                    return null;
+                const params = shortcut.commandId === "list.indent" ? { nestedListIds: [createNodeId()] }
+                    : shortcut.commandId === "list.outdent" ? { splitListIds: [createNodeId()] }
+                        : shortcut.params;
+                return command.run(this.editor.document, scope, params, this.commandContext());
+            });
+            if (resolved) {
+                event.preventDefault();
+                const { shortcut, operations } = resolved;
+                const selectionTarget = shortcut.commandId === "block.code.indentTab"
+                    ? { ownerId: ownerAt(this.editor, active).id, offset: active.offset + 1 }
+                    : { ownerId: ownerAt(this.editor, active).id, offset: active.offset };
+                const intent = shortcut.commandId === "list.outdent" ? "outdent" : "indent";
+                this.commitStructuralResult({ operations: [...operations], selectionTarget, intent }, "keyboard");
+                return;
+            }
+            // Tab inside a list item is always ours to handle, even when there is
+            // no legal indent/outdent (e.g. the first item, or already at the max
+            // legal depth) — preventDefault unconditionally here, or the browser
+            // falls through to its native Tab-to-next-focusable-element behavior
+            // and keyboard focus silently leaves the editor entirely.
+            if (!inTable && listItemAt(this.editor.document, active)) {
+                event.preventDefault();
+                return;
+            }
+            if (inTable && description.inTable) {
+                event.preventDefault();
+                this.handleTableTab(description.inTable.tableId, description.inTable.cellId, event.shiftKey);
+                return;
+            }
+            return;
+        }
+        // Space is ordinary text while the caret is inside a checklist item.  When
+        // keyboard focus is actually on the projected checkbox button, preserve
+        // native button semantics by routing Space to the same click path.  The
+        // focus check is essential: a global checklist-item shortcut makes a
+        // sentence such as "Buy milk" toggle the item and drops the separator.
+        if ((event.key === " " || event.key === "Spacebar")
+            && this.ownerDocument.activeElement instanceof Element) {
+            const checkControl = this.ownerDocument.activeElement.closest(`[${SMART_UI_ATTRIBUTE}="check-control"]`);
+            if (checkControl) {
+                event.preventDefault();
+                checkControl.click();
+                return;
+            }
+        }
+        if (event.key === "ArrowLeft" || event.key === "ArrowRight") {
+            const direction = event.key === "ArrowLeft" ? -1 : 1;
+            if (event.shiftKey && this.handleTableShiftArrow(0, direction)) {
+                event.preventDefault();
+                return;
+            }
+            event.preventDefault();
+            // Plain arrows collapse a range to its normalized endpoint.  Reading
+            // `selection.head` here makes the result depend on drag direction,
+            // violating the anchor/head contract and reversing Left/Right for a
+            // bottom-to-top selection.
+            if (!event.shiftKey && this.editor.selection.type === "text" && !collapsed(this.editor.selection)) {
+                const range = normalizedRange(this.editor.selection);
+                const target = direction < 0 ? range.from : range.to;
+                const model = { type: "text", anchor: target, head: target };
+                this.editor.setSelection(model, { source: "keyboard" });
+                this.renderer.render(this.editor.document, model);
+                return;
+            }
+            this.moveCaret(direction, modifier || event.altKey);
+        }
+        else if (event.key === "ArrowUp" || event.key === "ArrowDown") {
+            if (event.shiftKey && this.handleTableShiftArrow(event.key === "ArrowUp" ? -1 : 1, 0)) {
+                event.preventDefault();
+                return;
+            }
+            if (this.editor.selection.type === "node") {
+                // Native vertical movement has no useful target while a block atom is
+                // selected. Treat it as movement to the preceding/following editable
+                // line, matching left/right atom-boundary navigation.
+                event.preventDefault();
+                this.moveCaret(event.key === "ArrowUp" ? -1 : 1);
+            }
+            else if (!event.shiftKey && this.editor.selection.type === "text" && !collapsed(this.editor.selection)
+                && isWholeDocumentRange(this.editor, normalizedRange(this.editor.selection))) {
+                // Native vertical-arrow collapse of a whole-document (Ctrl/Cmd+A)
+                // selection is unreliable once the document contains structural
+                // content (lists, tables): the browser's own notion of where
+                // selection "focus" lands after select-all does not consistently
+                // resolve to the true first/last editable position once nested
+                // containers are involved, so ArrowDown can land mid-document
+                // instead of at the real end (and symmetrically for ArrowUp/start).
+                // Ordinary, non-whole-document vertical movement is deliberately
+                // left native above (real line-based caret movement isn't something
+                // the model layer can replicate) - only this specific, well-defined
+                // state is collapsed deterministically here, reusing the same
+                // document-order editable-owner walk moveCaret already relies on for
+                // cross-container navigation.
+                event.preventDefault();
+                const owners = editableOwners(this.editor.document, [], this.editor.schema);
+                const target = event.key === "ArrowUp" ? owners[0] : owners[owners.length - 1];
+                if (target) {
+                    const pos = { path: [...target.path], offset: event.key === "ArrowUp" ? 0 : inlineText(target.node).length };
+                    const model = { type: "text", anchor: pos, head: pos };
+                    this.editor.setSelection(model, { source: "keyboard" });
+                    this.renderer.render(this.editor.document, model);
+                }
+            }
+        }
+        else if (event.key === "Home" || event.key === "End") {
+            event.preventDefault();
+            const active = this.editor.selection.head;
+            const owner = ownerAt(this.editor, active);
+            const next = { path: [...active.path], offset: event.key === "Home" ? 0 : inlineText(owner).length };
+            // Shift+Home/End is the standard "select to line start/end" gesture -
+            // this previously collapsed to `next` unconditionally, discarding
+            // the existing anchor regardless of the Shift key, so Shift+Home/
+            // End could never actually select anything; it only ever moved the
+            // caret. Preserve the current anchor when extending.
+            const anchor = event.shiftKey ? this.editor.selection.anchor : next;
+            const model = { type: "text", anchor, head: next };
+            this.editor.setSelection(model, { source: "keyboard" });
+            this.renderer.render(this.editor.document, model);
+        }
+    }
+    handleCompositionStart(_event) {
+        const selection = this.editor.selection;
+        const owner = ownerAt(this.editor, selection.head);
+        const element = this.renderer.mapping.nodeToDom(owner.id);
+        const observer = element && typeof MutationObserver !== "undefined" ? new MutationObserver(() => undefined) : null;
+        observer?.observe(element, { subtree: true, childList: true, characterData: true });
+        this.composition = {
+            id: createNodeId(), ownerId: owner.id, ownerPath: [...selection.head.path], beforeText: inlineText(owner), selectionBefore: selection, observer,
+            beforeTokens: tokenizeCompositionOwner(owner),
+            activeMarks: [...(this.editor.storedMarks || marksAtInsertion(this.editor.document, selection.head, this.editor.schema))],
+        };
+        this.renderer.beginComposition(owner.id);
+    }
+    /** DOM remains authoritative; updates are intentionally observed, not rendered. */
+    handleCompositionUpdate(_event) { }
+    handleCompositionEnd(_event) {
+        const state = this.composition;
+        if (!state)
+            return;
+        state.observer?.disconnect();
+        const element = this.renderer.mapping.nodeToDom(state.ownerId);
+        const afterTokens = [];
+        if (element) {
+            [...element.childNodes].forEach((direct) => {
+                const directElement = direct instanceof HTMLElement ? direct : direct.parentElement;
+                if (directElement?.closest("[data-smart-ui]"))
+                    return;
+                const atomic = directElement?.closest("[data-smart-atomic]");
+                if (atomic) {
+                    const mapped = this.renderer.mapping.domToNode(atomic);
+                    if (mapped && !isTextNode(mapped.node))
+                        afterTokens.push({ kind: "atom", nodeId: mapped.node.id, atomType: mapped.node.type });
+                    return;
+                }
+                const text = direct.textContent || "";
+                if (!text)
+                    return;
+                const marks = [];
+                const walker = element.ownerDocument.createTreeWalker(direct, NodeFilter.SHOW_TEXT);
+                const firstText = direct.nodeType === direct.TEXT_NODE ? direct : walker.nextNode();
+                let cursor = firstText?.parentElement || null;
+                while (cursor && cursor !== element) {
+                    const type = cursor.getAttribute("data-smart-mark");
+                    if (type) {
+                        const raw = cursor.getAttribute("data-smart-mark-attrs");
+                        marks.push({ type, ...(raw ? { attrs: JSON.parse(raw) } : {}) });
+                    }
+                    cursor = cursor.parentElement;
+                }
+                afterTokens.push({ kind: "text", text, marks: canonicalMarkOrder(marks) });
+            });
+        }
+        const beforeUnits = tokenUnits(state.beforeTokens);
+        const afterUnits = tokenUnits(afterTokens);
+        let prefix = 0;
+        while (prefix < beforeUnits.length && prefix < afterUnits.length
+            && beforeUnits[prefix].char === afterUnits[prefix].char && beforeUnits[prefix].key === afterUnits[prefix].key)
+            prefix += 1;
+        let suffix = 0;
+        while (suffix < beforeUnits.length - prefix && suffix < afterUnits.length - prefix
+            && beforeUnits[beforeUnits.length - 1 - suffix].char === afterUnits[afterUnits.length - 1 - suffix].char
+            && beforeUnits[beforeUnits.length - 1 - suffix].key === afterUnits[afterUnits.length - 1 - suffix].key)
+            suffix += 1;
+        const removed = beforeUnits.slice(prefix, beforeUnits.length - suffix);
+        const inserted = afterUnits.slice(prefix, afterUnits.length - suffix);
+        const domSelection = this.ownerDocument.getSelection();
+        const domCaret = domSelection?.focusNode ? this.renderer.mapping.domToPos(domSelection.focusNode, domSelection.focusOffset) : null;
+        this.renderer.endComposition();
+        this.composition = null;
+        // Atoms are opaque composition boundaries. If a browser mutation crosses,
+        // reject the DOM mutation and restore the unchanged canonical owner.
+        if (removed.some((unit) => unit.kind === "atom") || inserted.some((unit) => unit.kind === "atom")) {
+            return this.renderer.render(this.editor.document, this.editor.selection);
+        }
+        if (!removed.length && !inserted.length)
+            return this.renderer.render(this.editor.document, this.editor.selection);
+        this.commit((builder) => {
+            if (removed.length)
+                queueInlineDeletion(builder, state.ownerPath, ownerAt(this.editor, { path: state.ownerPath, offset: prefix }), prefix, prefix + removed.length);
+            let insertedOffset = 0;
+            while (insertedOffset < inserted.length) {
+                const key = inserted[insertedOffset].key;
+                let end = insertedOffset + 1;
+                while (end < inserted.length && inserted[end].key === key)
+                    end += 1;
+                const text = inserted.slice(insertedOffset, end).map((unit) => unit.char).join("");
+                const marks = inserted[insertedOffset].marks.length ? inserted[insertedOffset].marks : state.activeMarks;
+                builder.operations.push({ type: "insertText", pos: { path: state.ownerPath, offset: prefix + insertedOffset }, text, ...(marks.length ? { marks } : {}) });
+                insertedOffset = end;
+            }
+            const caret = domCaret || { path: state.ownerPath, offset: prefix + inserted.length };
+            return { type: "text", anchor: caret, head: caret };
+        }, { compositionId: state.id });
+    }
+    setTrackChanges(enabled, authorId) {
+        this.trackChanges = { enabled, authorId: authorId ?? this.trackChanges.authorId };
+    }
+    syncSelectionFromDom() {
+        if (this.destroyed || this.composition)
+            return;
+        const native = this.ownerDocument.getSelection();
+        if (!native?.anchorNode || !native.focusNode || !this.root.contains(native.anchorNode) || !this.root.contains(native.focusNode))
+            return;
+        const anchor = this.renderer.mapping.domToPos(native.anchorNode, native.anchorOffset);
+        const head = this.renderer.mapping.domToPos(native.focusNode, native.focusOffset);
+        if (!anchor || !head)
+            return;
+        // A selectable atom is projected as a native range spanning its parent
+        // boundary.  The browser emits `selectionchange` after that projection,
+        // and importing the range as a text selection would immediately discard
+        // the semantic node selection that the atom click established.  Preserve
+        // it only when the native endpoints are exactly the node range; a
+        // genuinely different native range must still replace the node selection.
+        const current = this.editor.selection;
+        if (current.type === "node") {
+            const currentRange = normalizedRange(current);
+            if (samePos(anchor, currentRange.from) && samePos(head, currentRange.to))
+                return;
+            if (samePos(anchor, currentRange.to) && samePos(head, currentRange.from))
+                return;
+        }
+        // A cell selection is projected as a native range spanning the selected
+        // cell boundaries.  The browser emits `selectionchange` for that
+        // projection; importing the endpoints as a text selection would lose the
+        // semantic cell selection (and, after a merge, make the result depend on
+        // which render frame happened to win). Preserve it while the native range
+        // still represents the same model endpoints. A genuinely different click
+        // or drag maps to a new selection below.
+        if (current.type === "cell") {
+            if (samePos(anchor, current.anchor) && samePos(head, current.head))
+                return;
+            if (samePos(anchor, current.head) && samePos(head, current.anchor))
+                return;
+        }
+        // A native selection may collapse on the editable root (or another
+        // structural container) instead of an inline owner. Keep that DOM detail
+        // out of canonical state: root offset `children.length`, in particular,
+        // is the browser's representation of "below the final blockquote" and
+        // would otherwise leave ownerAt() with an unusable document path.
+        const collapsedNative = native.isCollapsed;
+        const normalizedAnchor = editablePositionForStructuralBoundary(this.editor, anchor, collapsedNative ? (anchor.offset === 0 ? 1 : -1) : 1) || anchor;
+        const normalizedHead = editablePositionForStructuralBoundary(this.editor, head, collapsedNative ? (head.offset === 0 ? 1 : -1) : -1) || head;
+        let model = { type: "text", anchor: normalizedAnchor, head: normalizedHead };
+        const anchorCell = this.cellFromNode(native.anchorNode);
+        const headCell = this.cellFromNode(native.focusNode);
+        if (anchorCell && headCell && anchorCell.tableId === headCell.tableId && anchorCell.id !== headCell.id) {
+            const cellSelection = cellSelectionFromIds(anchorCell.id, headCell.id, this.editor.positions);
+            if (cellSelection)
+                model = cellSelection;
+        }
+        const description = this.editor.resolveScope({ want: "describe" }, model);
+        if (model.type !== "cell" && "spansIsolatingBoundary" in description && description.spansIsolatingBoundary) {
+            const isolateId = description.inTable?.tableId || description.isolatingAncestorId;
+            const range = isolateId ? this.editor.positions.rangeOf(isolateId) : null;
+            if (range)
+                model = { type: "node", anchor: range.from, head: range.to };
+        }
+        if (current.type === model.type && samePos(current.anchor, model.anchor) && samePos(current.head, model.head))
+            return;
+        this.editor.setSelection(model, { source: "api" });
+        // Re-project a normalized structural DOM point immediately. Without this
+        // call the model would know the right owner while the browser caret stayed
+        // on the root boundary, making the first subsequent input appear inert.
+        this.renderer.render(this.editor.document, model);
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.composition?.observer?.disconnect();
+        this.root.removeEventListener("beforeinput", this.beforeInputListener);
+        this.root.removeEventListener("keydown", this.keyDownListener);
+        this.root.removeEventListener("compositionstart", this.compositionStartListener);
+        this.root.removeEventListener("compositionupdate", this.compositionUpdateListener);
+        this.root.removeEventListener("compositionend", this.compositionEndListener);
+        this.root.removeEventListener("click", this.clickListener);
+        this.root.removeEventListener("mousedown", this.tableMouseDownListener);
+        this.root.removeEventListener("mouseup", this.tableMouseUpListener);
+        this.ownerDocument.removeEventListener("selectionchange", this.selectionChangeListener);
+        this.root.removeEventListener("paste", this.pasteListener);
+        this.root.removeEventListener("copy", this.copyListener);
+        this.root.removeEventListener("cut", this.cutListener);
+        this.root.removeEventListener("dragstart", this.dragStartListener);
+        this.root.removeEventListener("drop", this.dropListener);
+    }
+}
+export const createInputPipeline = (editor, renderer, root, options = {}) => new FoundationInputPipeline(editor, renderer, root, options);