@voithos-labs/aragonite 0.10.1

package/dist/editor-actions/focus/focus-landing.js

@@ -0,0 +1,39 @@
+/**
+ * Shared cross-block landing tail for the focus dispatchers. Sticky-X null handling
+ * lives here, so `focusAtColumn` receivers always get a finite x.
+ */
+import { CURSOR_END, CURSOR_START } from '../../block-component';
+export async function consumeStickyLanding(block, index, position, stickyColumn, retryAt) {
+    const isStickyMove = typeof position === 'object' && 'stickyColumnFrom' in position;
+    // Widget-only blocks contribute no column landing, so ArrowUp/Down passes through.
+    // Horizontal moves still stop at the widget edge.
+    if (isStickyMove && block.isVerticallyTransparent?.()) {
+        const direction = position.stickyColumnFrom === 'below' ? -1 : 1;
+        await retryAt(index + direction);
+        return;
+    }
+    // Enter an edge widget rather than dropping a no-op caret at its boundary, so the
+    // arrow key produces one visible step.
+    if (position === 'start' && block.enterEdgeWidget?.('start'))
+        return;
+    if (position === 'end' && block.enterEdgeWidget?.('end'))
+        return;
+    if (isStickyMove) {
+        const x = stickyColumn.get();
+        const from = position.stickyColumnFrom;
+        if (x !== null && block.focusAtColumn) {
+            block.focusAtColumn(x, from);
+            return;
+        }
+        block.focus(from === 'above' ? CURSOR_START : CURSOR_END);
+        return;
+    }
+    // An ARRIVAL says "the start"/"the end" and the door seats it on a landable offset; a numeric
+    // position is a caller who knows its byte (a split's continuation) and is passed through.
+    if (typeof position === 'number')
+        block.focus(position);
+    else if (position === 'start')
+        block.focus(CURSOR_START);
+    else
+        block.focus(CURSOR_END);
+}

package/dist/editor-actions/focus/focus.d.ts

@@ -0,0 +1,7 @@
+/**
+ * FocusActions factory: cursor movement across blocks, sticky-column-aware
+ * vertical traversal, and trailing-paragraph creation past document end.
+ */
+import type { FocusActions } from '../../action-contracts';
+import type { EditorActionsDeps, UndoController } from '../deps';
+export declare function createFocusActions(deps: EditorActionsDeps, controller: UndoController): FocusActions;

package/dist/editor-actions/focus/focus.js

@@ -0,0 +1,74 @@
+/**
+ * FocusActions factory: cursor movement across blocks, sticky-column-aware
+ * vertical traversal, and trailing-paragraph creation past document end.
+ */
+import { emptyParagraph } from '../../tree-operations';
+import { trailingLineEnding } from '../../core/lines';
+import { traversalStep } from './focus-dispatch';
+import { consumeStickyLanding } from './focus-landing';
+import { docPathFrom } from '../../cursor/coordinate-spaces';
+import { tryGapStop } from '../../selection/gap-caret';
+export function createFocusActions(deps, controller) {
+    const gapScope = {
+        getDoc: () => deps.doc,
+        selection: deps.selectionState,
+        getPresentationMode: deps.getPresentationMode
+    };
+    const gapStopAt = (parentPath, boundaryIndex) => tryGapStop(gapScope, parentPath, boundaryIndex);
+    return {
+        revealPath: deps.revealPath,
+        tryGapStop: gapStopAt,
+        async moveFocus(blockIndex, position, options) {
+            const step = traversalStep(position);
+            const stopsAtGaps = step !== 0 && !options?.skipGapStop;
+            // The boundary a directional move crosses is the greater of the two adjacent
+            // indices. Out-of-range boundaries and the root's trailing one decline in
+            // `gapEligibleAt`, so the arms below keep their behavior unguarded.
+            if (stopsAtGaps && gapStopAt([], step > 0 ? blockIndex : blockIndex + 1))
+                return;
+            if (blockIndex < 0)
+                return;
+            if (blockIndex >= deps.doc.children.length) {
+                if (options?.append === false)
+                    return;
+                // Past the last block — appended through the commit primitive so it participates in
+                // undo history and edit events. The separating blank line and the paragraph's own
+                // are both line endings, so both take the document's (G4.20).
+                const lastBlock = deps.doc.children[deps.doc.children.length - 1];
+                const lineEnding = trailingLineEnding(lastBlock?.raw ?? '\n');
+                const newBlock = emptyParagraph(lineEnding, lineEnding);
+                // The appended slot (one past the end) is the coordinate for both the
+                // event and the restore fallback — it names the block this op creates.
+                const appendPath = docPathFrom([deps.doc.children.length]);
+                await controller.commitStructural({
+                    snapshot: { path: appendPath, offset: 0 },
+                    mutate: (children) => {
+                        const at = children.length;
+                        children.push(newBlock);
+                        return { op: 'insert', at, count: 1 };
+                    },
+                    op: { kind: 'appendBlock', eventPath: appendPath },
+                    afterTick: () => {
+                        const lastIdx = deps.doc.children.length - 1;
+                        deps.blockRefs[lastIdx]?.focus(0);
+                    }
+                });
+                return;
+            }
+            const block = await deps.revealPath([blockIndex]);
+            if (!block?.focusable) {
+                // A refless or non-focusable block must not dead-end the move — skip it in
+                // the move's direction (editor.md § Focus traversal).
+                if (step !== 0)
+                    await this.moveFocus(blockIndex + step, position, options);
+                return;
+            }
+            // A landing AT a block's end is a seat at an extreme, not a step onto it, so the side
+            // it means is construct-relative (docs/design/live-mode.md § 4.2). Without this the
+            // first byte typed after a structural landing joins the closer it landed inside.
+            if (position === 'end')
+                deps.edgeAffinity.noteExtreme();
+            await consumeStickyLanding(block, blockIndex, position, deps.stickyColumn, (i) => this.moveFocus(i, position, options));
+        }
+    };
+}

package/dist/editor-actions/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Editor-root action bundle factory. Composes the undo controller plus four
+ * sub-interface bundles for Editor.svelte to wire into Svelte context.
+ */
+import type { BlockEditActions, ContainerEditActions, FocusActions, HistoryActions } from '../action-contracts';
+import type { EditorActionsDeps, UndoController } from './deps';
+export interface EditorActionsBundle {
+    blockEdit: BlockEditActions;
+    focus: FocusActions;
+    history: HistoryActions;
+    containerEdit: ContainerEditActions;
+    controller: UndoController;
+}
+export declare function createEditorActions(deps: EditorActionsDeps): EditorActionsBundle;
+export type { EditorActionsDeps } from './deps';

package/dist/editor-actions/index.js

@@ -0,0 +1,19 @@
+/**
+ * Editor-root action bundle factory. Composes the undo controller plus four
+ * sub-interface bundles for Editor.svelte to wire into Svelte context.
+ */
+import { createUndoController } from './commit/undo-controller';
+import { createBlockEditActions } from './block-edit';
+import { createFocusActions } from './focus/focus';
+import { createHistoryActions } from './commit/history';
+import { createContainerEditActions } from './container-edit';
+export function createEditorActions(deps) {
+    const controller = createUndoController(deps);
+    return {
+        blockEdit: createBlockEditActions(deps, controller),
+        focus: createFocusActions(deps, controller),
+        history: createHistoryActions(deps, controller),
+        containerEdit: createContainerEditActions(deps, controller),
+        controller
+    };
+}

package/dist/editor-actions/inline-range-commit.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Rewrite a byte range inside one leaf's raw as a single undo entry. The anchored inline editors
+ * (image properties, link card) all reach their bytes this way, so the scope choice — top-level
+ * vs container ceremony — and the no-op discard live here rather than at each popover.
+ */
+import type { Document } from '../core/nodes';
+import type { GrammarView } from '../schema/block-openers';
+import type { UndoController } from './deps';
+export interface InlineRangeCommitDeps {
+    getDoc: () => Document;
+    controller: UndoController;
+    /** The instance's grammar, for the leaf's own raw-write rule. Absent = the global grammar. */
+    grammar?: GrammarView;
+}
+export interface InlineRangeCommit {
+    /** Splice `bytes` over `[start, end)` of the leaf at `path`; `caretAfter` is the raw offset the
+     *  entry's snapshot restores. A splice that changes no byte commits nothing. */
+    commitInlineRange(path: number[], start: number, end: number, bytes: string, caretAfter: number): Promise<void>;
+}
+export declare function createInlineRangeCommit(deps: InlineRangeCommitDeps): InlineRangeCommit;

package/dist/editor-actions/inline-range-commit.js

@@ -0,0 +1,63 @@
+/**
+ * Rewrite a byte range inside one leaf's raw as a single undo entry. The anchored inline editors
+ * (image properties, link card) all reach their bytes this way, so the scope choice — top-level
+ * vs container ceremony — and the no-op discard live here rather than at each popover.
+ */
+import { docPathFrom } from '../cursor/coordinate-spaces';
+import { expectStateForNode } from '../reactivity/state-registry';
+import { isBlockNode, nodeAt, normalizeOwnRaw, writeOwnRaw } from '../tree-operations/node-ops';
+import { ensureUnsharedChild, ensureUnsharedPath } from '../tree-operations/unshare';
+export function createInlineRangeCommit(deps) {
+    async function commitInlineRange(path, start, end, bytes, caretAfter) {
+        if (path.length === 0)
+            return;
+        const leaf = nodeAt(deps.getDoc(), path);
+        if (leaf === null || !isBlockNode(leaf))
+            return;
+        const newRaw = leaf.raw.slice(0, start) + bytes + leaf.raw.slice(end);
+        // Compared against the bytes the KIND would actually land (G4.28), so a splice a cell's
+        // pipe escape normalizes away adds no undo entry — the dismiss-after-resize shape.
+        const legal = normalizeOwnRaw(leaf, newRaw);
+        if (legal === leaf.raw)
+            return;
+        const { controller } = deps;
+        const snapshot = { path: docPathFrom(path), offset: caretAfter };
+        const leafIdx = path[path.length - 1];
+        const op = {
+            kind: 'updateContent',
+            detail: { length: legal.length },
+            eventPath: docPathFrom(path)
+        };
+        const writeRaw = (node) => {
+            writeOwnRaw(node, newRaw, deps.grammar);
+        };
+        if (path.length === 1) {
+            await controller.commitStructural({
+                snapshot,
+                mutate: (children) => {
+                    const [owned] = ensureUnsharedPath({ children }, [leafIdx], controller.sharing);
+                    writeRaw(owned);
+                    return { op: 'noop' };
+                },
+                op
+            });
+            return;
+        }
+        // path.length > 1, so the parent is a container node, never the root.
+        const container = nodeAt(deps.getDoc(), path.slice(0, -1));
+        if (container === null || !isBlockNode(container))
+            return;
+        await controller.commitContainerStructural({
+            containerNode: container,
+            path: path.slice(0, -1),
+            state: expectStateForNode(container),
+            snapshot,
+            mutate: (scope) => {
+                writeRaw(ensureUnsharedChild(scope.node, leafIdx, scope.sharing));
+                return { op: 'noop' };
+            },
+            op
+        });
+    }
+    return { commitInlineRange };
+}

package/dist/editor-actions/list-context.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The ListContext bundle a ListBlock provides to its child ListItemBlocks. Every
+ * mutation routes through `commitMultiScope`, whose owned scope views are the only
+ * legal write targets — never the pre-commit `deps.scope.node` captures.
+ */
+import type { BlockEditActions, FocusActions, ListContext } from '../action-contracts';
+import type { PresentationModeGetter } from '../editor-keys';
+import type { InlineResolverRef } from '../schema/inline-construct-policy';
+import type { UndoController } from './deps';
+import type { BlockListState } from '../reactivity/block-list-state.svelte';
+import type { NodeScope } from './nested/nested-actions';
+export interface ListContextDeps {
+    scope: NodeScope;
+    state: BlockListState;
+    parentBlockEdit: BlockEditActions;
+    parentFocus: FocusActions;
+    parentListContext: ListContext | undefined;
+    controller: UndoController;
+    /** Live EFFECTIVE mode, for the mid-item split's byte rebalance. Nullable rather than
+     *  optional so the one composing container answers. */
+    getPresentationMode: PresentationModeGetter | undefined;
+    /** The instance's link-reference resolver, required-nullable beside the mode. */
+    linkRef: InlineResolverRef | undefined;
+}
+export declare function createListContext(deps: ListContextDeps): ListContext;

package/dist/editor-actions/list-context.js

@@ -0,0 +1,285 @@
+/**
+ * The ListContext bundle a ListBlock provides to its child ListItemBlocks. Every
+ * mutation routes through `commitMultiScope`, whose owned scope views are the only
+ * legal write targets — never the pre-commit `deps.scope.node` captures.
+ */
+import { CURSOR_EXACT_START, CURSOR_START, FOCUS_LAST_START } from '../block-component';
+import { metadataOf } from '../core/nodes';
+import { trailingLineEnding } from '../core/lines';
+import { extendDocPath, docPathFrom } from '../cursor/coordinate-spaces';
+import { replacePreservingFirst, stampStructuralChange } from '../tree-operations/structural-change';
+import { splitNode as performSplit, assertSplitLanding, emptyParagraph } from '../tree-operations';
+import { ensureUnsharedChild } from '../tree-operations/unshare';
+import { rebuildListRaw } from '../schema/container-rebuilders';
+import { renumberOrderedList, normalizeItemMarkerToList, bumpOrderedMarker } from '../tree-operations/list/ordered-markers';
+import { buildListItem, buildListShell } from '../tree-operations/list/list-builders';
+import { buildExitReplacement } from '../tree-operations/list/exit-replacement';
+import { settleSublistSeparator } from '../tree-operations/list/sublist-separator';
+import { expectStateForNode } from '../reactivity/state-registry';
+/** The Enter-minted follower: the previous item's marker bumped, its task-ness inherited unchecked. */
+function mintFollowerItem(prevMeta, children) {
+    const inheritTask = prevMeta?.taskItem === true;
+    return buildListItem({
+        marker: bumpOrderedMarker(prevMeta?.marker ?? '- '),
+        taskItem: inheritTask,
+        taskChecked: false,
+        taskMarker: inheritTask ? '[ ] ' : null
+    }, children);
+}
+export function createListContext(deps) {
+    return {
+        async indentItem(itemIndex) {
+            const node = deps.scope.node;
+            if (!node.children || itemIndex === 0)
+                return;
+            const prevItem = node.children[itemIndex - 1];
+            if (!prevItem.children)
+                return;
+            const ordered = metadataOf(node, 'list').ordered;
+            const existingNestedIdx = prevItem.children.findIndex((c) => c.kind === 'list' && metadataOf(c, 'list').ordered === ordered);
+            const existingNestedList = existingNestedIdx === -1 ? undefined : prevItem.children[existingNestedIdx];
+            // One predicate, one destination: a matching sublist adopts the item whether or not it
+            // holds any yet, so the scope push and the mutate branch cannot disagree about the seat.
+            const destination = existingNestedList
+                ? {
+                    node: existingNestedList,
+                    state: expectStateForNode(existingNestedList),
+                    path: [...deps.scope.path, itemIndex - 1, existingNestedIdx]
+                }
+                : {
+                    node: prevItem,
+                    state: expectStateForNode(prevItem),
+                    path: [...deps.scope.path, itemIndex - 1]
+                };
+            await deps.controller.commitMultiScope({
+                scopes: [{ node, state: deps.state, path: deps.scope.path }, destination],
+                snapshot: { path: extendDocPath(deps.scope.path, itemIndex), offset: 0 },
+                mutate: ([outerScope, destScope]) => {
+                    const sharing = outerScope.sharing;
+                    const [movedItem] = outerScope.children.splice(itemIndex, 1);
+                    let destList;
+                    if (existingNestedList) {
+                        destList = destScope.node;
+                        destScope.children.push(movedItem);
+                        // Adopt the destination sublist's marker style, matching paste-absorb.
+                        // A fresh shell (the else branch) has no convention to adopt.
+                        const moved = ensureUnsharedChild(destList, destScope.children.length - 1, sharing);
+                        normalizeItemMarkerToList(moved, destList);
+                    }
+                    else {
+                        const shell = buildListShell(ordered, [movedItem]);
+                        sharing.stamp(shell);
+                        destScope.children.push(shell);
+                        // Write-then-re-read (tree-operations/unshare.ts): the writes below go
+                        // through the tree-held value, not the shell the proxy has now observed.
+                        destList = destScope.children[destScope.children.length - 1];
+                    }
+                    // Renumber writes the moved item's marker — sharing unshares it.
+                    renumberOrderedList(destList, 0, sharing);
+                    rebuildListRaw(destList);
+                    // After the rebuild: the separator question is asked of the sublist's own bytes.
+                    settleSublistSeparator(destScope.children, destScope.children.length - 1);
+                    renumberOrderedList(outerScope.node, itemIndex, sharing);
+                    return [
+                        { op: 'delete', at: itemIndex, count: 1 },
+                        { op: 'insert', at: destScope.children.length - 1, count: 1 }
+                    ];
+                },
+                op: {
+                    kind: 'replaceBlock',
+                    detail: { action: 'indentItem', itemIndex },
+                    eventPath: docPathFrom(deps.scope.path)
+                },
+                afterTick: () => {
+                    deps.state.innerBlockRefs[itemIndex - 1]?.focus(FOCUS_LAST_START);
+                }
+            });
+        },
+        async unindentItem(itemIndex) {
+            if (!deps.parentListContext || !deps.scope.node.children)
+                return;
+            await deps.parentListContext.promoteNestedItem(deps.parentListContext.getContainingItemIndex(), deps.scope.node, itemIndex);
+        },
+        async insertItemAfter(itemIndex, newItem) {
+            const node = deps.scope.node;
+            if (!node.children)
+                return;
+            if (!newItem) {
+                const prevItem = node.children[itemIndex];
+                newItem = mintFollowerItem(prevItem ? metadataOf(prevItem, 'listItem') : undefined, 
+                // The new item's body IS a line ending, so it takes the list's (G4.20);
+                // rebuildListItemRaw derives the item's raw from it.
+                [emptyParagraph('', trailingLineEnding(node.raw))]);
+            }
+            await deps.controller.commitMultiScope({
+                scopes: [{ node, state: deps.state, path: deps.scope.path }],
+                snapshot: { path: docPathFrom(deps.scope.path), offset: 0 },
+                mutate: ([scope]) => {
+                    const sharing = scope.sharing;
+                    sharing.stamp(newItem);
+                    scope.children.splice(itemIndex + 1, 0, newItem);
+                    renumberOrderedList(scope.node, itemIndex + 1, sharing);
+                    return [{ op: 'insert', at: itemIndex + 1, count: 1 }];
+                },
+                op: {
+                    kind: 'appendBlock',
+                    detail: { itemIndex },
+                    eventPath: docPathFrom(deps.scope.path)
+                },
+                afterTick: () => {
+                    deps.state.innerBlockRefs[itemIndex + 1]?.focus(0);
+                }
+            });
+        },
+        async splitItemAtOffset(itemIndex, innerIndex, offset) {
+            const outerList = deps.scope.node;
+            if (!outerList.children)
+                return;
+            const item = outerList.children[itemIndex];
+            if (!item.children)
+                return;
+            const itemState = expectStateForNode(item);
+            // Both scopes in one commit, so mid-item Enter is a single undo entry.
+            await deps.controller.commitMultiScope({
+                scopes: [
+                    { node: outerList, state: deps.state, path: deps.scope.path },
+                    { node: item, state: itemState, path: [...deps.scope.path, itemIndex] }
+                ],
+                // The true pre-edit caret: `offset` sits inside the split leaf.
+                snapshot: { path: docPathFrom([...deps.scope.path, itemIndex, innerIndex]), offset },
+                mutate: ([outerScope, itemScope]) => {
+                    const sharing = outerScope.sharing;
+                    const itemChildren = itemScope.children;
+                    // The descriptor must report everything removed from innerIndex onward,
+                    // not just the child that was split.
+                    const preSpliceLen = itemChildren.length;
+                    const split = performSplit({ children: itemChildren, ownerKind: itemScope.node.kind, owner: itemScope.node }, innerIndex, offset, sharing, deps.getPresentationMode?.(), deps.linkRef);
+                    stampStructuralChange(itemChildren, split.change, sharing);
+                    // The primitive's landing index, not `innerIndex + 1`: a plural first half
+                    // stays with this item, and G1.34 holds the splice to it.
+                    const landing = split.secondHalfIndex;
+                    assertSplitLanding(split, landing);
+                    const secondHalf = itemChildren.splice(landing);
+                    if (secondHalf.length > 0) {
+                        secondHalf[0].leadingTrivia = '';
+                    }
+                    const newItem = mintFollowerItem(metadataOf(itemScope.node, 'listItem'), secondHalf);
+                    sharing.stamp(newItem);
+                    outerScope.children.splice(itemIndex + 1, 0, newItem);
+                    renumberOrderedList(outerScope.node, itemIndex + 1, sharing);
+                    // Net item change: [innerIndex .. preSpliceLen) replaced by the first half's
+                    // blocks — plural when the cut bytes reparse to more than one.
+                    return [
+                        { op: 'insert', at: itemIndex + 1, count: 1 },
+                        replacePreservingFirst(innerIndex, preSpliceLen - innerIndex, landing - innerIndex)
+                    ];
+                },
+                op: {
+                    kind: 'split',
+                    detail: { at: offset, itemIndex, innerIndex },
+                    eventPath: docPathFrom(deps.scope.path)
+                },
+                afterTick: () => {
+                    deps.state.innerBlockRefs[itemIndex + 1]?.focus(CURSOR_EXACT_START);
+                }
+            });
+        },
+        async promoteNestedItem(parentItemIdx, nestedListNode, nestedItemIdx) {
+            const node = deps.scope.node;
+            if (!node.children || !nestedListNode.children)
+                return;
+            const parentItem = node.children[parentItemIdx];
+            if (!parentItem?.children)
+                return;
+            const nestedIdxInParent = parentItem.children.indexOf(nestedListNode);
+            if (nestedIdxInParent === -1)
+                return;
+            // Removing the last item empties the nested list, which needs a third scope
+            // to splice the now-empty list out of parentItem's children.
+            const nestedListWillEmpty = nestedListNode.children.length === 1;
+            const scopes = [
+                { node, state: deps.state, path: deps.scope.path },
+                {
+                    node: nestedListNode,
+                    state: expectStateForNode(nestedListNode),
+                    path: [...deps.scope.path, parentItemIdx, nestedIdxInParent]
+                }
+            ];
+            let parentItemScopeIdx = -1;
+            if (nestedListWillEmpty) {
+                parentItemScopeIdx = scopes.length;
+                scopes.push({
+                    node: parentItem,
+                    state: expectStateForNode(parentItem),
+                    path: [...deps.scope.path, parentItemIdx]
+                });
+            }
+            await deps.controller.commitMultiScope({
+                scopes,
+                // The promoted item's pre-move path (its nested-list slot).
+                snapshot: {
+                    path: docPathFrom([...deps.scope.path, parentItemIdx, nestedIdxInParent, nestedItemIdx]),
+                    offset: 0
+                },
+                mutate: (scopeViews) => {
+                    const outerScope = scopeViews[0];
+                    const nestedScope = scopeViews[1];
+                    const sharing = outerScope.sharing;
+                    // The promoted item is moved AND written (marker normalization,
+                    // renumber), so own it before it leaves the nested list.
+                    const item = ensureUnsharedChild(nestedScope.node, nestedItemIdx, sharing);
+                    nestedScope.children.splice(nestedItemIdx, 1);
+                    const changes = new Array(scopes.length);
+                    changes[1] = { op: 'delete', at: nestedItemIdx, count: 1 };
+                    if (nestedListWillEmpty && parentItemScopeIdx !== -1) {
+                        const parentItemChildren = scopeViews[parentItemScopeIdx].children;
+                        const nestedIdx = parentItemChildren.indexOf(nestedScope.node);
+                        if (nestedIdx !== -1) {
+                            parentItemChildren.splice(nestedIdx, 1);
+                            changes[parentItemScopeIdx] = { op: 'delete', at: nestedIdx, count: 1 };
+                        }
+                        else {
+                            changes[parentItemScopeIdx] = { op: 'noop' };
+                        }
+                    }
+                    if (!nestedListWillEmpty) {
+                        renumberOrderedList(nestedScope.node, 0, sharing);
+                    }
+                    normalizeItemMarkerToList(item, outerScope.node);
+                    outerScope.children.splice(parentItemIdx + 1, 0, item);
+                    changes[0] = { op: 'insert', at: parentItemIdx + 1, count: 1 };
+                    renumberOrderedList(outerScope.node, parentItemIdx + 1, sharing);
+                    return changes;
+                },
+                op: {
+                    kind: 'replaceBlock',
+                    detail: { action: 'promoteNestedItem', parentItemIdx, nestedItemIdx },
+                    eventPath: docPathFrom(deps.scope.path)
+                },
+                afterTick: () => {
+                    deps.state.innerBlockRefs[parentItemIdx + 1]?.focus(CURSOR_START);
+                }
+            });
+        },
+        getContainingItemIndex() {
+            // Top-level list — only nested lists return a meaningful value here.
+            return -1;
+        },
+        async exitListAtItem(itemIndex) {
+            const node = deps.scope.node;
+            if (!node.children)
+                return;
+            // Nested list: one Enter outdents one level (Shift+Tab semantics). Only the
+            // outermost list escapes straight to a paragraph.
+            if (deps.parentListContext) {
+                await deps.parentListContext.promoteNestedItem(deps.parentListContext.getContainingItemIndex(), node, itemIndex);
+                return;
+            }
+            const replacement = buildExitReplacement(node, itemIndex);
+            await deps.parentBlockEdit.replaceBlock(deps.scope.index, replacement.blocks, {
+                replacementIndex: replacement.paragraphIndex,
+                offset: 0
+            });
+        }
+    };
+}

package/dist/editor-actions/list-overrides.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Override factory for ListBlock: item-level no-ops and last-item forward-merge
+ * delegation. Item delete and replace fall through to the shared block-edit core.
+ * Backspace unwrap (U1/M1) is declaration-driven — the list's `unwrapRole` selects
+ * strategies in `unwrap-strategies.ts`.
+ */
+import type { BlockEditActions } from '../action-contracts';
+import type { NestedActionsOverrideFactory, NodeScope } from './nested/nested-actions';
+export interface ListOverridesDeps {
+    scope: NodeScope;
+    parentBlockEdit: BlockEditActions;
+}
+export declare function createListOverrides(deps: ListOverridesDeps): NestedActionsOverrideFactory;

package/dist/editor-actions/list-overrides.js

@@ -0,0 +1,26 @@
+/**
+ * Override factory for ListBlock: item-level no-ops and last-item forward-merge
+ * delegation. Item delete and replace fall through to the shared block-edit core.
+ * Backspace unwrap (U1/M1) is declaration-driven — the list's `unwrapRole` selects
+ * strategies in `unwrap-strategies.ts`.
+ */
+export function createListOverrides(deps) {
+    return () => ({
+        blockEdit: {
+            // Items split through the ITEM's own bundle; nothing calls the list's, and the shared
+            // core would run a prose split on a `listItem` if anything ever did.
+            splitBlock: async () => { },
+            updateBlockContent: () => { },
+            // Items are structural peers, not text-mergeable. Only the LAST item delegates
+            // upward, so the following block merges into this list's deepest leaf.
+            mergeWithNext: async (itemIndex) => {
+                const node = deps.scope.node;
+                if (!node.children)
+                    return;
+                if (itemIndex >= node.children.length - 1) {
+                    await deps.parentBlockEdit.mergeWithNext(deps.scope.index);
+                }
+            }
+        }
+    });
+}

package/dist/editor-actions/merge-fallback.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Single owner of the interior-merge fallbacks, both directions: the cross-sibling merge
+ * (`block-edit-core`), the within-list M1 merge (`unwrap-strategies.listItemCascadeMiddle`).
+ * A merge that does not happen still moves the caret across the boundary the user pressed at.
+ */
+import { type BlockComponent } from '../block-component';
+import type { StructuralChange } from '../tree-operations/structural-change';
+/**
+ * A null result means the previous block exposed no reachable text leaf, or the join was
+ * refused, so nothing merged: land the caret at its end instead. The nullable input makes
+ * ignoring the no-merge case a compile error.
+ */
+export declare function mergedElseFocusPrevious<T>(result: T | null, previous: BlockComponent | undefined): T | null;
+/**
+ * The forward twin, over the door's own change: `noop` means the join was refused (its bytes
+ * read as several blocks, and one slot installs one node), so the caret crosses into the block
+ * that stayed. Returns whether the merge happened, so the caller's landing asks the same question.
+ */
+export declare function mergedElseFocusNext(change: StructuralChange, next: BlockComponent | undefined): boolean;

package/dist/editor-actions/merge-fallback.js

@@ -0,0 +1,27 @@
+/**
+ * Single owner of the interior-merge fallbacks, both directions: the cross-sibling merge
+ * (`block-edit-core`), the within-list M1 merge (`unwrap-strategies.listItemCascadeMiddle`).
+ * A merge that does not happen still moves the caret across the boundary the user pressed at.
+ */
+import { CURSOR_END, CURSOR_START } from '../block-component';
+/**
+ * A null result means the previous block exposed no reachable text leaf, or the join was
+ * refused, so nothing merged: land the caret at its end instead. The nullable input makes
+ * ignoring the no-merge case a compile error.
+ */
+export function mergedElseFocusPrevious(result, previous) {
+    if (result === null)
+        previous?.focus(CURSOR_END);
+    return result;
+}
+/**
+ * The forward twin, over the door's own change: `noop` means the join was refused (its bytes
+ * read as several blocks, and one slot installs one node), so the caret crosses into the block
+ * that stayed. Returns whether the merge happened, so the caller's landing asks the same question.
+ */
+export function mergedElseFocusNext(change, next) {
+    if (change.op !== 'noop')
+        return true;
+    next?.focus(CURSOR_START);
+    return false;
+}