@voithos-labs/aragonite 0.10.1

package/dist/editor-actions/ancestry-folds.js

@@ -0,0 +1,106 @@
+/**
+ * Publishing side of the ancestry settle (`tree-operations/unshare.ts`): a fold at a container's
+ * own slot splices its PARENT's children, a scope the commit's own change descriptor never
+ * covers, so that scope's ids and refs are resynced here instead.
+ */
+import { applyStructuralChangeToIdsRefs } from '../tree-operations/structural-change';
+import { spliceMany } from '../tree-operations/splice-many';
+import { assignIds } from '../block-id';
+import { getStateForNode } from '../reactivity/state-registry';
+import { replaceRefs } from '../reactivity/publish-ref.svelte';
+/**
+ * Resync every folded scope's ids/refs and return the unwind for them, which a commit rolling
+ * back runs beside its own registers.
+ */
+export function publishAncestryFolds(deps, folds) {
+    const restores = [];
+    for (const fold of folds) {
+        restores.push(fold.owner ? publishContainerFold(deps, fold) : publishDocFold(deps, fold));
+    }
+    return () => {
+        for (let i = restores.length - 1; i >= 0; i--)
+            restores[i]();
+    };
+}
+/**
+ * The landing a fold owes the caret: the container's slot is always gone (the reparse re-mints
+ * every block in the folded window), so a door whose focus addressed it has nothing to land on.
+ * `scopePath` is the committing scope's own path, from which the fold's depth names the parent.
+ * The chain rebuilds innermost-first, so the LAST fold is the outermost one — the one whose slot
+ * swallowed the others, and the only landing still addressable after them all.
+ */
+export function foldLandingFor(folds, scopePath) {
+    const fold = folds[folds.length - 1];
+    if (!fold)
+        return null;
+    return {
+        path: [...scopePath.slice(0, fold.depth), fold.landing.index],
+        offset: fold.landing.offset
+    };
+}
+/**
+ * A splice made outside the commit ceremony, published as the ceremony publishes the change its
+ * mutate returns. `owner` is the container whose children moved, or undefined for the document.
+ */
+export function publishScopeFold(deps, owner, change) {
+    if (change.op === 'noop')
+        return;
+    if (owner)
+        publishContainerScope(owner, change);
+    else
+        publishDocScope(deps, change);
+}
+function publishDocScope(deps, change) {
+    const ids = [...deps.blockIds];
+    const refs = [...deps.blockRefs];
+    applyStructuralChangeToIdsRefs(change, ids, refs);
+    deps.setBlockIds(ids);
+    deps.setBlockRefs(refs);
+}
+/**
+ * Ids live on the owner node, which is what an unmounted container's BlockListState reads back;
+ * refs live on the state and only exist while the scope is mounted.
+ */
+function publishContainerScope(owner, change) {
+    const state = getStateForNode(owner);
+    // A container that never mounted has no ids to carry across, and this runs AFTER the fold —
+    // so one fresh id per surviving child is the whole answer, where a descriptor over a window
+    // the seeded array never held would mis-shape it (G1.36).
+    if (!owner.childIds) {
+        owner.childIds = assignIds(owner.children ?? []);
+        return;
+    }
+    const ids = [...owner.childIds];
+    const refs = state ? [...state.innerBlockRefs] : [];
+    applyStructuralChangeToIdsRefs(change, ids, refs);
+    owner.childIds = ids;
+    if (state)
+        replaceRefs(state.innerBlockRefs, refs);
+}
+function publishDocFold(deps, fold) {
+    const savedIds = [...deps.blockIds];
+    const savedRefs = [...deps.blockRefs];
+    publishScopeFold(deps, undefined, fold.change);
+    return () => {
+        deps.setBlockIds(savedIds);
+        deps.setBlockRefs(savedRefs);
+        restoreChildren(fold);
+    };
+}
+function publishContainerFold(deps, fold) {
+    const owner = fold.owner;
+    const state = getStateForNode(owner);
+    const savedIds = owner.childIds;
+    const savedRefs = state ? [...state.innerBlockRefs] : [];
+    publishScopeFold(deps, owner, fold.change);
+    return () => {
+        owner.childIds = savedIds;
+        if (state)
+            replaceRefs(state.innerBlockRefs, savedRefs);
+        restoreChildren(fold);
+    };
+}
+/** The whole pre-splice array: a fold re-mints plural slots, so no narrower register covers it. */
+function restoreChildren(fold) {
+    spliceMany(fold.siblings, 0, fold.siblings.length, fold.before);
+}

package/dist/editor-actions/block-edit-core.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Scope-parameterized structural-edit core shared by the top-level and container
+ * BlockEditActions factories. Each method is the interior body only — no edge guards,
+ * no upward delegation, no unwrap dispatch; the factories add those.
+ */
+import type { CstNode } from '../core/nodes';
+import type { CommitAfterTick, UndoEntryMode } from '../action-contracts';
+import type { CommitScope } from './block-edit-scope';
+export interface BlockEditCore {
+    split(i: number, offset: number): Promise<void>;
+    descendToBody(i: number): Promise<void>;
+    insertParagraph(i: number, text: string): Promise<void>;
+    mergeWithPreviousInterior(i: number): Promise<void>;
+    mergeWithNextInterior(i: number): Promise<void>;
+    deleteInterior(i: number): Promise<void>;
+    updateBlockMetadata(i: number, metadata: Record<string, unknown>, options?: {
+        undoEntry?: UndoEntryMode;
+        afterTick?: CommitAfterTick;
+    }): Promise<void>;
+    replaceBlock(i: number, replacement: CstNode[], focus?: {
+        replacementIndex: number;
+        offset: number;
+        path?: number[];
+    }, options?: {
+        undoEntry?: UndoEntryMode;
+        snapshotOffset?: number;
+    }): Promise<void>;
+}
+export declare function createBlockEditCore(scope: CommitScope): BlockEditCore;

package/dist/editor-actions/block-edit-core.js

@@ -0,0 +1,277 @@
+/**
+ * Scope-parameterized structural-edit core shared by the top-level and container
+ * BlockEditActions factories. Each method is the interior body only — no edge guards,
+ * no upward delegation, no unwrap dispatch; the factories add those.
+ */
+import { CURSOR_END, CURSOR_EXACT_START, CURSOR_START } from '../block-component';
+import { displayLength, trailingLineEnding } from '../core/lines';
+import { splitNode as performSplit, assertSplitLanding, mergeWithNext as performMergeNext, mergeIntoPrevDeepLeaf, deleteNode as performDelete, ensureEditableContainers, normalizeReplacementTrivia, rebuildUnsharedChain, restoreSeparatorOnFill, dropDoubledSeparator, emptyParagraph, paragraphNode } from '../tree-operations';
+import { replacePreservingFirst, stampStructuralChange } from '../tree-operations/structural-change';
+import { spliceMany } from '../tree-operations/splice-many';
+import { isMergeEligible, isBlockEditable } from '../schema/merge-rules';
+import { getBlockKindDescriptor } from '../schema/block-kind-descriptor';
+import { mergedElseFocusNext, mergedElseFocusPrevious } from './merge-fallback';
+/** The byte/settle sinks' owner answer, read live off the commit's owned view. */
+const bodyParentOf = (view) => ({
+    children: view.children,
+    ownerKind: view.ownerKind,
+    owner: view.owner
+});
+/** The ineligible-merge cascade both directions share; `dir` names the neighbour side. */
+async function handleIneligibleNeighbor(scope, i, dir) {
+    const neighbor = i + dir;
+    const neighborKind = scope.children()[neighbor].kind;
+    // A whole-block-focus neighbor is focused, not deleted: press one highlights it, a second
+    // press deletes it. Ordered first so a not-mergeable-but-editable kind never dead-ends here.
+    if (getBlockKindDescriptor(neighborKind).blockFocus === 'whole-block') {
+        scope.refAt(neighbor)?.focus(0);
+        return;
+    }
+    if (isBlockEditable(neighborKind)) {
+        scope.refAt(neighbor)?.focus(dir < 0 ? CURSOR_END : CURSOR_START);
+        return;
+    }
+    await scope.commit({
+        snapshot: { index: i, offset: dir < 0 ? 0 : CURSOR_END },
+        eventTarget: neighbor,
+        op: { kind: 'delete' },
+        mutate: (view) => performDelete(bodyParentOf(view), neighbor, view.sharing),
+        afterTick: () => scope.refAt(dir < 0 ? neighbor : i)?.focus(dir < 0 ? CURSOR_START : CURSOR_END),
+        discardIfNoop: true
+    });
+}
+export function createBlockEditCore(scope) {
+    const core = {
+        async split(i, offset) {
+            // Offset 0 is not special: empty block above, content below, caret on the content. The
+            // landing is the primitive's answer, not `i + 1` — a plural first half pushes the
+            // second half further down, and G1.34 holds the seat to it.
+            let secondHalfIndex = i + 1;
+            let split;
+            await scope.commit({
+                snapshot: { index: i, offset },
+                eventTarget: i,
+                op: { kind: 'split', detail: { at: offset } },
+                mutate: (view) => {
+                    split = performSplit(bodyParentOf(view), i, offset, view.sharing, view.getPresentationMode?.(), view.linkRef);
+                    secondHalfIndex = split.secondHalfIndex;
+                    stampStructuralChange(view.children, split.change, view.sharing);
+                    return split.change;
+                },
+                afterTick: () => {
+                    if (split)
+                        assertSplitLanding(split, secondHalfIndex);
+                    scope.refAt(secondHalfIndex)?.focus(CURSOR_EXACT_START);
+                },
+                // A single-line/chrome block splits to nothing, so discard rather than
+                // mint a dead entry on a rebound Enter.
+                discardIfNoop: true
+            });
+        },
+        async descendToBody(i) {
+            const children = scope.children();
+            // A body child already exists: pure focus move, no undo entry. An absent ref
+            // (windowed-out, or a collapsed body) leaves the caret put — load-bearing.
+            if (i + 1 < children.length) {
+                scope.refAt(i + 1)?.focus(CURSOR_START);
+                return;
+            }
+            await scope.commit({
+                snapshot: { index: i, offset: 0 },
+                eventTarget: i + 1,
+                op: { kind: 'appendBlock' },
+                mutate: (view) => {
+                    // The synthesized body line IS a line ending, so it takes the chrome
+                    // sibling's (G4.20); a defaulted LF strands one in a CRLF container.
+                    const body = emptyParagraph('', trailingLineEnding(view.children[i]?.raw ?? '\n'));
+                    view.children.splice(i + 1, 0, body);
+                    const change = { op: 'insert', at: i + 1, count: 1 };
+                    stampStructuralChange(view.children, change, view.sharing);
+                    return change;
+                },
+                afterTick: () => scope.refAt(i + 1)?.focus(0)
+            });
+        },
+        /**
+         * The between-blocks caret's mint (`selection/gap-caret.ts`). `i` is a BOUNDARY index,
+         * so `children.length` appends; the caret lands after the text the paragraph carries.
+         */
+        async insertParagraph(i, text) {
+            const children = scope.children();
+            // Both the separator and the paragraph's own bytes ARE line endings, so both take a
+            // real neighbour's (G4.20); a boundary always has one on at least one side.
+            const lineEnding = trailingLineEnding((children[i - 1] ?? children[i])?.raw ?? '\n');
+            await scope.commit({
+                snapshot: { index: i, offset: 0 },
+                eventTarget: i,
+                op: { kind: 'insertBlock' },
+                mutate: (view) => {
+                    // Only the scope's head block owns no separator; anywhere else the mint owes
+                    // its predecessor a blank line, whatever the displaced sibling carried.
+                    const trivia = i > 0 ? lineEnding : (view.children[0]?.leadingTrivia ?? '');
+                    view.children.splice(i, 0, paragraphNode(trivia, text, lineEnding));
+                    const change = { op: 'insert', at: i, count: 1 };
+                    stampStructuralChange(view.children, change, view.sharing);
+                    // A gap-caret paragraph is a block of its own on BOTH sides, which the splice
+                    // settle cannot infer: the displaced sibling is a body block now, not the head,
+                    // so it owes its own separator, and an EMPTY mint is a blank line itself.
+                    const parent = bodyParentOf(view);
+                    restoreSeparatorOnFill(parent, i + 1, view.sharing);
+                    dropDoubledSeparator(parent, i, view.sharing);
+                    return change;
+                },
+                afterTick: () => scope.refAt(i)?.focus(displayLength(text))
+            });
+        },
+        async mergeWithPreviousInterior(i) {
+            const children = scope.children();
+            const prevKind = children[i - 1].kind;
+            const currKind = children[i].kind;
+            if (!isMergeEligible(prevKind, currKind)) {
+                await handleIneligibleNeighbor(scope, i, -1);
+                return;
+            }
+            let mergeResult = null;
+            await scope.commit({
+                snapshot: { index: i, offset: 0 },
+                eventTarget: i,
+                op: { kind: 'merge', detail: { direction: 'prev' } },
+                mutate: (view) => {
+                    mergeResult = mergeIntoPrevDeepLeaf(bodyParentOf(view), i, view.sharing, view.getPresentationMode?.(), view.linkRef, view.grammar);
+                    return mergeResult?.change ?? { op: 'noop' };
+                },
+                afterTick: () => {
+                    const ref = scope.refAt(i - 1);
+                    const merged = mergedElseFocusPrevious(mergeResult, ref);
+                    if (!merged)
+                        return;
+                    if (merged.targetPath.length === 0)
+                        ref?.focus(merged.joinOffset);
+                    else
+                        ref?.focusByPath?.(merged.targetPath, merged.joinOffset);
+                },
+                // A no-target merge changes nothing; discard the entry but keep afterTick,
+                // which still lands the caret.
+                discardIfNoop: true
+            });
+        },
+        async mergeWithNextInterior(i) {
+            const children = scope.children();
+            const currKind = children[i].kind;
+            const nextKind = children[i + 1].kind;
+            if (!isMergeEligible(currKind, nextKind)) {
+                await handleIneligibleNeighbor(scope, i, 1);
+                return;
+            }
+            // The landing is the primitive's answer, not `displayLength` read ahead of it: a live
+            // seam cleanup drops runs on the first block's side and moves where the two met.
+            let merged = { change: { op: 'noop' }, joinOffset: 0 };
+            await scope.commit({
+                snapshot: { index: i, offset: CURSOR_END },
+                eventTarget: i,
+                op: { kind: 'merge', detail: { direction: 'next' } },
+                mutate: (view) => {
+                    merged = performMergeNext({ children: view.children }, i, view.getPresentationMode?.(), view.linkRef);
+                    stampStructuralChange(view.children, merged.change, view.sharing);
+                    return merged.change;
+                },
+                afterTick: () => {
+                    if (mergedElseFocusNext(merged.change, scope.refAt(i + 1))) {
+                        scope.refAt(i)?.focus(merged.joinOffset);
+                    }
+                },
+                discardIfNoop: true
+            });
+        },
+        async deleteInterior(i) {
+            await scope.commit({
+                snapshot: { index: i, offset: 0 },
+                eventTarget: i,
+                op: { kind: 'delete' },
+                mutate: (view) => performDelete(bodyParentOf(view), i, view.sharing),
+                afterTick: () => {
+                    const focusIdx = Math.min(i, scope.children().length - 1);
+                    if (focusIdx >= 0)
+                        scope.refAt(focusIdx)?.focus(CURSOR_START);
+                },
+                discardIfNoop: true
+            });
+        },
+        async updateBlockMetadata(i, metadata, options) {
+            const children = scope.children();
+            if (i < 0 || i >= children.length)
+                return;
+            const fields = Object.keys(metadata);
+            if (fields.length === 0)
+                return;
+            // `mutate` returns noop, so the ceremony's dev oracle can't infer the resynced
+            // node. The owned copy exists only after unshareChild, hence a stable array
+            // the ceremony reads post-mutate.
+            const touchedNodes = [];
+            await scope.commit({
+                snapshot: options?.undoEntry === 'join' ? 'skip' : { index: i, offset: 0 },
+                eventTarget: i,
+                op: { kind: 'metadataUpdate', detail: { fields } },
+                touchedNodes,
+                mutate: (view) => {
+                    const node = view.unshareChild(i);
+                    node.metadata = { ...(node.metadata ?? {}), ...metadata };
+                    // Through the chain funnel, not a bare rebuild: metadata can feed the
+                    // container's OPENER line (an alert's type), so the rebuilt bytes may open
+                    // as a different kind. The document branch runs no chain rebuild of its
+                    // own, so this is the only seam a top-level metadata write crosses.
+                    // `folds: null` — the rebuild root is the commit's own scope array, whose
+                    // descriptor this mutate has already fixed as `noop`.
+                    const [reclassified] = rebuildUnsharedChain({ children: view.children }, [node], view.sharing, null, view.grammar);
+                    touchedNodes.push(reclassified?.replacement ?? node);
+                    return { op: 'noop' };
+                },
+                afterTick: options?.afterTick
+            });
+        },
+        async replaceBlock(i, replacement, focus, options) {
+            const children = scope.children();
+            if (i < 0 || i >= children.length)
+                return;
+            // `snapshotOffset` is where the caret WAS, which undo restores; `focus.offset` is where
+            // it lands. They part company when the replacement seats it inside a new structure.
+            const snapshot = options?.undoEntry === 'join'
+                ? 'skip'
+                : { index: i, offset: options?.snapshotOffset ?? focus?.offset ?? 0 };
+            await scope.commit({
+                snapshot,
+                eventTarget: i,
+                // Empty-replace op-kind is per-scope: top-level emits `replaceBlock{count:0}`,
+                // container collapses to `delete`. The structural change is `delete` either way.
+                op: replacement.length === 0
+                    ? scope.collapseEmptyReplaceToDelete
+                        ? { kind: 'delete' }
+                        : { kind: 'replaceBlock', detail: { count: 0 } }
+                    : { kind: 'replaceBlock', detail: { count: replacement.length } },
+                mutate: (view) => {
+                    if (replacement.length === 0) {
+                        view.children.splice(i, 1);
+                        return { op: 'delete', at: i, count: 1 };
+                    }
+                    const normalized = normalizeReplacementTrivia(view.children[i], replacement);
+                    for (const node of normalized)
+                        ensureEditableContainers(node);
+                    spliceMany(view.children, i, 1, normalized);
+                    const change = replacePreservingFirst(i, 1, normalized.length);
+                    stampStructuralChange(view.children, change, view.sharing);
+                    return change;
+                },
+                afterTick: () => {
+                    if (!focus || replacement.length === 0)
+                        return;
+                    const ref = scope.refAt(i + focus.replacementIndex);
+                    if (focus.path?.length)
+                        ref?.focusByPath?.(focus.path, focus.offset);
+                    else
+                        ref?.focus(focus.offset);
+                }
+            });
+        }
+    };
+    return core;
+}

package/dist/editor-actions/block-edit-scope.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Per-level adapter for the shared block-edit core: commit ceremony, child addressing, refs and
+ * unshare, for a top-level edit vs a container one. Both factories are the SINGLE mint point for
+ * the commit args' doc-absolute paths, as `DocPath` — the core hands over local indices only.
+ * G1.16 stays the runtime belt for the JS callers types don't bind.
+ */
+import type { OpDescriptor } from '../schema/operations';
+import type { CommitAfterTick, ContainerScope } from '../action-contracts';
+import type { AnyBlockKind, CstNode } from '../core/nodes';
+import type { NodeView } from '../core/node-views';
+import type { StructuralChange } from '../tree-operations/structural-change';
+import type { SharingState } from '../tree-operations/sharing';
+import type { GrammarView } from '../schema/block-openers';
+import type { InlineResolverRef } from '../schema/inline-construct-policy';
+import type { PresentationModeGetter } from '../editor-keys';
+import type { BlockComponent } from '../block-component';
+import type { EditorActionsDeps, UndoController } from './deps';
+import type { NestedActionsDeps } from './nested/nested-actions';
+import type { BlockListState } from '../reactivity/block-list-state.svelte';
+/** Owned mutation view the core's `mutate` writes through — uniform across levels. */
+export interface MutationView {
+    children: CstNode[];
+    sharing: SharingState;
+    /** The container these children belong to, for mutations whose bytes must satisfy
+     *  its grammar (`bodyWrite`). Absent at the document root. */
+    ownerKind?: AnyBlockKind;
+    /** The container NODE itself, for settles that write its wrap slots. Nullable
+     *  rather than optional so each adapter answers; `undefined` is the document root. */
+    owner: CstNode | undefined;
+    /** The instance's block grammar, for mutations that re-parse. Absent = the global grammar. */
+    grammar?: GrammarView;
+    /** Live EFFECTIVE mode, for mutations whose bytes depend on what the mode paints. Nullable
+     *  rather than optional so each adapter answers; `undefined` reads as not-live. */
+    getPresentationMode: PresentationModeGetter | undefined;
+    /** The instance's link-reference resolver, so a rewrite parses the reference forms the render
+     *  path drew. Nullable for the same reason as the mode; `undefined` reads them as brackets. */
+    linkRef: InlineResolverRef | undefined;
+    /** Copy-out-of-sharing the child at `i` before an in-place write; returns the owned node. */
+    unshareChild(i: number): CstNode;
+}
+export interface ScopeCommitArgs {
+    /** Snapshot coordinate in THIS scope's local index space, or 'skip' to join a caller's entry. */
+    snapshot: {
+        index: number;
+        offset: number;
+    } | 'skip';
+    /** Local index the edit event targets; the factory prefixes the scope's absolute path. */
+    eventTarget: number;
+    op: OpDescriptor;
+    mutate: (view: MutationView) => StructuralChange;
+    afterTick?: CommitAfterTick;
+    /**
+     * Leaves the dev staleness oracle checks when `mutate` returns `noop`. The owned
+     * copy exists only after `mutate` runs, hence a stable array. Top-level only.
+     */
+    touchedNodes?: CstNode[];
+    /**
+     * A structural op that can legitimately no-op, so the ceremony discards the snapshot
+     * rather than mint a dead entry. Never on content/metadata commits — their `noop`
+     * still carries a byte change (action-contracts `DiscardIfNoop`).
+     */
+    discardIfNoop?: boolean;
+}
+export interface CommitScope {
+    /** Read accessor — mutation happens through the commit's owned view, never this. */
+    children(): readonly NodeView[];
+    refAt(i: number): BlockComponent | undefined;
+    /** Empty replaceBlock emits `delete` (container) vs `replaceBlock{count:0}` (top-level). */
+    collapseEmptyReplaceToDelete: boolean;
+    commit(args: ScopeCommitArgs): Promise<void>;
+}
+/** The byte/settle sinks' owner answer for a container commit's own scope — {@link MutationView}'s twin. */
+export declare const scopeParentOf: (scope: ContainerScope) => {
+    children: CstNode[];
+    ownerKind: "heading" | "setextHeading" | "paragraph" | "fencedCode" | "thematicBreak" | "indentedCode" | "htmlBlock" | "linkReferenceDefinition" | "tableCell" | "unrecognized" | "blockquote" | "list" | "listItem" | "table" | "tableRow" | import("../plugin").PluginBlockKind;
+    owner: CstNode;
+};
+export declare function createTopLevelScope(deps: EditorActionsDeps, controller: UndoController): CommitScope;
+export declare function createContainerScope(state: BlockListState, deps: NestedActionsDeps): CommitScope;

package/dist/editor-actions/block-edit-scope.js

@@ -0,0 +1,76 @@
+/**
+ * Per-level adapter for the shared block-edit core: commit ceremony, child addressing, refs and
+ * unshare, for a top-level edit vs a container one. Both factories are the SINGLE mint point for
+ * the commit args' doc-absolute paths, as `DocPath` — the core hands over local indices only.
+ * G1.16 stays the runtime belt for the JS callers types don't bind.
+ */
+import { ensureUnsharedPath, ensureUnsharedChild } from '../tree-operations';
+import { asDocPath } from '../selection/path-math';
+import { extendDocPath } from '../cursor/coordinate-spaces';
+/** The byte/settle sinks' owner answer for a container commit's own scope — {@link MutationView}'s twin. */
+export const scopeParentOf = (scope) => ({
+    children: scope.children,
+    ownerKind: scope.node.kind,
+    owner: scope.node
+});
+// ── Top-level adapter ────────────────────────────────────────────────────────
+export function createTopLevelScope(deps, controller) {
+    return {
+        children: () => deps.doc.children,
+        refAt: (i) => deps.blockRefs[i],
+        collapseEmptyReplaceToDelete: false,
+        commit({ snapshot, eventTarget, op, mutate, afterTick, touchedNodes, discardIfNoop }) {
+            return controller.commitStructural({
+                snapshot: snapshot === 'skip'
+                    ? 'skip'
+                    : { path: asDocPath([snapshot.index]), offset: snapshot.offset },
+                mutate: (children) => mutate({
+                    children,
+                    sharing: deps.sharing,
+                    owner: undefined,
+                    grammar: deps.grammar,
+                    getPresentationMode: deps.getPresentationMode,
+                    linkRef: deps.linkRef,
+                    unshareChild: (i) => ensureUnsharedPath({ children }, [i], deps.sharing)[0]
+                }),
+                op: { ...op, eventPath: asDocPath([eventTarget]) },
+                afterTick,
+                touchedNodes,
+                discardIfNoop
+            });
+        }
+    };
+}
+// ── Container adapter ────────────────────────────────────────────────────────
+export function createContainerScope(state, deps) {
+    return {
+        // A fold at this container's own slot detaches it (`tree-operations/unshare.ts`), so a
+        // post-commit read can find the scope gone rather than merely empty.
+        children: () => deps.node?.children ?? [],
+        refAt: (i) => state.innerBlockRefs[i],
+        collapseEmptyReplaceToDelete: true,
+        commit({ snapshot, eventTarget, op, mutate, afterTick, discardIfNoop }) {
+            return deps.parent.containerEdit.commitContainer({
+                containerNode: deps.node,
+                path: deps.path,
+                state,
+                snapshot: snapshot === 'skip'
+                    ? 'skip'
+                    : { path: extendDocPath(deps.path, snapshot.index), offset: snapshot.offset },
+                mutate: (scope) => mutate({
+                    children: scope.children,
+                    sharing: scope.sharing,
+                    ownerKind: scope.node.kind,
+                    owner: scope.node,
+                    grammar: deps.grammar,
+                    getPresentationMode: deps.getPresentationMode,
+                    linkRef: deps.linkRef,
+                    unshareChild: (i) => ensureUnsharedChild(scope.node, i, scope.sharing)
+                }),
+                op: { ...op, eventPath: extendDocPath(deps.path, eventTarget) },
+                afterTick,
+                discardIfNoop
+            });
+        }
+    };
+}

package/dist/editor-actions/block-edit.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Top-level BlockEditActions factory. Structural mutations route through the shared
+ * `block-edit-core` against a top-level `CommitScope`; this factory adds the edge
+ * guards and the one per-level body the core can't share, `updateBlockContent`.
+ */
+import type { BlockEditActions } from '../action-contracts';
+import type { EditorActionsDeps, UndoController } from './deps';
+export declare function createBlockEditActions(deps: EditorActionsDeps, controller: UndoController): BlockEditActions;