@voithos-labs/aragonite 0.10.2 → 0.10.4

package/dist/schema/operations.d.ts

@@ -39,7 +39,7 @@ export interface OperationDetailMap {
         parentItemIdx?: number;
         nestedItemIdx?: number;
     } | {
-        source: 'paste-dispatch' | 'paste-dispatch-table-cell' | 'cross-block-paste-whole-table';
+        source: 'paste-dispatch' | 'paste-dispatch-table-cell' | 'cross-block-covered-block' | 'selection-drop';
     };
     paste: {
         count: number;
@@ -70,6 +70,13 @@ export interface OperationDetailMap {
         colIdx: number;
         side: 'left' | 'right';
     };
+    /** A grid pasted from `rowIdx`/`colIdx`, the table grown to hold it. */
+    tablePasteGrid: {
+        rowIdx: number;
+        colIdx: number;
+        rows: number;
+        cols: number;
+    };
     tableDeleteColumn: {
         colIdx: number;
         crossBlock?: true;

package/dist/schema/reserved-chords.js

@@ -15,12 +15,30 @@ export const HARDCODED_CHORD_SITES = [
         keys: [],
         note: 'Mod-click link activation — no keystroke is consumed.'
     },
+    {
+        file: 'components/editor-root-keydown.ts',
+        chords: [],
+        keys: ['Escape'],
+        note: 'Escape closes the find bar (a reserved UI chord, enumerated). The modifier read is a REFUSAL: an unchorded character over a live range goes to the range’s text door, a chorded one to the arms below it.'
+    },
     {
         file: 'components/editor-root-listeners.ts',
         chords: [],
         keys: [],
         note: 'The Mod-held `data-mod-active` affordance tracks flag state only — no keystroke is consumed.'
     },
+    {
+        file: 'selection/selection-drop.ts',
+        chords: [],
+        keys: [],
+        note: 'Ctrl/Alt at the DROP is the platform copy modifier, read off a DragEvent — no keystroke is consumed.'
+    },
+    {
+        file: 'selection/multi-click.ts',
+        chords: [],
+        keys: [],
+        note: 'A modified multi-click is left to the browser (Shift extends, Mod activates) — no keystroke is consumed.'
+    },
     {
         file: 'components/GapCaret.svelte',
         chords: [],
@@ -45,8 +63,8 @@ export const HARDCODED_CHORD_SITES = [
     {
         file: 'components/blocks/editable-leaf.ts',
         chords: [],
-        keys: ['Enter'],
-        note: 'Shift-click gate on the rendered surface — a pointer read.'
+        keys: ['Backspace', 'Enter'],
+        note: "Shift-click gate on the rendered surface — a pointer read; plain Backspace (no modifier) at the top of an empty painted source deletes the block, as the code block does. The reveal's own undo resolves its chord through the keymap, so it claims none here."
     },
     {
         file: 'components/link-card/LinkCard.svelte',
@@ -54,6 +72,12 @@ export const HARDCODED_CHORD_SITES = [
         keys: ['Enter', 'K', 'Tab', 'k'],
         note: "Backwards step of the open card's focus trap, plus the entry chord swallowed as a no-op where the focus already is — the kind keymaps claim it everywhere else. Escape lives on the host, which must also close a card the document still holds the caret for."
     },
+    {
+        file: 'components/menu/BlockMenu.svelte',
+        chords: [],
+        keys: ['ArrowDown', 'ArrowLeft', 'ArrowRight', 'ArrowUp', 'Enter', 'Escape'],
+        note: 'The open block menu steps and picks; the modifier read is the guard that leaves every chord to the editor.'
+    },
     {
         file: 'components/blocks/table/TableActionMenu.svelte',
         chords: ['Shift+Tab'],
@@ -115,8 +139,17 @@ export const HARDCODED_CHORD_SITES = [
     {
         file: 'components/blocks/text/widget-interaction.ts',
         chords: ['Shift+ArrowLeft', 'Shift+ArrowRight'],
-        keys: ['Arrow*', 'ArrowLeft', 'ArrowRight', 'Backspace', 'Delete', 'Escape'],
-        note: 'Extends a selection into a widget. A modified arrow is also swallowed while a widget is selected, but that is a caret-coherence guard in a transient state, not a binding.'
+        keys: [
+            'Arrow*',
+            'ArrowDown',
+            'ArrowLeft',
+            'ArrowRight',
+            'ArrowUp',
+            'Backspace',
+            'Delete',
+            'Escape'
+        ],
+        note: 'Extends a selection into a widget. A modified arrow is also swallowed while a widget is selected, but that is a caret-coherence guard in a transient state, not a binding; a plain vertical arrow seats a caret and declines.'
     },
     {
         file: 'components/image/ImageResizeHandles.svelte',

package/dist/schema/table-cell-raw.d.ts

@@ -1,6 +1,6 @@
 /**
  * The tableCell raw-write rule, declared on the kind as `normalizeRawWrite` and applied at the
- * write sink (`tree-operations/node-ops.updateNodeContent`). A cell's bytes are joined verbatim
+ * write sink (`tree-operations/content-write.updateNodeContent`). A cell's bytes are joined verbatim
  * into its row, and the parser truncates a row reparsing wider than the delimiter's column
  * count, so a bare `|` or line break reaching a cell raw deletes the last column's content.
  * Both passes are prefix-composable, which is what makes `escapedCellOffset` an exact caret image.

package/dist/schema/table-cell-raw.js

@@ -1,6 +1,6 @@
 /**
  * The tableCell raw-write rule, declared on the kind as `normalizeRawWrite` and applied at the
- * write sink (`tree-operations/node-ops.updateNodeContent`). A cell's bytes are joined verbatim
+ * write sink (`tree-operations/content-write.updateNodeContent`). A cell's bytes are joined verbatim
  * into its row, and the parser truncates a row reparsing wider than the delimiter's column
  * count, so a bare `|` or line break reaching a cell raw deletes the last column's content.
  * Both passes are prefix-composable, which is what makes `escapedCellOffset` an exact caret image.

package/dist/selection/block-hit-test.js

@@ -26,10 +26,11 @@ export function blockAtPoint(editorRoot, clientX, clientY) {
                 path,
                 // A cell-addressed kind's first contenteditable is one of its CELLS, so declaring
                 // the drag hook withdraws the block-level surface rather than offering that. The
-                // whole-block editing host is chrome, not characters, so it is excluded too.
+                // whole-block editing host is chrome, not characters, so it is excluded too, as is
+                // the selection overlay (`contenteditable="false"`, mounted while a range is live).
                 charSurface: dragHitTest
                     ? null
-                    : wrapper.querySelector(`[contenteditable]:not([${WHOLE_BLOCK_INPUT_ATTR}])`),
+                    : wrapper.querySelector(`[contenteditable]:not([${WHOLE_BLOCK_INPUT_ATTR}]):not(.selection-overlay)`),
                 foreignDragHitTest: dragHitTest && ((cx, cy) => dragHitTest(wrapper, cx, cy)),
                 caretTargetAtPoint: caretTarget && ((cx, cy) => caretTarget(wrapper, cx, cy))
             };

package/dist/selection/char-endpoint-snap.js

@@ -6,7 +6,7 @@
  * order against the other endpoint, never the anchor/focus role, which `normalize` reorders later.
  */
 import { displayLength, snapToScalarBoundary } from '../core/lines';
-import { isBlockNode, nodeAt } from '../tree-operations/node-ops';
+import { isBlockNode, nodeAt } from '../tree-operations/node-primitives';
 import { isWholeBlockUnit } from '../schema/whole-block-unit';
 import { comparePaths } from './path-math';
 import { isWholeBlockEndpoint } from './primitives';

package/dist/selection/clipboard-text.js

@@ -3,7 +3,7 @@
  */
 import { makeBlockNode, metadataOf } from '../core/nodes';
 import { cloneMetadata } from '../tree-operations/clone';
-import { isBlockNode, nodeAt } from '../tree-operations/node-ops';
+import { isBlockNode, nodeAt } from '../tree-operations/node-primitives';
 import { walkBetween, normalize, charOffsetOf, cellIndexOf } from './primitives';
 import { snapCrossBlockTableEndpoints } from './table-endpoint-snap';
 import { isStrictAncestorOf, pathHasPrefix, pathsEqual, sharedPrefixLength } from './path-math';
@@ -39,6 +39,11 @@ export function collectCrossBlockText(doc, anchor, focus) {
     }
     const startRaw = isBlockNode(startNode) ? startNode.raw : '';
     const endRaw = isBlockNode(endNode) ? endNode.raw : '';
+    // One leaf taken whole (`SelectionState.wholeUnitPath`): the only same-path prose pair the
+    // state stores, and the head/tail split below would emit its bytes twice.
+    if (pathsEqual(start.path, end.path) && !start.cellCoordinate) {
+        return startRaw.slice(start.offset, end.offset);
+    }
     let effectiveStartPath = start.path;
     let chromeStart = null;
     let startTail = '';

package/dist/selection/covered-block.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The block a range holds whole, for the gestures that insert over it. Such a range has no seam
+ * inside it to merge at: the block leaves the tree entirely, so bytes that follow must land in
+ * its SLOT rather than at a caret in whatever took the slot.
+ */
+import type { DocumentView } from '../core/node-views';
+import type { SelectionPoint } from './primitives';
+/** The block both endpoints address and jointly span, or null. Cell coordinates index a grid
+ *  rather than characters: the table's own coverage rule is `cross-block/paste.ts`'s. */
+export declare function blockCoveredWhole(doc: DocumentView, anchor: SelectionPoint | null, focus: SelectionPoint | null): number[] | null;

package/dist/selection/covered-block.js

@@ -0,0 +1,24 @@
+/**
+ * The block a range holds whole, for the gestures that insert over it. Such a range has no seam
+ * inside it to merge at: the block leaves the tree entirely, so bytes that follow must land in
+ * its SLOT rather than at a caret in whatever took the slot.
+ */
+import { displayLength } from '../core/lines';
+import { isBlockNode, nodeAt } from '../tree-operations/node-primitives';
+import { pathsEqual } from './path-math';
+/** The block both endpoints address and jointly span, or null. Cell coordinates index a grid
+ *  rather than characters: the table's own coverage rule is `cross-block/paste.ts`'s. */
+export function blockCoveredWhole(doc, anchor, focus) {
+    if (!anchor || !focus)
+        return null;
+    if (!pathsEqual(anchor.path, focus.path))
+        return null;
+    if (anchor.cellCoordinate || focus.cellCoordinate)
+        return null;
+    const node = nodeAt(doc, anchor.path);
+    if (!node || !isBlockNode(node))
+        return null;
+    const low = Math.min(anchor.offset, focus.offset);
+    const high = Math.max(anchor.offset, focus.offset);
+    return low === 0 && high >= displayLength(node.raw) ? anchor.path.slice() : null;
+}

package/dist/selection/cross-block/dispatch.d.ts

@@ -71,6 +71,9 @@ export interface CrossBlockHandlers {
      *  programmatic insertion: no gesture to consume, so `replacement` carries the payload. */
     handlePaste(e: ClipboardEvent | null, replacement?: string): Promise<boolean>;
     handleBeforeInput(e: InputEvent): Promise<boolean>;
+    /** Type-replace from a door that carries no InputEvent: the editor root, where a range over a
+     *  block with no character position leaves no editing surface for `beforeinput` to fire on. */
+    insertText(text: string): Promise<boolean>;
     handleCompositionStart(): boolean;
     /** Cross-block range delete for Cut handlers, after they synchronously wrote the clipboard. */
     performCrossBlockDeleteFromEvent(): Promise<void>;

package/dist/selection/cross-block/dispatch.js

@@ -28,6 +28,14 @@ export function createCrossBlockHandlers(ctx) {
     // (each editable surface, the editor root) inherits them. Keydown gates its own destructive
     // branches, since it also carries navigation, which stays live.
     const reading = () => isReadingMode(ctx.getPresentationMode);
+    const insertText = async (text) => {
+        if (reading())
+            return true;
+        if (!ctx.selection.isCrossBlock)
+            return false;
+        await handleCrossBlockTypeReplace(ctx, mutationCtx, text);
+        return true;
+    };
     return {
         handleKeyDown: keydown.handleKeyDown,
         handleCompositionStart: keydown.handleCompositionStart,
@@ -44,8 +52,12 @@ export function createCrossBlockHandlers(ctx) {
                 e.preventDefault();
                 return true;
             }
-            return handleCrossBlockTypeReplace(ctx, mutationCtx, e);
+            if (!ctx.selection.isCrossBlock || e.inputType !== 'insertText')
+                return false;
+            e.preventDefault();
+            return insertText(e.data ?? '');
         },
+        insertText,
         performCrossBlockDeleteFromEvent: async () => {
             // Reached from cut handlers after the clipboard write; declining the delete
             // degrades a reading-mode cut to a copy.

package/dist/selection/cross-block/format-range.d.ts

@@ -10,7 +10,7 @@ import type { DocumentView } from '../../core/node-views';
 import type { InlineMarkKind } from '../../schema/inline-construct-policy';
 import type { PresentationMode } from '../../presentation-mode';
 import type { GrammarView } from '../../schema/block-openers';
-import { type NodeParent } from '../../tree-operations/node-ops';
+import { type NodeParent } from '../../tree-operations/node-primitives';
 import type { SharingState } from '../../tree-operations/sharing';
 import { type SelectionPoint } from '../primitives';
 export interface CrossBlockFormatWrite {

package/dist/selection/cross-block/format-range.js

@@ -6,12 +6,13 @@
  * through the single-block seam, so its arms, candidates and mode verification are the same ones.
  * A grid joins by its cells, which the range covers whole.
  */
-import { activeInlineFormats, inlineFormatsCovering, isInlineFormatActive, isInlineFormatActiveAfter, toggleInlineFormat } from '../../core/inline/format-toggle';
+import { activeInlineFormats, inlineFormatsCovering, isInlineFormatActive, isInlineFormatActiveAfter, toggleInlineFormat, withoutBoundaryWhitespace } from '../../core/inline/format-toggle';
 import { getContentRange } from '../../core/inline';
 import { ownTrailingLineEnding, trimTrailingLineEnding } from '../../core/lines';
 import { tryGetBlockKindDescriptor } from '../../schema/block-kind-descriptor';
-import { normalizeBodyWrite, writeOwnRaw } from '../../tree-operations/node-ops';
-import { ensureUnsharedPath, rebuildUnsharedChain } from '../../tree-operations/unshare';
+import { normalizeBodyWrite, writeOwnRaw } from '../../tree-operations/node-primitives';
+import { ensureUnsharedPath } from '../../tree-operations/unshare';
+import { rebuildUnsharedChain } from '../../tree-operations/chain-rebuild';
 import { comparePaths } from '../path-math';
 import { charOffsetOf } from '../primitives';
 import { coveredGridCells, gridEndpointCellIndex } from '../table-endpoint-snap';
@@ -170,18 +171,6 @@ function contentSpan(node, path, from, to) {
     const selection = withoutBoundaryWhitespace(display, clampToContent(from ?? content.start, content), clampToContent(to ?? content.end, content));
     return selection && { path, edit: { display, content, selection } };
 }
-/** The span minus its boundary whitespace, null once nothing is left. Markdown opens and closes a
- *  run against a word, never a space, so an untrimmed edge yields delimiters that form no
- *  construct — which the modes that paint them write anyway (`wrapCandidates` is unverified there). */
-function withoutBoundaryWhitespace(display, from, to) {
-    let start = from;
-    let end = to;
-    while (start < end && /\s/.test(display[start]))
-        start++;
-    while (end > start && /\s/.test(display[end - 1]))
-        end--;
-    return start === end ? null : { start, end };
-}
 const clampToContent = (offset, content) => Math.min(Math.max(offset, content.start), content.end);
 /**
  * Whether the span actually changed sides. The single-block seam decides its own arm from the

package/dist/selection/cross-block/format-toggle.js

@@ -7,7 +7,7 @@
 import { ownTrailingLineEnding } from '../../core/lines';
 import { docPathFrom } from '../../cursor/coordinate-spaces';
 import { inlineMarkForCommand } from '../../schema/inline-construct-policy';
-import { blockNodeAt } from '../../tree-operations/node-ops';
+import { blockNodeAt } from '../../tree-operations/node-primitives';
 import { comparePaths } from '../path-math';
 import { restoreSelection } from '../selection-restore';
 import { applyCrossBlockFormat, crossBlockActiveFormats, planCrossBlockFormat } from './format-range';

package/dist/selection/cross-block/keydown.js

@@ -4,16 +4,14 @@
  */
 import { CURSOR_START } from '../../block-component';
 import { performCrossBlockDelete, performCrossBlockDeleteSync } from './ops';
-import { isBlockNode } from '../../tree-operations/node-ops';
+import { isBlockNode } from '../../tree-operations/node-primitives';
 import { isReadingMode } from '../../presentation-mode';
 import { eventToChord } from '../../schema/keybindings';
 import { dispatchKeyCommand } from '../../schema/block-commands';
 import { collapseCrossBlock, extendFocusToNextBlock, extendFocusToPreviousBlock, extendFocusToDocEdge, selectWholeDocument, scrollFocusBlockIntoView } from '../keyboard-extend';
 import { pathsEqual } from '../path-math';
 import { intraTableRectExtension } from '../table-rect-extend';
-import { ambientSpanOf, placeCaretAfterAmbientSpan } from '../../ambient/ambient-dom';
-import { asDomTextOffset } from '../../cursor/coordinate-spaces';
-import { createRangeFromOffsets } from '../../cursor/content-offsets';
+import { applySurfaceContentRange } from '../native-bridge';
 export function createCrossBlockKeydown(ctx, mutCtx) {
     return {
         handleKeyDown: (e) => handleKeyDown(ctx, mutCtx, e),
@@ -168,7 +166,7 @@ async function handleCrossBlockEntry(ctx, e) {
         e.preventDefault();
         selection.incrementSelectAllCount();
         if (selection.selectAllCount === 1) {
-            selectFirstPressContent(el);
+            applySurfaceContentRange(el);
             return true;
         }
         selectWholeDocument(selection, getDoc(), ctx.getBlockElByPath);
@@ -261,30 +259,6 @@ function kindOfPath(path, doc) {
     // The root's 'document' kind is outside AnyBlockKind; dispatch treats it as an unknown kind.
     return isBlockNode(node) ? node.kind : node.kind;
 }
-/**
- * Select the block's content for the first Ctrl+A press. With an ambient marker (a list item's
- * `- `), anchor after it so type-replace doesn't corrupt the contenteditable="false" island.
- */
-function selectFirstPressContent(el) {
-    const ambient = ambientSpanOf(el);
-    const ambientLen = ambient?.textContent?.length ?? 0;
-    const textLen = el.textContent?.length ?? 0;
-    if (ambient && textLen > ambientLen) {
-        if (!placeCaretAfterAmbientSpan(el))
-            return;
-        // textLen counts the full textContent (marker included) — a DomTextOffset by construction.
-        const endRange = createRangeFromOffsets(el, asDomTextOffset(textLen), asDomTextOffset(textLen));
-        if (endRange) {
-            window.getSelection()?.extend(endRange.endContainer, endRange.endOffset);
-        }
-        return;
-    }
-    const range = document.createRange();
-    range.selectNodeContents(el);
-    const sel = window.getSelection();
-    sel?.removeAllRanges();
-    sel?.addRange(range);
-}
 /**
  * Bring the active (focus-side) endpoint into view after an extend. A cell-coordinate focus
  * addresses the table block by cell index, so reveal the deep cell path to mount the off-window

package/dist/selection/cross-block/ops.js

@@ -9,7 +9,7 @@ import { deleteSnapshot } from '../primitives';
 import { focusCollapsedCaret } from '../native-bridge';
 import { rangeDelete } from '../range-delete';
 import { trackChildIds } from '../../tree-operations/structural-change';
-import { isBlockNode, nodeAt } from '../../tree-operations/node-ops';
+import { isBlockNode, nodeAt } from '../../tree-operations/node-primitives';
 import { pathsEqual } from '../path-math';
 import { docPathFrom } from '../../cursor/coordinate-spaces';
 import { getStateForNode } from '../../reactivity/state-registry';

package/dist/selection/cross-block/paste.js

@@ -9,13 +9,13 @@ import { normalizeLineEndings } from '../../core/lines';
 import { performCrossBlockDelete } from './ops';
 import { charOffsetOf } from '../primitives';
 import { focusCollapsedCaret } from '../native-bridge';
+import { blockCoveredWhole } from '../covered-block';
 import { pasteDispatch } from '../../tree-operations/paste/dispatch';
 import { applyPasteTransforms } from '../../tree-operations/paste/paste-transforms';
-import { parse } from '../../core/parser';
-import { blockNodeAt, isBlockNode, nodeAt } from '../../tree-operations/node-ops';
+import { blockNodeAt, isBlockNode, nodeAt } from '../../tree-operations/node-primitives';
 import { pathsEqual } from '../path-math';
 import { replaceBlockAtParent } from '../../tree-operations/paste/replace-block-at-parent';
-import { ensureEditableContainers, normalizeReplacementTrivia } from '../../tree-operations';
+import { parseReplacement } from '../../tree-operations/paste/replacement-parse';
 import { emitClipboardError } from '../../editor-events';
 export async function handleCrossBlockPaste(ctx, mutCtx, e, replacement) {
     if (!ctx.selection.isCrossBlock)
@@ -32,10 +32,12 @@ export async function handleCrossBlockPaste(ctx, mutCtx, e, replacement) {
     if (!pasted)
         return true;
     const doc = ctx.getDoc();
-    // Whole-table selection (Ctrl+A 2nd press inside a cell): replace the table block at the
-    // parent position, single undo. The sub-rectangle path only clears cells, leaving the table.
-    if (isWholeTableSelection(ctx.selection, doc)) {
-        await replaceTableWithPaste(ctx, mutCtx, pasted);
+    // The range holds one block whole, in either addressing: replace the block at its parent
+    // position, single undo. A sub-rectangle inside a table only clears cells, leaving the table.
+    const covered = wholeTablePath(ctx.selection, doc) ??
+        blockCoveredWhole(doc, ctx.selection.anchor, ctx.selection.focus);
+    if (covered) {
+        await replaceCoveredBlockWithPaste(ctx, mutCtx, pasted, covered);
         return true;
     }
     // Read before the delete collapses the selection: the only coordinate an error report on the
@@ -96,60 +98,54 @@ async function landCaretAfterPaste(ctx, caretPath, inlineCaretOffset) {
         ctx.getBlockElByPath(caretPath)?.focus();
     }
 }
-// ── Whole-table paste ──────────────────────────────────────────────────────
-function isWholeTableSelection(selection, doc) {
+// ── Covered-block paste ────────────────────────────────────────────────────
+/** The table a cell rectangle covers whole (Ctrl+A's 2nd press inside a cell), or null. */
+function wholeTablePath(selection, doc) {
     const anchor = selection.anchor;
     const focus = selection.focus;
     if (!anchor || !focus)
-        return false;
+        return null;
     if (!pathsEqual(anchor.path, focus.path))
-        return false;
+        return null;
     const node = nodeAt(doc, anchor.path);
     if (!node || !isBlockNode(node) || node.kind !== 'table')
-        return false;
+        return null;
     const cellCount = tableCellCount(node);
     if (cellCount === 0)
-        return false;
+        return null;
     // Same-path intra-table selection: cell offsets are context-established, so read directly.
     const lo = Math.min(anchor.offset, focus.offset);
     const hi = Math.max(anchor.offset, focus.offset);
-    return lo === 0 && hi === cellCount - 1;
+    return lo === 0 && hi === cellCount - 1 ? anchor.path.slice() : null;
 }
 /**
- * Replace the selected table block with the pasted content at the table's parent position.
- * Routes through replaceBlockAtParent so the splice lands at the doc/enclosing-container scope
- * rather than the row-level blockEdit TableRowBlock propagates. One snapshot covers the replace.
+ * Replace the covered block with the pasted content at its parent position. Routes through
+ * replaceBlockAtParent so the splice lands at the doc/enclosing-container scope rather than the
+ * row-level blockEdit TableRowBlock propagates. One snapshot covers the replace.
  */
-async function replaceTableWithPaste(ctx, mutCtx, pasted) {
-    const tablePath = ctx.selection.anchor.path;
+async function replaceCoveredBlockWithPaste(ctx, mutCtx, pasted, blockPath) {
     const doc = ctx.getDoc();
+    const covered = blockNodeAt(doc, blockPath);
+    if (!covered)
+        return;
     // This route never reaches pasteDispatch, so the paste transforms and the instance grammar
     // ride here too; both rules live in the helper, applied at both sites.
-    const parsed = parse(applyPasteTransforms(pasted, ctx.activePlugins), {
-        grammar: ctx.grammar,
-        scope: 'fragment'
-    });
-    if (parsed.children.length === 0)
-        return;
-    const tableNode = blockNodeAt(doc, tablePath);
-    if (!tableNode)
+    const parsed = parseReplacement(covered, applyPasteTransforms(pasted, ctx.activePlugins), ctx.grammar);
+    if (!parsed)
         return;
-    const replacement = normalizeReplacementTrivia(tableNode, parsed.children);
-    for (const node of replacement)
-        ensureEditableContainers(node);
     mutCtx.pushUndoSnapshot();
     ctx.selection.collapse();
     await replaceBlockAtParent({
         doc,
-        blockPath: tablePath,
-        replacement,
+        blockPath,
+        replacement: parsed.replacement,
         controller: ctx.pasteCoordinator,
         undoEntry: 'join',
-        focusReplacementIndex: replacement.length - 1,
+        focusReplacementIndex: parsed.replacement.length - 1,
         focusOffset: CURSOR_END,
-        source: 'cross-block-paste-whole-table',
+        source: 'cross-block-covered-block',
         ...(ctx.grammar ? { grammar: ctx.grammar } : {}),
-        // Nothing is reattached behind the clipboard here — the table's whole slot is the target —
+        // Nothing is reattached behind the clipboard here — the block's whole slot is the target —
         // so the trailing blank rides in unfiltered (`paste/dispatch.ts` states the rule).
         trailingSeparator: parsed.suffix
     });

package/dist/selection/cross-block/type-replace.d.ts

@@ -3,8 +3,9 @@
  * Delete the range, splice the character into the surviving leaf's raw, re-parse so a marker at
  * offset 0 re-derives the kind (parity with the single-block type path). Routed through
  * commitMultiScope so a kind change mints a fresh node, ids/refs stay synced, and the op is
- * `updateContent`.
+ * `updateContent`. A range holding its block whole has no surviving leaf and takes the
+ * replace arm at the foot of the file instead.
  */
 import type { CrossBlockDispatchContext } from './dispatch';
 import type { CrossBlockMutationContext } from './ops';
-export declare function handleCrossBlockTypeReplace(ctx: CrossBlockDispatchContext, mutCtx: CrossBlockMutationContext, e: InputEvent): Promise<boolean>;
+export declare function handleCrossBlockTypeReplace(ctx: CrossBlockDispatchContext, mutCtx: CrossBlockMutationContext, typed: string): Promise<void>;

package/dist/selection/cross-block/type-replace.js

@@ -3,37 +3,49 @@
  * Delete the range, splice the character into the surviving leaf's raw, re-parse so a marker at
  * offset 0 re-derives the kind (parity with the single-block type path). Routed through
  * commitMultiScope so a kind change mints a fresh node, ids/refs stay synced, and the op is
- * `updateContent`.
+ * `updateContent`. A range holding its block whole has no surviving leaf and takes the
+ * replace arm at the foot of the file instead.
  */
 import { performCrossBlockDelete } from './ops';
 import { charOffsetOf } from '../primitives';
-import { blockNodeAt, normalizeBodyWrite, updateNodeContent, writeOwnRaw, settledCaretTarget } from '../../tree-operations/node-ops';
+import { blockCoveredWhole } from '../covered-block';
+import { CURSOR_END } from '../../block-component';
+import { replaceBlockAtParent } from '../../tree-operations/paste/replace-block-at-parent';
+import { parseReplacement } from '../../tree-operations/paste/replacement-parse';
+import { blockNodeAt, normalizeBodyWrite, writeOwnRaw } from '../../tree-operations/node-primitives';
+import { updateNodeContent, settledCaretTarget } from '../../tree-operations/content-write';
 import { focusCollapsedCaret } from '../native-bridge';
-import { ensureUnsharedChild, ensureUnsharedNode, ensureUnsharedPath, rebuildUnsharedChain } from '../../tree-operations/unshare';
+import { ensureUnsharedChild, ensureUnsharedNode, ensureUnsharedPath } from '../../tree-operations/unshare';
+import { rebuildUnsharedChain } from '../../tree-operations/chain-rebuild';
 import { stampStructuralChange } from '../../tree-operations/structural-change';
 import { getStateForNode } from '../../reactivity/state-registry';
 import { docPathFrom } from '../../cursor/coordinate-spaces';
 import { devWarn } from '../../dev-warn';
-export async function handleCrossBlockTypeReplace(ctx, mutCtx, e) {
-    if (!ctx.selection.isCrossBlock || e.inputType !== 'insertText')
-        return false;
-    e.preventDefault();
-    const typed = e.data ?? '';
+export async function handleCrossBlockTypeReplace(ctx, mutCtx, typed) {
+    // A range holding its block whole leaves no leaf to splice into, so the character replaces the
+    // block in its own slot. An empty insertion has nothing to stand there and takes the delete.
+    const covered = typed
+        ? blockCoveredWhole(ctx.getDoc(), ctx.selection.anchor, ctx.selection.focus)
+        : null;
+    if (covered) {
+        await replaceCoveredBlockWithText(ctx, mutCtx, typed, covered);
+        return;
+    }
     const caret = await performCrossBlockDelete(mutCtx, { skipCaretRestore: true });
     if (!caret)
-        return true;
+        return;
     // All caret placements below target caret.path's top-level block; mount it once here so each
     // (the post-tick landing included) finds a live element.
     await ctx.revealPath(caret.path);
     if (!typed) {
         focusCollapsedCaret(ctx.getBlockElByPath, caret);
-        return true;
+        return;
     }
     const doc = ctx.getDoc();
     const targetNode = blockNodeAt(doc, caret.path);
     if (!targetNode) {
         focusCollapsedCaret(ctx.getBlockElByPath, caret);
-        return true;
+        return;
     }
     // `updateContent`, not `input`: symmetric with the single-block path's KIND-CHANGING branch
     // (block-edit.ts updateBlockContent). Only that path's kind-stable branch emits the debounced
@@ -42,7 +54,7 @@ export async function handleCrossBlockTypeReplace(ctx, mutCtx, e) {
     const scope = resolveTypedCharScope(ctx, caret.path);
     if (!scope) {
         focusCollapsedCaret(ctx.getBlockElByPath, caret);
-        return true;
+        return;
     }
     // resolveTypedCharScope returns the leaf's IMMEDIATE parent: every mounted container registers
     // a BlockListState, and the document root stands in for a top-level leaf. The guard below is
@@ -97,7 +109,34 @@ export async function handleCrossBlockTypeReplace(ctx, mutCtx, e) {
             focusCollapsedCaret(ctx.getBlockElByPath, { path, offset: target.offset });
         }
     });
-    return true;
+}
+/**
+ * Replace the covered block with the parse of the typed character, at the block's parent
+ * position: the same door the covered-block paste takes, so both gestures splice at one scope
+ * and land one undo entry. Re-parsed rather than spliced, so a marker typed over the block
+ * derives its kind exactly as the single-block type path does.
+ */
+async function replaceCoveredBlockWithText(ctx, mutCtx, typed, blockPath) {
+    const doc = ctx.getDoc();
+    const covered = blockNodeAt(doc, blockPath);
+    if (!covered)
+        return;
+    const parsed = parseReplacement(covered, typed, ctx.grammar);
+    if (!parsed)
+        return;
+    mutCtx.pushUndoSnapshot();
+    ctx.selection.collapse();
+    await replaceBlockAtParent({
+        doc,
+        blockPath,
+        replacement: parsed.replacement,
+        controller: ctx.pasteCoordinator,
+        undoEntry: 'join',
+        focusReplacementIndex: parsed.replacement.length - 1,
+        focusOffset: CURSOR_END,
+        source: 'cross-block-covered-block',
+        ...(ctx.grammar ? { grammar: ctx.grammar } : {})
+    });
 }
 /** The scope's children, re-read after the commit: the ceremony replaces the node it published. */
 function scopeChildrenOf(ctx, scopePath) {

package/dist/selection/dead-space-caret.d.ts

@@ -7,6 +7,7 @@
  */
 import { type BlockComponent } from '../block-component';
 import { type GapStopScope } from './gap-caret';
+import type { SelectionEndpoint } from './primitives';
 export interface DeadSpaceCaretDeps {
     getBlockComponent(path: number[]): BlockComponent | null;
     /**
@@ -35,5 +36,17 @@ export interface DeadSpaceCaret {
      * was claimed; a point past a windowed-out tail claims it and lands after the reveal.
      */
     placeAtPoint(root: HTMLElement, x: number, y: number): boolean;
+    /** Whether a press target is the editor's dead space (the root, or a block list inside it). */
+    isDeadSpaceTarget(root: HTMLElement, target: EventTarget | null): boolean;
+    /**
+     * The endpoint a drag STARTING in dead space (or on a block's rendered face) anchors at: the
+     * landing a click there would take, without taking it. A character surface anchors at that
+     * offset; a rendered leaf (an equation) anchors as a WHOLE block, so the range takes it entire
+     * whichever way the drag goes. A coordinate-addressed kind (a table) anchors nothing.
+     */
+    anchorAtPoint(root: HTMLElement, x: number, y: number): SelectionEndpoint | null;
+    /** The path of the block a press names, the point clamped into the nearest band: what the
+     *  click ladder selects in for a press on the margin or a block's own box. */
+    blockPathNearPoint(root: HTMLElement, x: number, y: number): number[] | null;
 }
 export declare function createDeadSpaceCaret(deps: DeadSpaceCaretDeps): DeadSpaceCaret;