@voithos-labs/aragonite 0.10.4 → 0.10.7

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

@@ -1,22 +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.
+ * The ListContext a ListBlock provides to its child ListItemBlocks. Every edit goes through
+ * `commitMultiScope`, whose copied scope views are the only legal write targets, never the
+ * `deps.scope.node` read before the commit.
  */
-import { CURSOR_EXACT_START, CURSOR_START, FOCUS_LAST_START } from '../block-component';
+import { CURSOR_EXACT_START, CURSOR_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 { replacePreservingFirst, stampStructuralChange, trackChildIds } from '../tree-operations/structural-change';
+import { spliceChildren } from '../tree-operations/children';
+import { cascadeCleanupEmptyAncestors } from '../tree-operations/cleanup';
+import { splitNode as performSplit, emptyParagraph } from '../tree-operations';
+import { lastCaretLeaf } from '../selection/path-lookup';
 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 { fragmentReaderAt } from '../tree-operations/list/task-paragraph';
 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. */
+/** The item Enter creates: the previous item's marker bumped, its task checkbox inherited
+ *  unchecked. */
 function mintFollowerItem(prevMeta, children) {
     const inheritTask = prevMeta?.taskItem === true;
     return buildListItem({
@@ -27,19 +30,24 @@ function mintFollowerItem(prevMeta, children) {
     }, children);
 }
 export function createListContext(deps) {
+    /** Item `index` of this list, at `offset`; a container position the landing resolves to a leaf. */
+    const itemAt = (index, offset) => ({
+        path: extendDocPath(deps.scope.path, index),
+        offset
+    });
     return {
         async indentItem(itemIndex) {
             const node = deps.scope.node;
             if (!node.children || itemIndex === 0)
-                return;
+                return false;
             const prevItem = node.children[itemIndex - 1];
             if (!prevItem.children)
-                return;
+                return false;
             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.
+            // One test, one destination: a matching sublist adopts the item whether or not it holds
+            // any yet, so the scope list and the mutate branch cannot disagree about where it goes.
             const destination = existingNestedList
                 ? {
                     node: existingNestedList,
@@ -51,34 +59,41 @@ export function createListContext(deps) {
                     state: expectStateForNode(prevItem),
                     path: [...deps.scope.path, itemIndex - 1]
                 };
-            await deps.controller.commitMultiScope({
+            // The moved item's path below this list once it lands in the previous item.
+            let movedTo = [];
+            return 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;
+                    const at = destScope.children.length;
+                    movedTo = existingNestedList
+                        ? [itemIndex - 1, existingNestedIdx, at]
+                        : [itemIndex - 1, at, 0];
+                    // Each branch renumbers the moved item's marker through `sharing`, which copies it first.
                     if (existingNestedList) {
-                        destList = destScope.node;
+                        const 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.
+                        // Adopt the destination sublist's marker style, as a paste does. A fresh list
+                        // (the else branch) has no convention to adopt.
                         const moved = ensureUnsharedChild(destList, destScope.children.length - 1, sharing);
                         normalizeItemMarkerToList(moved, destList);
+                        renumberOrderedList(destList, 0, sharing);
                     }
                     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];
+                        // Write, then read back (tree-operations/unshare.ts): the writes below go
+                        // through the value in the tree, not the list the proxy has observed.
+                        const destList = destScope.children[destScope.children.length - 1];
+                        renumberOrderedList(destList, 0, sharing);
+                        // A new sublist sits below the commit's chain, which never rebuilds it; the
+                        // blank-line rule below reads its bytes too.
+                        destScope.rebuild(destList);
+                        settleSublistSeparator(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 },
@@ -90,28 +105,35 @@ export function createListContext(deps) {
                     detail: { action: 'indentItem', itemIndex },
                     eventPath: docPathFrom(deps.scope.path)
                 },
-                afterTick: () => {
-                    deps.state.innerBlockRefs[itemIndex - 1]?.focus(FOCUS_LAST_START);
+                // The moved item's last leaf, at its start; the walk runs over this list's own items.
+                landing: () => {
+                    const items = {
+                        kind: 'document',
+                        prefix: '',
+                        children: deps.scope.node.children ?? [],
+                        suffix: ''
+                    };
+                    const leaf = lastCaretLeaf(items, movedTo);
+                    return leaf && { path: docPathFrom([...deps.scope.path, ...leaf]), offset: CURSOR_START };
                 }
             });
         },
         async unindentItem(itemIndex) {
             if (!deps.parentListContext || !deps.scope.node.children)
-                return;
-            await deps.parentListContext.promoteNestedItem(deps.parentListContext.getContainingItemIndex(), deps.scope.node, itemIndex);
+                return false;
+            return deps.parentListContext.promoteNestedItem(deps.parentListContext.getContainingItemIndex(), deps.scope.node, itemIndex);
         },
         async insertItemAfter(itemIndex, newItem) {
             const node = deps.scope.node;
             if (!node.children)
-                return;
+                return false;
             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))]);
+                // rebuildListItemRaw derives the item's raw from its body's line ending.
+                [emptyParagraph('', deps.getLineEnding())]);
             }
-            await deps.controller.commitMultiScope({
+            return deps.controller.commitMultiScope({
                 scopes: [{ node, state: deps.state, path: deps.scope.path }],
                 snapshot: { path: docPathFrom(deps.scope.path), offset: 0 },
                 mutate: ([scope]) => {
@@ -126,40 +148,40 @@ export function createListContext(deps) {
                     detail: { itemIndex },
                     eventPath: docPathFrom(deps.scope.path)
                 },
-                afterTick: () => {
-                    deps.state.innerBlockRefs[itemIndex + 1]?.focus(0);
-                }
+                landing: () => itemAt(itemIndex + 1, 0)
             });
         },
         async splitItemAtOffset(itemIndex, innerIndex, offset) {
             const outerList = deps.scope.node;
             if (!outerList.children)
-                return;
+                return false;
             const item = outerList.children[itemIndex];
             if (!item.children)
-                return;
+                return false;
             const itemState = expectStateForNode(item);
-            // Both scopes in one commit, so mid-item Enter is a single undo entry.
-            await deps.controller.commitMultiScope({
+            // Both lists in one commit, so mid-item Enter is a single undo entry.
+            return 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.
+                // The real pre-edit caret: `offset` is 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.
+                    // The change 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);
+                    const split = performSplit(itemScope.body, innerIndex, offset, sharing, deps.reading, 
+                    // The new item inherits this one's task marker, so its first block reads
+                    // as this item's first block does.
+                    fragmentReaderAt(itemScope.node, 0, deps.reading.grammar));
                     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);
+                    // The primitive's index, not `innerIndex + 1`: a first half that parses to several
+                    // blocks stays with this item.
+                    const cutAt = split.secondHalfIndex;
+                    const secondHalf = itemChildren.splice(cutAt);
                     if (secondHalf.length > 0) {
                         secondHalf[0].leadingTrivia = '';
                     }
@@ -168,10 +190,10 @@ export function createListContext(deps) {
                     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.
+                    // blocks, several when the cut bytes reparse to more than one.
                     return [
                         { op: 'insert', at: itemIndex + 1, count: 1 },
-                        replacePreservingFirst(innerIndex, preSpliceLen - innerIndex, landing - innerIndex)
+                        replacePreservingFirst(innerIndex, preSpliceLen - innerIndex, cutAt - innerIndex)
                     ];
                 },
                 op: {
@@ -179,42 +201,35 @@ export function createListContext(deps) {
                     detail: { at: offset, itemIndex, innerIndex },
                     eventPath: docPathFrom(deps.scope.path)
                 },
-                afterTick: () => {
-                    deps.state.innerBlockRefs[itemIndex + 1]?.focus(CURSOR_EXACT_START);
-                }
+                landing: () => itemAt(itemIndex + 1, CURSOR_EXACT_START)
             });
         },
         async promoteNestedItem(parentItemIdx, nestedListNode, nestedItemIdx) {
             const node = deps.scope.node;
             if (!node.children || !nestedListNode.children)
-                return;
+                return false;
             const parentItem = node.children[parentItemIdx];
             if (!parentItem?.children)
-                return;
+                return false;
             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;
+                return false;
+            // The move can empty the nested list and then the parent item, so both are scopes.
             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({
+                }
+            ];
+            let promotedAt = parentItemIdx + 1;
+            return deps.controller.commitMultiScope({
                 scopes,
                 // The promoted item's pre-move path (its nested-list slot).
                 snapshot: {
@@ -222,64 +237,54 @@ export function createListContext(deps) {
                     offset: 0
                 },
                 mutate: (scopeViews) => {
-                    const outerScope = scopeViews[0];
-                    const nestedScope = scopeViews[1];
+                    const [outerScope, nestedScope] = scopeViews;
                     const sharing = outerScope.sharing;
-                    // The promoted item is moved AND written (marker normalization,
-                    // renumber), so own it before it leaves the nested list.
+                    // Opened before the move, since the cleanup below can splice any of the three lists.
+                    const ledgers = scopeViews.map((v) => trackChildIds(v.node));
+                    // The promoted item is moved and written (marker normalization, renumbering),
+                    // so copy 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);
-                    }
+                    spliceChildren(nestedScope.node, nestedItemIdx, 1, []);
                     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;
+                    spliceChildren(outerScope.node, promotedAt, 0, [item]);
+                    // What the move emptied goes, up to this list, which now holds the promoted item.
+                    const outerCount = outerScope.children.length;
+                    cascadeCleanupEmptyAncestors(outerScope.node, [parentItemIdx, nestedIdxInParent, nestedItemIdx], sharing, deps.reading.grammar);
+                    promotedAt -= outerCount - outerScope.children.length;
+                    if (nestedScope.children.length > 0)
+                        renumberOrderedList(nestedScope.node, 0, sharing);
+                    renumberOrderedList(outerScope.node, promotedAt, sharing);
+                    return ledgers.map((ledger) => {
+                        const change = ledger.read();
+                        ledger.release();
+                        return change;
+                    });
                 },
                 op: {
                     kind: 'replaceBlock',
                     detail: { action: 'promoteNestedItem', parentItemIdx, nestedItemIdx },
                     eventPath: docPathFrom(deps.scope.path)
                 },
-                afterTick: () => {
-                    deps.state.innerBlockRefs[parentItemIdx + 1]?.focus(CURSOR_START);
-                }
+                landing: () => itemAt(promotedAt, CURSOR_START)
             });
         },
         getContainingItemIndex() {
-            // Top-level list — only nested lists return a meaningful value here.
+            // A 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.
+                return false;
+            // In a nested list one Enter outdents one level, like Shift+Tab. Only the outermost
+            // list exits straight to a paragraph.
             if (deps.parentListContext) {
-                await deps.parentListContext.promoteNestedItem(deps.parentListContext.getContainingItemIndex(), node, itemIndex);
-                return;
+                return deps.parentListContext.promoteNestedItem(deps.parentListContext.getContainingItemIndex(), node, itemIndex);
             }
-            const replacement = buildExitReplacement(node, itemIndex);
-            await deps.parentBlockEdit.replaceBlock(deps.scope.index, replacement.blocks, {
-                replacementIndex: replacement.paragraphIndex,
-                offset: 0
-            });
+            const replacement = buildExitReplacement(node, itemIndex, deps.getLineEnding());
+            // The caret sat in an item, which an offset into the list can't name; the live read
+            // records it.
+            return deps.parentBlockEdit.replaceBlock(deps.scope.index, replacement.blocks, { replacementIndex: replacement.paragraphIndex, offset: 0 }, { snapshotOffset: 0 });
         }
     };
 }

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

@@ -1,13 +1,21 @@
 /**
- * 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`.
+ * The list's and the list item's overrides over the default child actions. The list's are
+ * item-level no-ops and the last item's forward merge, handed to the parent; the item's is its
+ * Enter. Backspace unwrap comes from the list's declared `unwrapRole`, which picks a strategy in
+ * `unwrap-strategies.ts`.
  */
-import type { BlockEditActions } from '../action-contracts';
+import type { BlockEditActions, ListContext } 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;
+export interface ListItemOverridesDeps {
+    scope: NodeScope;
+    /** The enclosing list's context, read before the item provides its own. */
+    listContext: ListContext;
+}
+/** A list item's Enter: an empty item leaves the list, at the item's end it starts the next
+ *  item, anywhere else it splits the item. Backspace keeps the default. */
+export declare function createListItemOverrides(deps: ListItemOverridesDeps): NestedActionsOverrideFactory;

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

@@ -1,25 +1,49 @@
 /**
- * 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`.
+ * The list's and the list item's overrides over the default child actions. The list's are
+ * item-level no-ops and the last item's forward merge, handed to the parent; the item's is its
+ * Enter. Backspace unwrap comes from the list's declared `unwrapRole`, which picks a strategy in
+ * `unwrap-strategies.ts`.
  */
+import { refusedWrite } from './stored-caret';
+import { displayLength, isBlankText } from '../core/lines';
 export function createListOverrides(deps) {
     return () => ({
         blockEdit: {
-            // Items split through the ITEM's own bundle; nothing calls the list's, and the shared
+            // 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.
+            splitBlock: async () => false,
+            updateBlockContent: () => refusedWrite(),
+            // Items are structural peers, not text to merge. Only the last item hands the merge
+            // to the parent, so the block after the list merges into the list's deepest leaf.
             mergeWithNext: async (itemIndex) => {
                 const node = deps.scope.node;
+                if (!node.children || itemIndex < node.children.length - 1)
+                    return false;
+                return deps.parentBlockEdit.mergeWithNext(deps.scope.index);
+            }
+        }
+    });
+}
+/** A list item's Enter: an empty item leaves the list, at the item's end it starts the next
+ *  item, anywhere else it splits the item. Backspace keeps the default. */
+export function createListItemOverrides(deps) {
+    return () => ({
+        blockEdit: {
+            splitBlock: async (innerIndex, offset) => {
+                const { node, index } = deps.scope;
                 if (!node.children)
-                    return;
-                if (itemIndex >= node.children.length - 1) {
-                    await deps.parentBlockEdit.mergeWithNext(deps.scope.index);
+                    return false;
+                // Looser than `isItemUserEmpty`: trailing structural children stay until
+                // `exitListAtItem` moves them.
+                const firstChild = node.children[0];
+                if (firstChild?.kind === 'paragraph' && isBlankText(firstChild.raw)) {
+                    return deps.listContext.exitListAtItem(index);
                 }
+                const lastChild = node.children[node.children.length - 1];
+                const atEnd = innerIndex === node.children.length - 1 && offset >= displayLength(lastChild.raw);
+                if (atEnd)
+                    return deps.listContext.insertItemAfter(index);
+                return deps.listContext.splitItemAtOffset(index, innerIndex, offset);
             }
         }
     });

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

@@ -1,19 +1,13 @@
 /**
- * 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.
+ * Where the caret goes after a merge that may not have happened, in both directions: the sibling
+ * merge (`block-edit-core`) and the list-item merge (`unwrap-strategies.listItemCascadeMiddle`).
+ * A refused merge still moves the caret across the boundary the user pressed at.
  */
-import { type BlockComponent } from '../block-component';
+import type { CaretPosition } from '../selection/primitives';
 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;
+/** Null means nothing merged (no reachable text leaf, or a refused join), so the caret goes to
+ *  the previous block's end. */
+export declare function mergedElsePrevious(joined: CaretPosition | null, previous: CaretPosition['path']): CaretPosition;
+/** A `noop` change means the join was refused (the joined bytes parse as several blocks), so the
+ *  caret crosses into the next block's start. */
+export declare function mergedElseNext(change: StructuralChange, joined: CaretPosition, next: CaretPosition['path']): CaretPosition;

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

@@ -1,27 +1,16 @@
 /**
- * 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.
+ * Where the caret goes after a merge that may not have happened, in both directions: the sibling
+ * merge (`block-edit-core`) and the list-item merge (`unwrap-strategies.listItemCascadeMiddle`).
+ * A refused merge 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;
+/** Null means nothing merged (no reachable text leaf, or a refused join), so the caret goes to
+ *  the previous block's end. */
+export function mergedElsePrevious(joined, previous) {
+    return joined ?? { path: previous, offset: CURSOR_END };
 }
-/**
- * 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;
+/** A `noop` change means the join was refused (the joined bytes parse as several blocks), so the
+ *  caret crosses into the next block's start. */
+export function mergedElseNext(change, joined, next) {
+    return change.op !== 'noop' ? joined : { path: next, offset: CURSOR_START };
 }

package/dist/editor-actions/nested/container-actions.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The action bundle a container block hands its children, built the same way for every container
+ * kind: its parent's actions and the editor's reading in, the children's actions provided out.
+ * Call it once during component init. It reads the action contexts before it sets them, so a
+ * caller that needs a parent context (a list's own list context) reads it before the call.
+ */
+import type { ListContext } from '../../action-contracts';
+import type { NodeView } from '../../core/node-views';
+import { type BlockListState } from '../../reactivity/block-list-state.svelte';
+import type { Reading } from '../../schema/reading';
+import type { ChildList } from '../../reactivity/child-list';
+import { type NestedActionsBundle, type NestedActionsDeps, type NestedActionsOverrideFactory, type NodeScope } from './nested-actions';
+export interface ContainerActionsDeps {
+    getNode: () => NodeView;
+    getIndex: () => number;
+    getPath: () => number[];
+    /** The container's own rules over the default child actions, given its scope and its parent. */
+    overrides?: (parts: {
+        scope: NodeScope;
+        parent: NestedActionsDeps['parent'];
+        reading: Reading;
+    }) => NestedActionsOverrideFactory;
+    /** The enclosing list's context, for a list nested in one. */
+    parentListContext?: ListContext;
+    /** The container's own child list; read at use, so it may name a const declared after the
+     *  call, which it has to since the list's window is built from `state`. */
+    childList: () => ChildList;
+}
+export interface ContainerActions {
+    /** The container's live index, node and path, shared by reference with every factory. */
+    scope: NodeScope;
+    state: BlockListState;
+    bundle: NestedActionsBundle;
+    parent: NestedActionsDeps['parent'];
+    reading: Reading;
+}
+export declare function createContainerActions(deps: ContainerActionsDeps): ContainerActions;

package/dist/editor-actions/nested/container-actions.js

@@ -0,0 +1,42 @@
+/**
+ * The action bundle a container block hands its children, built the same way for every container
+ * kind: its parent's actions and the editor's reading in, the children's actions provided out.
+ * Call it once during component init. It reads the action contexts before it sets them, so a
+ * caller that needs a parent context (a list's own list context) reads it before the call.
+ */
+import { getContext } from 'svelte';
+import { BLOCK_EDIT_KEY, CONTAINER_EDIT_KEY, EDITOR_DOC_KEY, EDITOR_SERVICES_KEY, FOCUS_KEY } from '../../editor-keys';
+import { createBlockListState } from '../../reactivity/block-list-state.svelte';
+import { createStandardNestedActions, setNestedActionsContexts } from './nested-actions';
+export function createContainerActions(deps) {
+    const parent = {
+        blockEdit: getContext(BLOCK_EDIT_KEY),
+        focus: getContext(FOCUS_KEY),
+        containerEdit: getContext(CONTAINER_EDIT_KEY)
+    };
+    const { caretMemory } = getContext(EDITOR_SERVICES_KEY);
+    const { reading } = getContext(EDITOR_DOC_KEY);
+    const state = createBlockListState(deps.getNode);
+    // Getters, never a spread: a spread would snapshot the container's position.
+    const scope = {
+        get index() {
+            return deps.getIndex();
+        },
+        get node() {
+            return deps.getNode();
+        },
+        get path() {
+            return deps.getPath();
+        }
+    };
+    const bundle = createStandardNestedActions(state, {
+        scope,
+        caretMemory,
+        reading,
+        parentListContext: deps.parentListContext,
+        childList: deps.childList,
+        parent
+    }, deps.overrides?.({ scope, parent, reading }));
+    setNestedActionsContexts(bundle);
+    return { scope, state, bundle, parent, reading };
+}

package/dist/editor-actions/nested/emptied-container.d.ts

@@ -0,0 +1,5 @@
+import type { RemovalGesture } from '../../selection/caret-target';
+import type { NestedActionsDeps } from './nested-actions';
+/** Removes the container from its parent's list, for an edit that would take its last child: an
+ *  emptied container goes rather than stay childless. */
+export declare function removeEmptiedContainer(deps: NestedActionsDeps, gesture: RemovalGesture): Promise<boolean>;