@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/editor-actions/container-block-component.d.ts

@@ -1,85 +1,66 @@
-/** Shared `BlockComponent` shim for container blocks. */
+/** The shared `BlockComponent` implementation for container blocks. */
 import { type BlockComponent, type ContainerBlockComponent } from '../block-component';
-import { type RefSlots } from '../reactivity/publish-ref.svelte';
+import type { ChildList } from '../reactivity/child-list';
 import type { AnyBlockKind } from '../core/nodes';
 import type { NodeView } from '../core/node-views';
 import type { BlockEditActions, FocusActions } from '../action-contracts';
-import { type GlobalCommandContext } from '../schema/commands';
-import type { KeybindingOverrideMap } from '../schema/keybinding-overrides';
-import type { PluginActivation } from '../schema/plugin-activation';
-import type { StickyColumnState } from '../cursor/sticky-column';
-import type { EdgeAffinityState } from '../cursor/edge-affinity';
+import { type CommandDispatchContext, type KindCommandTarget } from '../schema/block-commands';
+import type { Reading } from '../schema/reading';
+import type { CaretMemory } from '../cursor/caret-memory';
+import type { AnyCommandId } from '../schema/command-id';
 import type { SelectionState } from '../selection/selection-state.svelte';
 import { type WholeBlockInputProxy } from './whole-block-focus-surface';
-export interface EditorGlobalChordDeps extends Pick<GlobalCommandContext, 'history' | 'pluginEditor' | 'onCommandError'> {
-    getKind: () => AnyBlockKind;
-    getKeybindingOverrides: () => KeybindingOverrideMap | undefined;
-    isReading: () => boolean;
-    /** Required here though optional on the context: a whole-block surface that skipped it
-     *  would consume an unlisted plugin's chord. `undefined` = every installed plugin. */
-    activation: PluginActivation | undefined;
-}
+/** Undo, redo and plugin-global chords for a block focused as a whole, which neither an inner leaf
+ *  nor the editor root runs. Consumed in reading mode too, or the browser runs its own undo. */
+export declare function dispatchWholeBlockGlobalChord(e: KeyboardEvent, kind: AnyBlockKind, commands: CommandDispatchContext): boolean;
 /**
- * Undo/redo for a block that IS its own focus target: no inner leaf carries the global tier for
- * it, and the editor root declines while focus sits on the block. `true` means consumed —
- * including in reading mode, since bypassing `dispatchKeyCommand` would otherwise hand a read-only
- * document the browser's native undo.
+ * A chord at a container, resolved against the container's own kind only: a key that bubbled up
+ * from a focused leaf has already met the global chords there.
  */
-export declare function handleEditorGlobalChord(chord: string, deps: EditorGlobalChordDeps): boolean;
+export declare function dispatchContainerChord(e: KeyboardEvent, target: KindCommandTarget, commands: CommandDispatchContext): boolean;
 export interface BlockEdgeExitDeps {
     getIndex: () => number;
     focus: Pick<FocusActions, 'moveFocus'>;
 }
-/**
- * The four plain-arrow exits out of a block, in the direction the key points. Shared by
- * whole-block focus and the plugin container's `moveFocusOut`, so a surface that reaches its
- * own edge lands the same way the built-ins do. False for any other key.
- */
+/** The plain-arrow exits out of a block, shared by whole-block focus and a plugin container's
+ *  `moveFocusOut`, so a plugin editor leaves its edge as the built-ins do. False for other keys. */
 export declare function focusAcrossBlockEdge(key: string, deps: BlockEdgeExitDeps): boolean;
 export interface WholeBlockKeyDeps extends BlockEdgeExitDeps {
     getRaw: () => string;
     blockEdit: Pick<BlockEditActions, 'splitBlock' | 'deleteBlock' | 'insertParagraph'>;
     isReading: () => boolean;
-    stickyColumn: Pick<StickyColumnState, 'noteKey'>;
-    edgeAffinity: Pick<EdgeAffinityState, 'note'>;
+    caretMemory: Pick<CaretMemory, 'noteKey'>;
+    /** What the keypress resolves to at this block's kind, overrides included. */
+    commandOf: (e: KeyboardEvent) => AnyCommandId | null;
 }
 /**
- * The whole-block-focus key tail shared by ThematicBreakBlock and the plugin container
- * factory, so a new gate lands once instead of at both. Navigation never gates.
+ * The whole-block key handling shared by ThematicBreakBlock and the plugin container
+ * factory, so a new check lands once instead of at both. Navigation is never checked.
  */
 export declare function handleWholeBlockKeys(e: KeyboardEvent, deps: WholeBlockKeyDeps): void;
 export interface ContainerBlockComponentDeps {
-    /** What the mounted surface reports as `editable`, mirroring the kind's descriptor flag;
+    /** What the mounted component reports as `editable`, mirroring the kind's descriptor flag;
      *  omitted stays `true`, the built-in containers' answer. A getter, never a snapshot. */
     readonly editable?: boolean;
-    /** Ends a live cross-block range when `focus` lands a caret — a whole-block landing
+    /** Ends a live cross-block range when `focus` places a caret: focusing a whole block
      *  reaches no child to borrow it from. */
     readonly selection: SelectionState;
     readonly innerBlockRefs: (BlockComponent | undefined)[];
-    /** The same scope's slots — the array for the dispatch walks, this for the reveal's
-     *  mount-wait, which needs an identity the array's replacement can't invalidate. */
-    readonly refSlots: RefSlots<BlockComponent>;
-    readonly nodeChildrenLength: number;
-    /** For the pure-data transparency test, which must work off-window where
-     *  `innerBlockRefs` is sparse (VR-6). */
+    /** The same children as a descent reads them: their count, ref slots, render window and
+     *  collapse. `childList()` publishes it. */
+    readonly childList: ChildList;
+    /** For the widget-only check, which reads the node so it works for an unmounted
+     *  container where `innerBlockRefs` is sparse (VR-6). */
     readonly node: NodeView;
-    /** Scroll this scope so child `index` enters its window; resolves after a tick. */
-    readonly revealChild?: (index: number) => Promise<void>;
-    /** Lets the reveal degrade instead of hanging when a scroll missed (VR-5). */
-    readonly isInWindow?: (index: number) => boolean;
-    /** Collapse clamp — while true only the chrome row is mounted, so a focus extremum
-     *  entering the container clamps to it rather than no-oping on an unmounted child. */
-    readonly isCollapsed?: () => boolean;
-    /** Open this container so a reveal can descend into its clamped-out body, as a real
-     *  committed edit. Absent leaves the reveal to degrade on the chrome row. */
-    readonly expandCollapsed?: () => Promise<boolean>;
-    /** Whole-block-focus element for an opaque childless container, already composed
+    /** How the editor reads its bytes, whose grammar the widget-only check reads the node in. */
+    readonly reading: Reading;
+    /** The focus element of a childless container focused as a whole, already composed
      *  through `composeWholeBlockFocusSurface`. */
     readonly getFocusEl?: () => HTMLElement | null | undefined;
-    /** A childless opaque container has no child hosts to paint search/decoration
-     *  rects, so `measurePartialRects` measures the block itself off this element. */
+    /** A childless container has no child elements to measure search or decoration rects
+     *  from, so `measurePartialRects` measures the block itself off this element. */
     readonly getBoxEl?: () => HTMLElement | null | undefined;
-    /** The hidden editing host beside the declared surface, where whole-block focus lands. */
+    /** The hidden editing host beside the declared element, where whole-block focus lands. */
     readonly inputProxy?: WholeBlockInputProxy;
 }
 export declare function createContainerBlockComponent(deps: ContainerBlockComponentDeps): ContainerBlockComponent;

package/dist/editor-actions/container-block-component.js

@@ -1,34 +1,38 @@
-/** Shared `BlockComponent` shim for container blocks. */
-import { CURSOR_END, CURSOR_EXACT_START, CURSOR_START, FOCUS_LAST_START } from '../block-component';
-import { dispatchFocusByPath, dispatchFocusAtColumn, dispatchGetBlockComponentByPath } from './focus/focus-dispatch';
-import { revealChildOrWait } from '../reactivity/publish-ref.svelte';
+/** The shared `BlockComponent` implementation for container blocks. */
+import { entryEdge } from '../block-component';
+import { dispatchFocusByPath, dispatchFocusAtColumn } from './focus/focus-dispatch';
 import { runGlobalChordOnKind } from '../schema/commands';
-import { isCharacterKey } from '../schema/keybindings';
+import { dispatchKindCommand } from '../schema/block-commands';
+import { eventToChord, isCharacterKey } from '../schema/keybindings';
 import { displayLength, trimTrailingLineEnding } from '../core/lines';
 import { isVerticallyTransparentNode } from '../core/inline/transparency';
 import { placeCaret } from '../selection/caret-doors';
 import { focusWholeBlockEl, holdsWholeBlockFocus } from './whole-block-focus-surface';
 import { devWarn } from '../dev-warn';
-/**
- * Undo/redo for a block that IS its own focus target: no inner leaf carries the global tier for
- * it, and the editor root declines while focus sits on the block. `true` means consumed —
- * including in reading mode, since bypassing `dispatchKeyCommand` would otherwise hand a read-only
- * document the browser's native undo.
- */
-export function handleEditorGlobalChord(chord, deps) {
-    return runGlobalChordOnKind(chord, deps.getKind(), deps.getKeybindingOverrides(), {
-        isReading: deps.isReading(),
-        history: deps.history,
-        pluginEditor: deps.pluginEditor,
-        onCommandError: deps.onCommandError,
-        activation: deps.activation
-    });
+/** Undo, redo and plugin-global chords for a block focused as a whole, which neither an inner leaf
+ *  nor the editor root runs. Consumed in reading mode too, or the browser runs its own undo. */
+export function dispatchWholeBlockGlobalChord(e, kind, commands) {
+    const chord = eventToChord(e);
+    if (!chord || !runGlobalChordOnKind(chord, kind, commands))
+        return false;
+    e.preventDefault();
+    return true;
 }
 /**
- * The four plain-arrow exits out of a block, in the direction the key points. Shared by
- * whole-block focus and the plugin container's `moveFocusOut`, so a surface that reaches its
- * own edge lands the same way the built-ins do. False for any other key.
+ * A chord at a container, resolved against the container's own kind only: a key that bubbled up
+ * from a focused leaf has already met the global chords there.
  */
+export function dispatchContainerChord(e, target, commands) {
+    if (e.defaultPrevented)
+        return false;
+    const chord = eventToChord(e);
+    if (!chord || !dispatchKindCommand(chord, target, commands))
+        return false;
+    e.preventDefault();
+    return true;
+}
+/** The plain-arrow exits out of a block, shared by whole-block focus and a plugin container's
+ *  `moveFocusOut`, so a plugin editor leaves its edge as the built-ins do. False for other keys. */
 export function focusAcrossBlockEdge(key, deps) {
     const index = deps.getIndex();
     if (key === 'ArrowUp')
@@ -44,15 +48,13 @@ export function focusAcrossBlockEdge(key, deps) {
     return true;
 }
 /**
- * The whole-block-focus key tail shared by ThematicBreakBlock and the plugin container
- * factory, so a new gate lands once instead of at both. Navigation never gates.
+ * The whole-block key handling shared by ThematicBreakBlock and the plugin container
+ * factory, so a new check lands once instead of at both. Navigation is never checked.
  */
 export function handleWholeBlockKeys(e, deps) {
-    // The classification doors, before any branch: skipping them let a column captured
-    // outside survive a horizontal traversal through, and the arrival side the exit lands
-    // with is the same one an arrow means anywhere. No `measureX` — no caret here.
-    deps.stickyColumn.noteKey(e);
-    deps.edgeAffinity.note(e);
+    // Before any branch, or a column captured elsewhere survives a horizontal move through this
+    // block. No `measureX`: a block focused whole has no caret to measure.
+    deps.caretMemory.noteKey(e, deps.commandOf(e));
     if (e.key === 'Enter') {
         e.preventDefault();
         if (!deps.isReading())
@@ -62,18 +64,18 @@ export function handleWholeBlockKeys(e, deps) {
     if (e.key === 'Backspace' || e.key === 'Delete') {
         e.preventDefault();
         if (!deps.isReading())
-            void deps.blockEdit.deleteBlock(deps.getIndex());
+            void deps.blockEdit.deleteBlock(deps.getIndex(), e.key);
         return;
     }
-    // Mod+C / Mod+X on the block's own markdown: a keydown carries no ClipboardEvent,
-    // and preventDefault suppresses the native copy, so writeText is the sole writer.
+    // Mod+C and Mod+X copy the block's own markdown: a keydown carries no ClipboardEvent,
+    // and preventDefault suppresses the native copy, so writeText is the only writer.
     if ((e.ctrlKey || e.metaKey) && !e.altKey && !e.shiftKey && (e.key === 'c' || e.key === 'x')) {
         e.preventDefault();
         void copyFocusedWholeBlock(deps, e.key === 'x');
         return;
     }
-    // A typed character has nowhere to land on a block that IS its own focus target, so it mints
-    // the paragraph below carrying it (`editor-actions/block-edit-core.ts :: insertParagraph`).
+    // A typed character has nowhere to land on a block focused as a whole, so it creates the
+    // paragraph below carrying it (`editor-actions/block-edit-core.ts :: insertParagraph`).
     if (isCharacterKey(e.key) && !e.isComposing && !e.ctrlKey && !e.metaKey && !e.altKey) {
         e.preventDefault();
         if (!deps.isReading())
@@ -84,8 +86,8 @@ export function handleWholeBlockKeys(e, deps) {
     if (plainArrow && focusAcrossBlockEdge(e.key, deps))
         e.preventDefault();
 }
-// Copy is a read, so it never gates; cut's delete gates on reading mode and only runs
-// once the write resolves, so a rejected write leaves the block in place.
+// Copy is a read, so it is never blocked; cut's delete is blocked in reading mode and only
+// runs once the clipboard write resolves, so a rejected write leaves the block in place.
 async function copyFocusedWholeBlock(deps, cut) {
     try {
         await navigator.clipboard.writeText(trimTrailingLineEnding(deps.getRaw()));
@@ -95,37 +97,32 @@ async function copyFocusedWholeBlock(deps, cut) {
         return;
     }
     if (cut && !deps.isReading())
-        void deps.blockEdit.deleteBlock(deps.getIndex());
+        void deps.blockEdit.deleteBlock(deps.getIndex(), 'cut');
 }
 export function createContainerBlockComponent(deps) {
     const landFocus = (declared) => deps.inputProxy ? deps.inputProxy.focus(declared) : focusWholeBlockEl(declared);
     /**
-     * `focus` lands in a child that never forwarded the park door; `parkCaret` skips it,
-     * because for an extend a missed park costs a caret and `focus` costs the range.
+     * `focus` lands in a child that has no `parkCaret`; `parkCaret` skips it, because during a
+     * selection extend a missed `parkCaret` costs a caret and `focus` costs the range.
      */
     function walkInto(offset, land) {
-        // Whole-block focus: any caret entry lands on the block itself, so the element
-        // offset carries no meaning.
+        // Whole-block focus: any caret entry lands on the block itself, so the offset means
+        // nothing.
         const focusEl = deps.getFocusEl?.();
         if (focusEl) {
             landFocus(focusEl);
             return;
         }
-        if (deps.nodeChildrenLength === 0)
-            return;
-        // Collapsed: only the chrome row is mounted, so a walk-in from below clamps to
-        // it rather than no-oping on the unmounted last child.
-        const last = deps.isCollapsed?.() ? 0 : deps.nodeChildrenLength - 1;
-        const entersFirst = offset === 0 || offset === CURSOR_START || offset === CURSOR_EXACT_START;
-        const child = entersFirst ? deps.innerBlockRefs[0] : deps.innerBlockRefs[last];
-        if (!child)
+        const count = deps.childList.count();
+        if (count === 0)
             return;
-        if (offset === FOCUS_LAST_START)
-            land(child, FOCUS_LAST_START);
-        else if (entersFirst)
-            land(child, offset);
-        else
-            land(child, CURSOR_END);
+        // Collapsed: only the title row is mounted, so an entry from below clamps to it
+        // rather than doing nothing on the unmounted last child.
+        const last = deps.childList.isCollapsed?.() ? 0 : count - 1;
+        const edge = entryEdge(offset);
+        const child = deps.innerBlockRefs[edge.child === 'first' ? 0 : last];
+        if (child)
+            land(child, edge.offset);
     }
     function parkCaret(offset) {
         walkInto(offset, (child, at) => child.parkCaret?.(at));
@@ -165,59 +162,36 @@ export function createContainerBlockComponent(deps) {
         focusByPath(path, offset) {
             dispatchFocusByPath(deps.innerBlockRefs, path, offset);
         },
-        getBlockComponentByPath(path) {
-            return dispatchGetBlockComponentByPath(deps.innerBlockRefs, path);
-        },
-        async revealByPath(path) {
-            if (path.length === 0)
-                return null;
-            const [head, ...rest] = path;
-            // Only a body target needs the door opened; the chrome row stays mounted.
-            // Awaited because everything below must run against the post-commit window.
-            if (head >= 1 && deps.isCollapsed?.())
-                await deps.expandCollapsed?.();
-            if (deps.revealChild) {
-                await revealChildOrWait(head, {
-                    slots: deps.refSlots,
-                    childCount: deps.nodeChildrenLength,
-                    revealChild: deps.revealChild,
-                    isInWindow: deps.isInWindow
-                });
-            }
-            const ref = deps.innerBlockRefs[head];
-            if (!ref)
-                return null;
-            if (rest.length === 0)
-                return ref;
-            return ref.revealByPath
-                ? ref.revealByPath(rest)
-                : (ref.getBlockComponentByPath?.(rest) ?? null);
-        },
+        childList: () => deps.childList,
         focusAtColumn(x, from) {
-            // Whole-block focus has no column to land in, so a vertical entry focuses the
-            // block itself, mirroring the plain-arrow path.
+            // Whole-block focus has no column to land in, so a vertical entry focuses the block
+            // itself, like the plain-arrow path.
             const focusEl = deps.getFocusEl?.();
             if (focusEl) {
                 landFocus(focusEl);
+                // Announced here because this branch reaches neither `placeCaret` nor a text block's
+                // editable element, the two placements that announce for everything else.
+                deps.selection.announceSelection();
                 return;
             }
-            if (deps.nodeChildrenLength === 0)
+            if (deps.childList.count() === 0)
                 return;
             dispatchFocusAtColumn(deps.innerBlockRefs, x, from);
         },
         isVerticallyTransparent() {
-            return isVerticallyTransparentNode(deps.node);
+            return isVerticallyTransparentNode(deps.node, deps.reading.grammar);
         },
         enterEdgeWidget(side) {
-            if (deps.nodeChildrenLength === 0)
+            const count = deps.childList.count();
+            if (count === 0)
                 return false;
-            const edge = side === 'start' ? 0 : deps.nodeChildrenLength - 1;
+            const edge = side === 'start' ? 0 : count - 1;
             return deps.innerBlockRefs[edge]?.enterEdgeWidget?.(side) ?? false;
         },
         measurePartialRects(start, end) {
-            // Opaque single-unit: a childless container paints the whole box. A
-            // child-bearing one returns nothing — the overlay routes to its children.
-            if (deps.nodeChildrenLength > 0)
+            // A childless container is one unit and measures its whole box. One with children
+            // returns nothing; the overlay measures its children instead.
+            if (deps.childList.count() > 0)
                 return [];
             const box = deps.getBoxEl?.();
             if (!box || end <= start)

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

@@ -1,6 +1,8 @@
 /**
- * ContainerEditActions factory: the debounced checkpoint pusher for raw typing
- * outside the commit primitive, the doc-root reactivity nudge, and `commitContainer`.
+ * The root ContainerEditActions: what a container reaches the editor root for, which is the
+ * document's line ending, the container commit, the two things a keystroke needs the root for
+ * (grouping it with its typing burst, and the write that keeps the leaf in place), and the caret
+ * landing with the whole-document read a delete's caret needs.
  */
 import type { ContainerEditActions } from '../action-contracts';
 import type { EditorActionsDeps, UndoController } from './deps';

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

@@ -1,50 +1,20 @@
 /**
- * ContainerEditActions factory: the debounced checkpoint pusher for raw typing
- * outside the commit primitive, the doc-root reactivity nudge, and `commitContainer`.
+ * The root ContainerEditActions: what a container reaches the editor root for, which is the
+ * document's line ending, the container commit, the two things a keystroke needs the root for
+ * (grouping it with its typing burst, and the write that keeps the leaf in place), and the caret
+ * landing with the whole-document read a delete's caret needs.
  */
-import { ensureUnsharedPath } from '../tree-operations/unshare';
-import { rebuildUnsharedChain } from '../tree-operations/chain-rebuild';
-import { publishAncestryFolds, publishScopeFold } from './ancestry-folds';
+import { documentLineEnding } from '../core/lines';
+import { createLeafTyping } from './leaf-write';
+import { survivorAfterRemoval } from '../selection/caret-target';
 export function createContainerEditActions(deps, controller) {
+    const { typeInLeaf, writeLeafInPlace } = createLeafTyping(deps, controller);
     return {
-        pushDebouncedCheckpoint(leafPath, offset, batchKey) {
-            deps.stickyColumn.reset();
-            deps.edgeAffinity.reset();
-            controller.pushUndoSnapshotDebounced(leafPath, offset, batchKey);
-        },
-        armDebouncedPause() {
-            controller.armUndoPause();
-        },
-        nudgeReactivity() {
-            // Raw mutations made outside the commit primitive surface through this nudge,
-            // so Svelte re-reads doc.children.
-            deps.doc.children = [...deps.doc.children];
-        },
-        withUnsharedSpine(absPath, write) {
-            const chain = ensureUnsharedPath(deps.doc, absPath, deps.sharing);
-            // Read before the write: it is the one byte-state no level of the rebuild can capture
-            // for itself, and the ancestry splice needs it to place the leaf's own region.
-            const leafPreviousRaw = chain[chain.length - 1]?.raw;
-            const written = write(chain, deps.sharing) ?? { op: 'noop' };
-            // Unconditional: this door exists to carry bytes, and a short chain or a `noop`
-            // settle says nothing about whether `write` moved any.
-            deps.bumpContentVersion();
-            // The write's own settle can splice the scope it wrote in, and a short chain means the
-            // unshare never reached that scope, so there is nothing to publish against.
-            if (chain.length === absPath.length) {
-                publishScopeFold(deps, chain[absPath.length - 2], written);
-            }
-            // The ANCESTRY settle's folds — a container's own slot in its PARENT, not the write's
-            // scope published above. Their unwind is discarded on purpose: nothing rolls back at a
-            // door that is not a ceremony. Their caret landing (`foldLandingFor`) wants a tick this
-            // synchronous door has not got, and no producer reaches one.
-            const folds = [];
-            const replacements = rebuildUnsharedChain(deps.doc, chain, deps.sharing, folds, deps.grammar, leafPreviousRaw === undefined ? undefined : { path: absPath, leafPreviousRaw });
-            publishAncestryFolds(deps, folds);
-            return replacements.length > 0;
-        },
-        commitContainer(args) {
-            return controller.commitContainerStructural(args);
-        }
+        lineEnding: () => documentLineEnding(deps.doc),
+        commitContainer: (args) => controller.commitContainerStructural(args),
+        typeInLeaf,
+        writeLeafInPlace,
+        land: (pos) => deps.caretLanding.land(pos),
+        survivorAfterRemoval: (removedPath, gesture) => survivorAfterRemoval(deps.doc, removedPath, gesture)
     };
 }

package/dist/editor-actions/container-exit-overrides.d.ts

@@ -1,16 +1,18 @@
 /**
- * Override factory every plugin-seam container shares: the Enter-on-empty-last-child exit.
- * Backspace unwrap (U2) is declaration-driven — the kind's `unwrapRole` selects strategies
- * in `unwrap-strategies.ts`.
+ * The override every plugin container shares: Enter on an empty last child exits the
+ * container. Backspace unwrap comes from the kind's declared `unwrapRole`, which picks a
+ * strategy in `unwrap-strategies.ts` (`docs/design/editor.md` § Container unwrap).
  */
 import type { BlockEditActions } from '../action-contracts';
+import type { Reading } from '../schema/reading';
 import type { NestedActionsBundle, NodeScope } from './nested/nested-actions';
 export interface ContainerExitOverridesDeps {
     scope: NodeScope;
     parentBlockEdit: BlockEditActions;
+    reading: Reading;
 }
 export declare function createContainerExitOverrides(deps: ContainerExitOverridesDeps): (defaults: NestedActionsBundle) => {
     blockEdit: {
-        splitBlock: (innerIndex: number, offset: number) => Promise<void>;
+        splitBlock: (innerIndex: number, offset: number) => Promise<boolean>;
     };
 };

package/dist/editor-actions/container-exit-overrides.js

@@ -1,37 +1,35 @@
 /**
- * Override factory every plugin-seam container shares: the Enter-on-empty-last-child exit.
- * Backspace unwrap (U2) is declaration-driven — the kind's `unwrapRole` selects strategies
- * in `unwrap-strategies.ts`.
+ * The override every plugin container shares: Enter on an empty last child exits the
+ * container. Backspace unwrap comes from the kind's declared `unwrapRole`, which picks a
+ * strategy in `unwrap-strategies.ts` (`docs/design/editor.md` § Container unwrap).
  */
-import { displayLength } from '../core/lines';
+import { displayLength, isBlankText } from '../core/lines';
 import { buildQuoteExitReplacement } from '../tree-operations/blockquote';
 export function createContainerExitOverrides(deps) {
     return (defaults) => ({
         blockEdit: {
-            // Enter on an empty trailing paragraph exits the container instead of appending another
-            // inner line, and MINTS the blank it lands on: Enter is never down-nav, so a block
-            // below is left alone and a nested container is escaped one level per press.
+            // Enter on an empty last paragraph exits onto a new blank paragraph after the container,
+            // never into an existing block, so nested containers are escaped one level per Enter.
             splitBlock: async (innerIndex, offset) => {
                 const { parentBlockEdit } = deps;
                 const { node, index } = deps.scope;
                 if (!node.children)
-                    return;
+                    return false;
                 const child = node.children[innerIndex];
                 const isLastChild = innerIndex === node.children.length - 1;
-                const isEmpty = child.kind === 'paragraph' && child.raw.trim() === '';
-                if (isLastChild && isEmpty) {
-                    if (node.children.length <= 1) {
-                        await parentBlockEdit.splitBlock(index, displayLength(node.raw));
-                    }
-                    else {
-                        await parentBlockEdit.replaceBlock(index, buildQuoteExitReplacement(node), {
-                            replacementIndex: 1,
-                            offset: 0
-                        });
-                    }
-                    return;
+                const isEmpty = child.kind === 'paragraph' && isBlankText(child.raw);
+                if (!isLastChild || !isEmpty)
+                    return defaults.blockEdit.splitBlock(innerIndex, offset);
+                if (node.children.length <= 1) {
+                    return parentBlockEdit.splitBlock(index, displayLength(node.raw));
                 }
-                return defaults.blockEdit.splitBlock(innerIndex, offset);
+                return parentBlockEdit.replaceBlock(index, buildQuoteExitReplacement(node, deps.reading.grammar), {
+                    replacementIndex: 1,
+                    offset: 0
+                }, 
+                // The caret sat in a child leaf, which an offset into the quote can't name; the
+                // live read records it.
+                { snapshotOffset: 0 });
             }
         }
     });

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

@@ -1,60 +1,53 @@
 import type { BlockComponent } from '../block-component';
 import type { Document } from '../core/nodes';
-import type { StickyColumnState } from '../cursor/sticky-column';
-import type { EdgeAffinityState } from '../cursor/edge-affinity';
-import type { BlockElLookup, PresentationModeGetter } from '../editor-keys';
+import type { CaretMemory } from '../cursor/caret-memory';
+import type { BlockElLookup } from '../editor-keys';
 import type { SelectionState } from '../selection/selection-state.svelte';
 import type { UndoEntry, UndoManager } from '../undo/types';
 import type { SharingState } from '../tree-operations/sharing';
 import type { EditorEvents } from '../editor-events';
 import type { CommitController } from '../action-contracts';
-import type { GrammarView } from '../schema/block-openers';
-import type { InlineResolverRef } from '../schema/inline-construct-policy';
+import type { Reading } from '../schema/reading';
 import type { RefSlots } from '../reactivity/publish-ref.svelte';
+import type { CaretLanding } from '../selection/caret-landing';
 export interface EditorActionsDeps {
     get doc(): Document;
     get blockIds(): string[];
     get blockRefs(): (BlockComponent | undefined)[];
-    /** The top-level scope's slot identity, so the doc-scope adapter reports the same
-     *  scope the editor's own BlockList publishes into. */
+    /** The root block list's ref slots, so the document-scope adapter reports the same
+     *  list the editor's own BlockList writes into. */
     blockRefSlots: RefSlots<BlockComponent>;
     setDoc(doc: Document): void;
     setBlockIds(ids: string[]): void;
     setBlockRefs(refs: (BlockComponent | undefined)[]): void;
-    /** Announce that this door moved the document's bytes
-     *  (`reactivity/content-version.svelte.ts`). The ceremony owes one call per commit; the
-     *  writers outside it owe their own, which is the census G4.52 keeps honest. */
+    /** Announce that the document's bytes changed. A commit calls it once; a writer outside a
+     *  commit must call it itself (G4.52). */
     bumpContentVersion(): void;
     undoManager: UndoManager;
     sharing: SharingState;
-    stickyColumn: StickyColumnState;
-    edgeAffinity: EdgeAffinityState;
+    caretMemory: CaretMemory;
     selectionState: SelectionState;
     getBlockElByPath: BlockElLookup;
-    /** Scroll an off-window top-level block into the render window and await its
-     *  mount, then return its component (null if unreachable). Already-mounted
-     *  targets return synchronously without scrolling. */
-    revealPath(path: number[]): Promise<BlockComponent | null>;
+    /** Where every commit's caret and every restored selection is put down, and the counter an
+     *  undo, redo or swap bumps. */
+    caretLanding: CaretLanding;
     events: EditorEvents;
-    /** The instance's block grammar, so a disabled kind's opener stays skipped when
-     *  the editor re-parses an edited block. Absent = the global grammar. */
-    grammar?: GrammarView;
-    /** Live EFFECTIVE mode, for the seams that must not act in reading mode. Absent in
-     *  harnesses, which `isReadingMode` reads as not-reading. */
-    getPresentationMode?: PresentationModeGetter;
-    /** The instance's link-reference resolver, for the byte rewrites that must parse the reference
-     *  forms the render path drew. Absent in harnesses, which have no definitions to resolve. */
-    linkRef?: InlineResolverRef;
+    /** How the editor reads its bytes: a re-parse or completer reads only the syntax it switched
+     *  on, a rewrite parses the reference links the renderer drew, a write refuses reading mode. */
+    reading: Reading;
 }
 /**
- * The history-typed members added to the contracts-leaf `CommitController`. They stay here so
- * that leaf keeps no edge to `undo/`.
+ * `CommitController` plus the members typed against `undo/`. They live here so
+ * `action-contracts` keeps no import from `undo/`.
  */
 export interface UndoController extends CommitController {
+    /** Call a keystroke's commit into the undo entry its typing batch already holds, so a key that
+     *  reparses into several blocks undoes with the typing around it. Covers the call only. */
+    joinTypingBatch<T>(write: () => T): T;
     captureCurrentState(): UndoEntry;
-    /** Monotonic stamp of the last history swap. A caret landing captures it before its
-     *  reveal and declines when it moved: the tree it was aimed at is no longer on screen. */
-    historyGeneration(): number;
-    /** Announce a swap. The restore road's own call — nothing else may bump it. */
-    noteHistorySwap(): void;
+}
+/** The editor root's deps and controller, which a write addressed by document path starts from. */
+export interface EditorRoot {
+    deps: EditorActionsDeps;
+    controller: UndoController;
 }