@voithos-labs/aragonite 0.10.4 → 0.10.7

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

@@ -1,32 +1,37 @@
 /**
- * Cross-block mutation: delete a range, push undo, collapse, restore the caret. Commit
- * routing: pure top-level (both endpoints at doc.children, no cross-path table) commits
- * structurally; anything nested or with a cross-path table endpoint needs one scope per
- * spliced container, since the whole-row snap splices `table.children`. Intra-table
- * full-table/row/column coverage routes to `range-delete-table-coverage`.
+ * Cross-block delete: one commit that deletes the range, collapses it and restores the caret.
+ * A range between top-level blocks commits structurally; anything nested, or with an endpoint in
+ * a table the other endpoint isn't in, needs one scope per spliced container.
  */
 import { deleteSnapshot } from '../primitives';
 import { focusCollapsedCaret } from '../native-bridge';
-import { rangeDelete } from '../range-delete';
+import { rangeDelete, removeHeldWhole } from '../range-delete';
+import { coverRange, rangeCoverage } from '../range-coverage';
 import { trackChildIds } from '../../tree-operations/structural-change';
-import { isBlockNode, nodeAt } from '../../tree-operations/node-primitives';
+import { documentBody, isBlockNode, nodeAt } from '../../tree-operations/node-primitives';
 import { pathsEqual } from '../path-math';
+import { countsCells } from '../../schema/block-kind-descriptor';
 import { docPathFrom } from '../../cursor/coordinate-spaces';
 import { getStateForNode } from '../../reactivity/state-registry';
-import { maybeCommitTableCoverageDelete } from '../range-delete-table-coverage';
+import { commitGridLineDelete } from '../range-delete-table-coverage';
 /**
- * rangeDelete the current cross-block selection, commit, collapse, restore the caret.
- * Returns the collapsed caret, or null when the selection wasn't cross-block.
+ * Runs a cross-block gesture's writes as one undo entry holding the range as it stood; the range
+ * start is where undo puts the caret back when nothing is focused.
  */
-export async function performCrossBlockDelete(ctx, options) {
-    // A re-entrant delete (auto-repeat, paste, composition) parked on the reveal await would
-    // resolve the SAME endpoints and delete against the mutated tree. Serialize per selection;
-    // with nothing in flight this adds no await, preserving the sync variant's no-yield window.
+export function rangeUndoStep(ctx, run) {
+    const start = ctx.selection.start;
+    return ctx.controller.undoStep(deleteSnapshot(start?.path ?? [0], start?.offset ?? 0), run);
+}
+/** Returns the collapsed caret, or null when the selection wasn't cross-block. `gesture` picks the
+ *  caret's side when the range takes a block whole. */
+export async function performCrossBlockDelete(ctx, gesture, options) {
+    // A re-entrant delete (key repeat, paste, composition) would resolve the same endpoints against
+    // the mutated tree, so deletes queue per selection; with none queued this adds no await.
     let inFlight;
     while ((inFlight = inFlightDeletes.get(ctx.selection))) {
         await inFlight.catch(() => { });
     }
-    const run = runCrossBlockDelete(ctx, options);
+    const run = runCrossBlockDelete(ctx, gesture, options);
     inFlightDeletes.set(ctx.selection, run);
     try {
         return await run;
@@ -37,15 +42,15 @@ export async function performCrossBlockDelete(ctx, options) {
     }
 }
 const inFlightDeletes = new WeakMap();
-async function runCrossBlockDelete(ctx, options) {
+async function runCrossBlockDelete(ctx, gesture, options) {
     if (!ctx.selection.isCrossBlock)
         return null;
     const { start, end } = ctx.selection;
     if (!start || !end)
         return null;
     const doc = ctx.getDoc();
-    // A cross-path table endpoint leaves the pure path: the whole-row snap splices
-    // table.children, which only the multi-scope commit syncs. Intra-table clears only raws.
+    // A table endpoint splices `table.children` (the whole-row snap), which only the multi-scope
+    // commit syncs; a range inside one table clears only raws and stays top-level.
     const samePath = pathsEqual(start.path, end.path);
     const isPureTopLevel = start.path.length === 1 &&
         end.path.length === 1 &&
@@ -56,104 +61,83 @@ async function runCrossBlockDelete(ctx, options) {
                 focusCollapsedCaret(ctx.getBlockElByPath, caret);
         }
         : undefined;
-    // Start-wins collapse: the merged block lands at start.path[0] and stays put. Mount it now,
-    // while caretRestore (a sync post-tick landing) still needs a live element. Gated on
-    // caretRestore so the IME path never yields before its synchronous commit.
+    // The start wins the collapse, so mount it now while `caretRestore` still needs a live element;
+    // skipped without `caretRestore` so the IME path never yields before its synchronous commit.
     if (caretRestore) {
         await ctx.revealPath(start.path);
     }
-    if (options?.tableCoverageDelete && isPureTopLevel && samePath) {
-        const block = nodeAt(doc, start.path);
-        if (block && isBlockNode(block) && block.kind === 'table') {
-            const handled = await maybeCommitTableCoverageDelete(ctx, block, start, end, options, caretRestore);
-            if (handled)
-                return handled.caret;
-        }
+    const range = coverRange(doc, start, end);
+    const coverage = rangeCoverage(doc, range);
+    const grid = options?.tableCoverageDelete ? coverage.grid : null;
+    if (grid && (grid.kind === 'row' || grid.kind === 'column')) {
+        return commitGridLineDelete(ctx, grid, !!caretRestore);
     }
-    if (isPureTopLevel) {
-        return await commitPureTopLevelDelete(ctx, start, end, options, caretRestore);
+    // A table held whole goes, where `rangeDelete` would clear its cells; the commit lands the
+    // caret on the side the key points.
+    if (grid?.kind === 'table') {
+        const caret = caretByLanding(ctx, !!caretRestore);
+        const remove = (sharing) => removeHeldWhole(doc, coverage, sharing, ctx.reading, gesture);
+        return commitCrossContainerDelete(ctx, doc, range, remove, caret);
     }
-    return await commitCrossContainerDelete(ctx, doc, start, end, options, caretRestore);
+    const caret = caretAfterCommit(ctx, caretRestore);
+    if (isPureTopLevel)
+        return await commitPureTopLevelDelete(ctx, coverage, gesture, caret);
+    const remove = (sharing) => rangeDelete(doc, coverage, sharing, ctx.reading, gesture);
+    return await commitCrossContainerDelete(ctx, doc, range, remove, caret);
 }
-/**
- * compositionstart variant: the IME swallows the composition if the handler yields, so this
- * must not await. The commit ceremony is synchronous up to its post-publish `await tick()`,
- * so firing without awaiting keeps the whole delete inside the no-await window.
- */
+/** For compositionstart, where the IME drops the composition if the handler yields: the commit
+ *  is synchronous up to its `await tick()`, so firing without awaiting deletes before any yield. */
 export function performCrossBlockDeleteSync(ctx) {
-    void performCrossBlockDelete(ctx, { skipCaretRestore: true });
+    void performCrossBlockDelete(ctx, 'keyless', { skipCaretRestore: true });
 }
-// ── Internal ───────────────────────────────────────────────────────────────
 function isTableAt(doc, path) {
     const node = nodeAt(doc, path);
-    return node !== null && isBlockNode(node) && node.kind === 'table';
+    return node !== null && countsCells(node);
 }
-/**
- * Pure top-level commit path. Both paths have length 1, so rangeDelete never reaches into a
- * nested container and the proxy-doc (children copy) is a safe mutation target.
- */
-async function commitPureTopLevelDelete(ctx, start, end, options, caretRestore) {
-    let collapsedCaret = null;
-    const snapshot = deleteSnapshot(options, start.path, start.offset);
+/** Both paths have length 1, so `rangeDelete` never reaches into a nested container and the
+ *  top-level children copy is a safe mutation target. */
+async function commitPureTopLevelDelete(ctx, coverage, gesture, caret) {
+    const { start } = coverage.range;
+    const snapshot = deleteSnapshot(start.path, start.offset);
     const doc = ctx.getDoc();
     await ctx.controller.commitStructural({
         snapshot,
         mutate: (topLevelChildren) => {
-            // Prefix stays inert; the suffix rides the live document as accessors, so the
-            // tail settle can materialize the folded trailing line.
-            const proxyDoc = {
-                kind: 'document',
-                prefix: '',
-                children: topLevelChildren,
-                get suffix() {
-                    return doc.suffix;
-                },
-                set suffix(value) {
-                    doc.suffix = value;
-                }
-            };
-            const ledger = trackChildIds(proxyDoc);
-            const result = rangeDelete(proxyDoc, start, end, ctx.controller.sharing, ctx.grammar, ctx.getPresentationMode?.(), ctx.linkRef);
-            collapsedCaret = result.collapsedCaret;
+            const body = documentBody(doc, topLevelChildren);
+            const ledger = trackChildIds(body);
+            caret.hold(rangeDelete(body, coverage, ctx.controller.sharing, ctx.reading, gesture));
             ctx.selection.collapse();
             return ledger.read();
         },
         op: { kind: 'delete', detail: { crossBlock: true }, eventPath: docPathFrom([start.path[0]]) },
-        afterTick: caretRestore ? () => caretRestore(collapsedCaret) : undefined
+        ...caret.commitArgs
     });
-    return collapsedCaret;
+    return caret.read();
 }
-/**
- * Cross-container commit path: one rangeDelete on the live doc inside a commitMultiScope
- * whose scope list covers every container whose children array was spliced.
- */
-async function commitCrossContainerDelete(ctx, doc, start, end, options, caretRestore) {
-    const touched = collectTouchedContainers(doc, start.path, end.path);
-    const scopes = [];
-    // Doc scope goes first when the LCA is doc-level, so commitMultiScope publishes
-    // doc.children / blockIds / blockRefs atomically with the container scopes.
-    if (start.path[0] !== end.path[0]) {
-        scopes.push(ctx.controller.getDocScope());
-    }
-    for (const t of touched) {
-        scopes.push({ node: t.node, state: t.state, path: t.path });
-    }
-    let collapsedCaret = null;
+/** One `remove` on the live doc, with a commit scope for every container it splices. */
+async function commitCrossContainerDelete(ctx, doc, range, remove, caret) {
+    const { start, end } = range;
+    // The document goes first and always: it holds every endpoint, and a block the range takes
+    // whole at the top level is spliced out of it, so its ids and refs change with the containers'.
+    const scopes = [
+        ctx.controller.getDocScope(),
+        ...collectTouchedContainers(doc, start.path, end.path)
+    ];
     await ctx.controller.commitMultiScope({
         scopes,
-        // The selection start survives the delete (start-wins collapse), so its deep path is a
-        // resolving restore coordinate.
-        snapshot: deleteSnapshot(options, start.path, start.offset),
+        // The selection start survives the delete (the start wins the collapse), so its path still
+        // resolves as the restore position.
+        snapshot: deleteSnapshot(start.path, start.offset),
         mutate: (scopeViews) => {
             const sharing = scopeViews[0].sharing;
-            // Opened BEFORE the mutation: paths go stale as rangeDelete splices, while the owned
+            // Opened before the mutation: paths go stale as `rangeDelete` splices, while the copied
             // scope nodes stay valid because splices happen in place.
             const ledgers = scopeViews.map((v) => trackChildIds(v.node));
-            const result = rangeDelete(doc, start, end, sharing, ctx.grammar, ctx.getPresentationMode?.(), ctx.linkRef);
-            collapsedCaret = result.collapsedCaret;
+            const result = remove(sharing);
+            caret.hold(result);
             ctx.selection.collapse();
-            // An endpoint-table scope takes its descriptor from the row splice the table branch
-            // actually performed, matched on the owned node, never from re-derived snap math.
+            // An endpoint table's scope reports the row splice the table branch actually made,
+            // matched on the copied node, never a re-derived snap.
             const rowSplices = result.tableRowSplices ?? [];
             return ledgers.map((ledger, i) => {
                 const rowSplice = rowSplices.find((s) => s.table === scopeViews[i].node);
@@ -165,15 +149,46 @@ async function commitCrossContainerDelete(ctx, doc, start, end, options, caretRe
             });
         },
         op: { kind: 'delete', detail: { crossBlock: true }, eventPath: docPathFrom([start.path[0]]) },
-        afterTick: caretRestore ? () => caretRestore(collapsedCaret) : undefined
+        ...caret.commitArgs
     });
-    return collapsedCaret;
+    return caret.read();
 }
-/**
- * Every mounted container on either endpoint path whose children array gets spliced: strict
- * ancestors, plus a table endpoint itself (the whole-row snap splices its children). Document
- * root excluded; callers add it via `getDocScope()`. Outermost-first, de-duplicated.
- */
+/** Put down after the commit's tick when `caretRestore` is given; paste and typing continue at
+ *  the same read. */
+function caretAfterCommit(ctx, caretRestore) {
+    let result = null;
+    let caret = null;
+    return {
+        hold: (deleted) => {
+            result = deleted;
+        },
+        read: () => caret,
+        commitArgs: {
+            afterTick: () => {
+                caret = result?.caret(ctx.getDoc()) ?? null;
+                caretRestore?.(caret);
+            }
+        }
+    };
+}
+/** The commit puts the caret down itself, and only when `lands` is set. */
+function caretByLanding(ctx, lands) {
+    let result = null;
+    const read = () => result?.caret(ctx.getDoc()) ?? null;
+    const landing = () => {
+        const caret = read();
+        return caret && { path: docPathFrom(caret.path), offset: caret.offset };
+    };
+    return {
+        hold: (deleted) => {
+            result = deleted;
+        },
+        read,
+        commitArgs: { landing: lands ? landing : undefined }
+    };
+}
+/** Every mounted container on either endpoint path whose children get spliced: strict ancestors,
+ *  plus a table endpoint itself. The caller adds the document root with `getDocScope()`. */
 function collectTouchedContainers(doc, startPath, endPath) {
     const touched = [];
     const seen = new Set();

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

@@ -1,7 +1,6 @@
 /**
- * Cross-block paste: delete the active range inside a single undo snapshot, dispatch the paste
- * onto the collapsed caret, then restore the caret via DOM, since the originating block may be
- * gone and pendingCursor with it.
+ * Cross-block paste: delete the range and paste at the collapsed caret as one undo entry, then
+ * restore the caret through the DOM, since the block the paste started in may be gone.
  */
 import type { CrossBlockDispatchContext } from './dispatch';
 import type { CrossBlockMutationContext } from './ops';

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

@@ -1,27 +1,24 @@
 /**
- * Cross-block paste: delete the active range inside a single undo snapshot, dispatch the paste
- * onto the collapsed caret, then restore the caret via DOM, since the originating block may be
- * gone and pendingCursor with it.
+ * Cross-block paste: delete the range and paste at the collapsed caret as one undo entry, then
+ * restore the caret through the DOM, since the block the paste started in may be gone.
  */
-import { tableCellCount } from '../table-endpoint-snap';
 import { CURSOR_END } from '../../block-component';
-import { normalizeLineEndings } from '../../core/lines';
-import { performCrossBlockDelete } from './ops';
+import { documentLineEnding, normalizeLineEndings } from '../../core/lines';
+import { performCrossBlockDelete, rangeUndoStep } from './ops';
 import { charOffsetOf } from '../primitives';
 import { focusCollapsedCaret } from '../native-bridge';
 import { blockCoveredWhole } from '../covered-block';
+import { coverRange, rangeCoverage } from '../range-coverage';
 import { pasteDispatch } from '../../tree-operations/paste/dispatch';
 import { applyPasteTransforms } from '../../tree-operations/paste/paste-transforms';
-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 { blockNodeAt } from '../../tree-operations/node-primitives';
 import { parseReplacement } from '../../tree-operations/paste/replacement-parse';
+import { slotReaderAt } from '../../tree-operations/list/task-paragraph';
 import { emitClipboardError } from '../../editor-events';
 export async function handleCrossBlockPaste(ctx, mutCtx, e, replacement) {
     if (!ctx.selection.isCrossBlock)
         return false;
-    ctx.stickyColumn.reset();
-    ctx.edgeAffinity.reset();
+    ctx.caretMemory.forget();
     ctx.selection.resetSelectAllCount();
     e?.preventDefault();
     // `!== undefined`, not `??`: a caller supplying its own payload must never reach the
@@ -32,10 +29,10 @@ export async function handleCrossBlockPaste(ctx, mutCtx, e, replacement) {
     if (!pasted)
         return true;
     const doc = ctx.getDoc();
-    // The range holds one block whole, in either addressing: replace the block at its parent
+    // The range holds one block whole, a table included: 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);
+    const { anchor, focus } = ctx.selection;
+    const covered = anchor && focus ? blockCoveredWhole(rangeCoverage(doc, coverRange(doc, anchor, focus))) : null;
     if (covered) {
         await replaceCoveredBlockWithPaste(ctx, mutCtx, pasted, covered);
         return true;
@@ -43,50 +40,42 @@ export async function handleCrossBlockPaste(ctx, mutCtx, e, replacement) {
     // Read before the delete collapses the selection: the only coordinate an error report on the
     // declined branch below could still name.
     const rangeStartPath = ctx.selection.start?.path.slice();
-    // One snapshot covers the whole delete-then-paste so Ctrl+Z doesn't leave an intermediate
-    // "selection-deleted but blocks-not-inserted" state.
-    mutCtx.pushUndoSnapshot();
-    const caret = await performCrossBlockDelete(mutCtx, {
-        undoEntry: 'join',
-        skipCaretRestore: true
-    });
-    // The gesture was consumed (preventDefault above) and there is nowhere to put the payload:
-    // another cross-block mutation collapsed the selection while this paste waited it out. Text
-    // survives on the clipboard, but a host-imported image does not, so report it.
-    if (!caret) {
-        emitClipboardError(ctx.events, {
-            error: new Error('cross-block paste resolved no caret; nothing inserted'),
-            ...(rangeStartPath ? { path: rangeStartPath } : {})
+    // One entry for the delete and the paste, so Ctrl+Z never stops between them.
+    await rangeUndoStep(mutCtx, async () => {
+        const caret = await performCrossBlockDelete(mutCtx, 'keyless', { skipCaretRestore: true });
+        // The paste was consumed but has nowhere to go, since another cross-block edit collapsed the
+        // selection first; an imported image, unlike text, isn't on the clipboard, so report it.
+        if (!caret) {
+            emitClipboardError(ctx.events, {
+                error: new Error('cross-block paste resolved no caret; nothing inserted'),
+                ...(rangeStartPath ? { path: rangeStartPath } : {})
+            });
+            return;
+        }
+        // No `preDelete`: the delete above already removed the range and ran the join cleanup, so
+        // handing the dispatch a range would delete a second time.
+        const result = await pasteDispatch({
+            pastedText: pasted,
+            targetPath: caret.path,
+            offset: charOffsetOf(caret, 'cross-block-paste:dispatch')
+        }, {
+            doc,
+            blockEdit: ctx.blockEdit,
+            controller: ctx.pasteCoordinator,
+            crossBlock: true,
+            reading: ctx.reading,
+            activePlugins: ctx.activePlugins
         });
-        return true;
-    }
-    // No `preDelete`: the range is already gone. `performCrossBlockDelete` above took it through
-    // `rangeDelete`, which crosses the join seam itself, so this dispatch inserts at a caret the
-    // cleanup already seated — handing it a range would delete a second time.
-    const result = await pasteDispatch({
-        pastedText: pasted,
-        targetPath: caret.path,
-        offset: charOffsetOf(caret, 'cross-block-paste:dispatch')
-    }, {
-        doc,
-        blockEdit: ctx.blockEdit,
-        controller: ctx.pasteCoordinator,
-        undoEntry: 'join',
-        grammar: ctx.grammar,
-        activePlugins: ctx.activePlugins
+        // A fix-up that merged the target into the block above moved the caret to a position this
+        // gesture never mounted, so mount it before the placement looks for its element.
+        if (result.inlineCaretPath)
+            await ctx.revealPath(result.inlineCaretPath);
+        await landCaretAfterPaste(ctx, result.inlineCaretPath ?? caret.path, result.inlineCaretOffset);
     });
-    // A settle that absorbed the join above the target moved the caret to a slot this gesture
-    // never revealed, so mount it before the landing reads for its element.
-    if (result.inlineCaretPath)
-        await ctx.revealPath(result.inlineCaretPath);
-    await landCaretAfterPaste(ctx, result.inlineCaretPath ?? caret.path, result.inlineCaretOffset);
     return true;
 }
-/**
- * Land the caret after a cross-block paste commit. Inline pastes place it via DOM, since
- * pendingCursor may address a block the range delete unmounted; structural pastes rely on
- * pasteDispatch's internal focus and only step in when focus escaped the editor.
- */
+/** An inline paste places the caret through the DOM, since the pending caret may name a block the
+ *  delete unmounted; a structural paste focuses itself, so this only catches focus leaving. */
 async function landCaretAfterPaste(ctx, caretPath, inlineCaretOffset) {
     await ctx.afterReactivity();
     if (inlineCaretOffset !== undefined) {
@@ -99,54 +88,28 @@ async function landCaretAfterPaste(ctx, caretPath, inlineCaretOffset) {
     }
 }
 // ── 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 null;
-    if (!pathsEqual(anchor.path, focus.path))
-        return null;
-    const node = nodeAt(doc, anchor.path);
-    if (!node || !isBlockNode(node) || node.kind !== 'table')
-        return null;
-    const cellCount = tableCellCount(node);
-    if (cellCount === 0)
-        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 ? anchor.path.slice() : null;
-}
-/**
- * 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.
- */
+/** Through the paste coordinator, so the splice lands at the enclosing container's scope rather
+ *  than the row-level `blockEdit` a table row passes down. */
 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 = parseReplacement(covered, applyPasteTransforms(pasted, ctx.activePlugins), ctx.grammar);
+    // This route skips `pasteDispatch`, so it applies the paste transforms and the instance
+    // grammar itself.
+    const parsed = parseReplacement(covered, applyPasteTransforms(pasted, ctx.activePlugins), documentLineEnding(doc), slotReaderAt(doc, blockPath, ctx.reading.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 } : {}),
-        // 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
+    // Opened before the collapse, so the entry holds the range rather than the caret it leaves.
+    await rangeUndoStep(mutCtx, async () => {
+        ctx.selection.collapse();
+        await ctx.pasteCoordinator.replaceBlock(blockPath, parsed.replacement, { replacementIndex: parsed.replacement.length - 1, offset: CURSOR_END }, 
+        // The trailing blank line comes in unfiltered, since nothing is reattached after the
+        // pasted text; the range's undo step records the selection, so the offset is never read.
+        {
+            source: 'cross-block-covered-block',
+            trailingBlank: parsed.suffix !== '',
+            snapshotOffset: 0
+        });
     });
 }

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

@@ -1,19 +1,21 @@
-/**
- * Pointer half of the cross-block dispatcher: shift-click extension and pointer-drag entry. See
- * dispatch.ts for the composer that wires this together with the keydown half.
- */
-import type { CrossBlockDispatchContext } from './dispatch';
+/** The pointer half of cross-block dispatch: shift-click extension and starting a drag-select. */
+import type { CrossBlockDispatchContext, PointerPressOptions } from './dispatch';
 import type { SelectionState } from '../selection-state.svelte';
-import type { StickyColumnState } from '../../cursor/sticky-column';
-import type { EdgeAffinityState } from '../../cursor/edge-affinity';
+import type { CaretMemory } from '../../cursor/caret-memory';
 export interface CrossBlockPointer {
-    handlePointerDown(e: PointerEvent): boolean;
+    handlePointerDown(e: PointerEvent, press?: PointerPressOptions): boolean;
 }
 export declare function createCrossBlockPointer(ctx: CrossBlockDispatchContext): CrossBlockPointer;
-/**
- * Shared pointerdown preamble for any block that intercepts cross-block input. Resets
- * sticky-column and the select-all counter, and on a non-shift press clears any active
- * cross-block selection so a fresh drag doesn't extend the prior range. The native sibling of
- * `caret-doors.ts`, so it ends the gap caret too.
- */
-export declare function resetForPointerDown(selection: SelectionState, stickyColumn: StickyColumnState, edgeAffinity: EdgeAffinityState, isShift: boolean): void;
+/** The pointerdown reset every cross-block-aware block shares, the pointer counterpart of
+ *  `caret-doors.ts`: a plain click ends any range, so a fresh drag starts its own. */
+export declare function resetForPointerDown(selection: SelectionState, caretMemory: Pick<CaretMemory, 'forget'>, isShift: boolean): void;
+/** A primary press in a surface's top or bottom padding, which the editor places itself. */
+export interface PaddingPress {
+    /** Where the press lands: the column under it, on the nearest line. */
+    offset: number;
+    /** Whether the press was a single click the editor placed, so no native drag runs under it. */
+    placed(): boolean;
+}
+/** A right-click places a collapsed caret where a primary click would, before a menu reads it.
+ *  Bound in the capture phase at the editor root, so it runs ahead of every block's own menu. */
+export declare function placeContextPress(selection: SelectionState, e: MouseEvent): void;