@voithos-labs/aragonite 0.10.1

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

@@ -0,0 +1,156 @@
+/**
+ * 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.
+ */
+import { tableCellCount } from '../table-endpoint-snap';
+import { CURSOR_END } from '../../block-component';
+import { normalizeLineEndings } from '../../core/lines';
+import { performCrossBlockDelete } from './ops';
+import { charOffsetOf } from '../primitives';
+import { focusCollapsedCaret } from '../native-bridge';
+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 { pathsEqual } from '../path-math';
+import { replaceBlockAtParent } from '../../tree-operations/paste/replace-block-at-parent';
+import { ensureEditableContainers, normalizeReplacementTrivia } from '../../tree-operations';
+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.selection.resetSelectAllCount();
+    e?.preventDefault();
+    // `!== undefined`, not `??`: a caller supplying its own payload must never reach the
+    // clipboard read, and `??` would make that depend on callers never passing ''.
+    const pasted = replacement !== undefined
+        ? replacement
+        : normalizeLineEndings(e?.clipboardData?.getData('text/plain') ?? '');
+    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);
+        return true;
+    }
+    // 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 } : {})
+        });
+        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 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.
+ */
+async function landCaretAfterPaste(ctx, caretPath, inlineCaretOffset) {
+    await ctx.afterReactivity();
+    if (inlineCaretOffset !== undefined) {
+        focusCollapsedCaret(ctx.getBlockElByPath, { path: caretPath, offset: inlineCaretOffset });
+        return;
+    }
+    const editorRoot = ctx.getEditorRoot();
+    if (editorRoot && !editorRoot.contains(document.activeElement)) {
+        ctx.getBlockElByPath(caretPath)?.focus();
+    }
+}
+// ── Whole-table paste ──────────────────────────────────────────────────────
+function isWholeTableSelection(selection, doc) {
+    const anchor = selection.anchor;
+    const focus = selection.focus;
+    if (!anchor || !focus)
+        return false;
+    if (!pathsEqual(anchor.path, focus.path))
+        return false;
+    const node = nodeAt(doc, anchor.path);
+    if (!node || !isBlockNode(node) || node.kind !== 'table')
+        return false;
+    const cellCount = tableCellCount(node);
+    if (cellCount === 0)
+        return false;
+    // 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;
+}
+/**
+ * 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.
+ */
+async function replaceTableWithPaste(ctx, mutCtx, pasted) {
+    const tablePath = ctx.selection.anchor.path;
+    const doc = ctx.getDoc();
+    // 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)
+        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,
+        controller: ctx.pasteCoordinator,
+        undoEntry: 'join',
+        focusReplacementIndex: replacement.length - 1,
+        focusOffset: CURSOR_END,
+        source: 'cross-block-paste-whole-table',
+        ...(ctx.grammar ? { grammar: ctx.grammar } : {}),
+        // Nothing is reattached behind the clipboard here — the table'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/pointer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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';
+import type { SelectionState } from '../selection-state.svelte';
+import type { StickyColumnState } from '../../cursor/sticky-column';
+import type { EdgeAffinityState } from '../../cursor/edge-affinity';
+export interface CrossBlockPointer {
+    handlePointerDown(e: PointerEvent): 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;

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

@@ -0,0 +1,80 @@
+/**
+ * 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 { handleShiftClick } from '../keyboard-extend';
+import { findBlockPathForElement } from '../path-lookup';
+import { clearNativeSelection } from '../native-bridge';
+import { offsetFromViewportPoint } from '../../cursor/point-offset';
+import { installDragListener } from '../drag-pointer';
+import { devWarn } from '../../dev-warn';
+export function createCrossBlockPointer(ctx) {
+    return {
+        handlePointerDown: (e) => handlePointerDown(ctx, e)
+    };
+}
+/**
+ * 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 function resetForPointerDown(selection, stickyColumn, edgeAffinity, isShift) {
+    stickyColumn.reset();
+    edgeAffinity.reset();
+    selection.resetSelectAllCount();
+    // Unconditional, unlike the range arm: the gap is collapsed-only, so a shift-press has no
+    // range to grow from it. Silent when no gap is live.
+    selection.clearGapCaret();
+    if (!isShift && selection.isCrossBlock) {
+        selection.clear();
+        clearNativeSelection();
+    }
+}
+// ── Pointer ────────────────────────────────────────────────────────────────
+function handlePointerDown(ctx, e) {
+    const el = ctx.getEl();
+    if (!el)
+        return false;
+    const { selection } = ctx;
+    const myPath = ctx.getMyPath();
+    resetForPointerDown(selection, ctx.stickyColumn, ctx.edgeAffinity, e.shiftKey);
+    if (e.shiftKey) {
+        const prevActive = document.activeElement;
+        const prevFocusEl = prevActive instanceof HTMLElement && prevActive !== el
+            ? prevActive.closest('[contenteditable]')
+            : null;
+        const prevFocusPath = findBlockPathForElement(prevActive);
+        const handled = handleShiftClick(selection, el, myPath, e.clientX, e.clientY, prevFocusEl, prevFocusPath);
+        if (handled) {
+            e.preventDefault();
+            return true;
+        }
+    }
+    if (!e.shiftKey) {
+        const root = ctx.getEditorRoot();
+        if (!root)
+            return false;
+        const offset = offsetFromViewportPoint(el, e.clientX, e.clientY);
+        if (offset === null)
+            return false;
+        // SelectionState normalizes table endpoints on cross-block entry, so the raw block path
+        // is a valid anchor here.
+        const anchorPoint = { path: myPath.slice(), offset };
+        const lifetimeSignal = ctx.getEditorLifetime();
+        if (!lifetimeSignal) {
+            devWarn('cross-block-dispatch', 'editor lifetime signal unavailable; skipping drag install to avoid document-listener leak on unmount');
+            return false;
+        }
+        installDragListener({
+            editorRoot: root,
+            // The root is the hit-test boundary; what SCROLLS may be an ancestor in
+            // host-scroll mode, so the two resolve separately.
+            scrollContainer: ctx.getScrollHost() ?? root,
+            selection,
+            getBlockElByPath: ctx.getBlockElByPath,
+            lifetimeSignal
+        }, anchorPoint, e);
+    }
+    return false;
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Cross-block type-replace: the user typed a character with a cross-block selection active.
+ * 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`.
+ */
+import type { CrossBlockDispatchContext } from './dispatch';
+import type { CrossBlockMutationContext } from './ops';
+export declare function handleCrossBlockTypeReplace(ctx: CrossBlockDispatchContext, mutCtx: CrossBlockMutationContext, e: InputEvent): Promise<boolean>;

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

@@ -0,0 +1,129 @@
+/**
+ * Cross-block type-replace: the user typed a character with a cross-block selection active.
+ * 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`.
+ */
+import { performCrossBlockDelete } from './ops';
+import { charOffsetOf } from '../primitives';
+import { blockNodeAt, normalizeBodyWrite, updateNodeContent, writeOwnRaw, settledCaretTarget } from '../../tree-operations/node-ops';
+import { focusCollapsedCaret } from '../native-bridge';
+import { ensureUnsharedChild, ensureUnsharedNode, ensureUnsharedPath, rebuildUnsharedChain } from '../../tree-operations/unshare';
+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 ?? '';
+    const caret = await performCrossBlockDelete(mutCtx, { skipCaretRestore: true });
+    if (!caret)
+        return true;
+    // 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;
+    }
+    const doc = ctx.getDoc();
+    const targetNode = blockNodeAt(doc, caret.path);
+    if (!targetNode) {
+        focusCollapsedCaret(ctx.getBlockElByPath, caret);
+        return true;
+    }
+    // `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
+    // `input`, which consumers read as "kind held" (components/lrd-map-gate.ts runs post-commit
+    // and cannot recover a destroyed kind). snapshot: 'skip' keeps the char in the delete's unit.
+    const scope = resolveTypedCharScope(ctx, caret.path);
+    if (!scope) {
+        focusCollapsedCaret(ctx.getBlockElByPath, caret);
+        return true;
+    }
+    // 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
+    // the enforcement belt — an unregistered ancestor would make `scope` a grandparent and splice
+    // the wrong slot, so that case degrades to a raw-only splice instead.
+    const leafIndex = caret.path[caret.path.length - 1];
+    const scopeIsImmediateParent = scope.path.length === caret.path.length - 1;
+    let settled = { change: { op: 'noop' }, textStart: 0 };
+    await ctx.controller.commitMultiScope({
+        scopes: [scope],
+        snapshot: 'skip',
+        mutate: ([scopeView]) => {
+            const sharing = scopeView.sharing;
+            const charOffset = charOffsetOf(caret, 'cross-block-type-replace:slice');
+            if (!scopeIsImmediateParent) {
+                devWarn('cross-block-type-replace', `scope [${scope.path.join(',')}] is not the immediate parent of leaf [${caret.path.join(',')}]; splicing raw without kind re-derivation`);
+                const chain = ensureUnsharedPath(doc, caret.path, sharing);
+                const owned = chain[chain.length - 1] ?? ensureUnsharedNode(targetNode, sharing);
+                // Degraded, but still a body write: this arm splices raw with no reparse, so the
+                // container's rule and the leaf's own are all that stand between a typed `>` or
+                // backtick and a terminator line.
+                writeOwnRaw(owned, normalizeBodyWrite(chain[chain.length - 2]?.kind, owned.raw.slice(0, charOffset) + typed + owned.raw.slice(charOffset)), ctx.grammar);
+                rebuildUnsharedChain(doc, chain, sharing, null, ctx.grammar);
+                return [{ op: 'noop' }];
+            }
+            // Re-parse the spliced leaf inside the commit so a marker at offset 0 re-derives the
+            // kind (updateNodeContent mints a fresh node on a kind change). A single character
+            // never introduces a blank line, so the multi-block replacement arm is unreachable.
+            const owned = ensureUnsharedChild(scopeView.node, leafIndex, sharing);
+            const newText = owned.raw.slice(0, charOffset) + typed + owned.raw.slice(charOffset);
+            settled = updateNodeContent({ children: scopeView.children, ownerKind: scopeView.node.kind, owner: scopeView.node }, leafIndex, newText, ctx.grammar, sharing);
+            stampStructuralChange(scopeView.children, settled.change, sharing);
+            return [settled.change];
+        },
+        op: {
+            kind: 'updateContent',
+            // `op` is evaluated ahead of `mutate` and the splice only inserts, so the post-commit
+            // length is already fixed. Read for the event detail alone.
+            detail: { length: targetNode.raw.length + typed.length },
+            eventPath: docPathFrom(caret.path)
+        },
+        afterTick: async () => {
+            // A settle that absorbed the join above left the predecessor holding the typed bytes,
+            // so the leaf slot the delete resolved is no longer where the caret belongs.
+            const siblings = scopeChildrenOf(ctx, scope.path);
+            const target = settledCaretTarget(settled, leafIndex, caret.offset + typed.length, siblings);
+            const path = [...caret.path.slice(0, -1), target.index];
+            // The reveal above mounted the slot the delete resolved; a fold can land the caret on
+            // one the render window never held.
+            if (target.index !== leafIndex)
+                await ctx.revealPath(path);
+            focusCollapsedCaret(ctx.getBlockElByPath, { path, offset: target.offset });
+        }
+    });
+    return true;
+}
+/** The scope's children, re-read after the commit: the ceremony replaces the node it published. */
+function scopeChildrenOf(ctx, scopePath) {
+    const doc = ctx.getDoc();
+    if (scopePath.length === 0)
+        return doc.children;
+    return blockNodeAt(doc, scopePath)?.children ?? [];
+}
+/**
+ * The smallest commit scope covering the typed-char target: doc scope for a top-level leaf,
+ * nearest container ancestor with a registered BlockListState otherwise. Null when none is
+ * mounted, and the caller falls back to a direct caret restore.
+ */
+function resolveTypedCharScope(ctx, leafPath) {
+    if (leafPath.length === 1) {
+        return ctx.controller.getDocScope();
+    }
+    const doc = ctx.getDoc();
+    for (let depth = leafPath.length - 1; depth >= 1; depth--) {
+        const ancestorPath = leafPath.slice(0, depth);
+        const ancestor = blockNodeAt(doc, ancestorPath);
+        if (!ancestor)
+            continue;
+        const state = getStateForNode(ancestor);
+        if (state)
+            return { node: ancestor, state, path: ancestorPath };
+    }
+    return null;
+}

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

@@ -0,0 +1,39 @@
+/**
+ * Caret placement from a viewport point: the dead-space click (padding beside a block, the area
+ * below the last one) and the public `placeCaretAtPoint`, which shares the walk under the gesture
+ * guards. A y belonging to no band may name an eligible gap boundary; otherwise the point clamps
+ * into the nearest mounted block's box (`nearest-block.ts`) and resolves there, no kind named.
+ * Only what is mounted is measured, so "below the last block" resolves against the CST (VR-6).
+ */
+import { type BlockComponent } from '../block-component';
+import { type GapStopScope } from './gap-caret';
+export interface DeadSpaceCaretDeps {
+    getBlockComponent(path: number[]): BlockComponent | null;
+    /**
+     * The shared pointerdown preamble (`cross-block/pointer.ts`), pre-bound to a non-shift press:
+     * a dead-space click must end a live cross-block range exactly as a click on a block does.
+     */
+    resetSelectionForClick(): void;
+    /** The gap-caret arrival's reads; a point landing between two root bands parks there. */
+    gapScope: GapStopScope;
+    /** The document's own last top-level index, from the CST. The last mounted band is the
+     *  document's last block only while nothing is windowed out below it. */
+    lastBlockIndex(): number;
+    /** Reveal (mount) a top-level block and hand back its component — the same road undo's
+     *  restore uses. */
+    revealBlock(index: number): Promise<BlockComponent | null>;
+}
+export interface DeadSpaceCaret {
+    /** `root` is the element the installing effect captured, not a live binding. */
+    notePress(root: HTMLElement, event: MouseEvent): void;
+    /** Returns whether the click was claimed; false leaves every existing click semantic alone. */
+    handleClick(root: HTMLElement, event: MouseEvent): boolean;
+    /**
+     * The landing walk with no gesture discrimination in front of it, for a caller that has
+     * already decided to answer the point — the public `placeCaretAtPoint`. Shared rather than
+     * reimplemented, so the two can never resolve one point differently. True means the point
+     * was claimed; a point past a windowed-out tail claims it and lands after the reveal.
+     */
+    placeAtPoint(root: HTMLElement, x: number, y: number): boolean;
+}
+export declare function createDeadSpaceCaret(deps: DeadSpaceCaretDeps): DeadSpaceCaret;

package/dist/selection/dead-space-caret.js

@@ -0,0 +1,173 @@
+/**
+ * Caret placement from a viewport point: the dead-space click (padding beside a block, the area
+ * below the last one) and the public `placeCaretAtPoint`, which shares the walk under the gesture
+ * guards. A y belonging to no band may name an eligible gap boundary; otherwise the point clamps
+ * into the nearest mounted block's box (`nearest-block.ts`) and resolves there, no kind named.
+ * Only what is mounted is measured, so "below the last block" resolves against the CST (VR-6).
+ */
+import { CURSOR_END } from '../block-component';
+import { blockAtPoint } from './block-hit-test';
+import { measureBlocks, nearestBand, probePointIn } from './nearest-block';
+import { placeGapCaret } from './caret-doors';
+import { canGapStop } from './gap-caret';
+import { offsetFromViewportPoint } from '../cursor/point-offset';
+export function createDeadSpaceCaret(deps) {
+    // The press half of the gesture, because `click` alone cannot tell a dead-space click from a
+    // drag that STARTED on a block and released in the margin: both report dead space as target.
+    let pressedOnDeadSpace = false;
+    /** The end-of-document gesture when the tail is windowed out: reveal the real last block,
+     *  then land at its end — which is where the trailing-corner probe below lands when the
+     *  slice already reaches it. */
+    async function landAtDocumentEnd() {
+        const index = deps.lastBlockIndex();
+        if (index < 0)
+            return;
+        const component = await deps.revealBlock(index);
+        if (!component?.focusable)
+            return;
+        deps.resetSelectionForClick();
+        component.focus(CURSOR_END);
+    }
+    function placeAtPoint(root, x, y) {
+        // One measuring pass for both walks: the boundary question and the band clamp read the
+        // same layout, and a second query would force it again inside one click.
+        const blocks = measureBlocks(root);
+        const boundary = rootBoundaryOutsideBands(blocks, y);
+        if (boundary !== null && canGapStop(deps.gapScope, [], boundary)) {
+            // The preamble first, as on the block landing below — it clears the gap, so
+            // nothing may run between it and the door. The door ends a live range (G2.12).
+            deps.resetSelectionForClick();
+            placeGapCaret(deps.gapScope.selection, { parentPath: [], index: boundary });
+            return true;
+        }
+        const band = nearestBand(blocks.map((b) => b.rect), y);
+        if (!band)
+            return false;
+        // Below the last MOUNTED block is not below the document while a tail is windowed out,
+        // and a host's own below-the-editor handler resolves against the whole document — so
+        // the two would land a document apart. The reveal road is the only answer available
+        // here: the target has no box to probe until it mounts.
+        if (band.belowAll && lastMountedTopLevel(blocks) !== deps.lastBlockIndex()) {
+            void landAtDocumentEnd();
+            return true;
+        }
+        const { x: probeX, y: probeY } = probePointIn(blocks[band.index].rect, x, y, band.belowAll);
+        const hit = blockAtPoint(root, probeX, probeY);
+        if (!hit)
+            return false;
+        const landing = landingFor(hit, probeX, probeY);
+        if (!landing)
+            return false;
+        const component = deps.getBlockComponent(hit.path);
+        if (!component?.focusable)
+            return false;
+        // An internal landing needs the deep door; a block declaring the hook without it
+        // can't be reached, and declining here keeps the selection intact.
+        if (landing.path.length > 0 && !component.focusByPath)
+            return false;
+        // Only once the landing is known, so a declined point leaves the selection as it
+        // found it: a live range stays painted over a caret placed elsewhere, and the next
+        // printable key type-replaces the whole of it.
+        deps.resetSelectionForClick();
+        // Both doors end the live range (`selection/caret-doors.ts`); `focusByPath` reaches
+        // the leaf's own `focus`.
+        if (landing.path.length === 0)
+            component.focus(landing.offset);
+        else
+            component.focusByPath(landing.path, landing.offset);
+        // The probe point is inside the block's box, so the surface answers it exactly as it
+        // answers a click there: a landing at an atomic widget's edge has nothing to show for
+        // itself until the surface's own snap paints it.
+        leafOf(component, landing.path)?.snapCaretToPoint?.(probeX, probeY);
+        return true;
+    }
+    return {
+        notePress(root, event) {
+            pressedOnDeadSpace =
+                isDeadSpace(root, event.target) &&
+                    event.button === 0 &&
+                    // Shift belongs to selection extension, the modifiers to platform commands.
+                    !(event.shiftKey || event.ctrlKey || event.metaKey || event.altKey);
+        },
+        handleClick(root, event) {
+            const pressed = pressedOnDeadSpace;
+            pressedOnDeadSpace = false;
+            if (!pressed || !isDeadSpace(root, event.target))
+                return false;
+            // A drag that ended in the margin leaves a real range behind; collapsing it would
+            // throw away what the user just selected. This sees only NATIVE ranges: a cross-block
+            // range is overlay-painted with the native selection empty, and is ended below instead.
+            const native = root.ownerDocument.defaultView?.getSelection();
+            if (native && native.rangeCount > 0 && !native.isCollapsed)
+                return false;
+            return placeAtPoint(root, event.clientX, event.clientY);
+        },
+        placeAtPoint
+    };
+}
+// ── Internal ───────────────────────────────────────────────────────────────
+/** The last top-level index the slice currently holds; -1 when none is mounted. */
+function lastMountedTopLevel(blocks) {
+    for (let i = blocks.length - 1; i >= 0; i--) {
+        const path = blocks[i].path;
+        if (path?.length === 1)
+            return path[0];
+    }
+    return -1;
+}
+/**
+ * The root-level boundary a `y` belonging to NO band names: the editor's leading padding,
+ * and the space between two adjacent bands where a layout leaves one. Below the last band
+ * is excluded — that y is the end-of-document gesture, and under windowing the last MOUNTED
+ * band is not the last block. Indices come off the path attribute for the same reason.
+ */
+function rootBoundaryOutsideBands(blocks, y) {
+    const bands = blocks.flatMap((b) => b.path?.length === 1 ? [{ index: b.path[0], top: b.rect.top, bottom: b.rect.bottom }] : []);
+    if (bands.length === 0)
+        return null;
+    // Only when the document's own first block is mounted: above a windowed-out slice the
+    // blocks the point sits over are not the ones the boundary would name.
+    if (y < bands[0].top)
+        return bands[0].index === 0 ? 0 : null;
+    for (let i = 1; i < bands.length; i++) {
+        const above = bands[i - 1];
+        const below = bands[i];
+        if (above.index + 1 === below.index && y > above.bottom && y < below.top)
+            return below.index;
+    }
+    return null;
+}
+/** The component the landing addresses: this one on a character surface, else the leaf a
+ *  coordinate-addressed kind's internal path names. */
+function leafOf(component, path) {
+    if (path.length === 0)
+        return component;
+    return component.getBlockComponentByPath?.(path) ?? null;
+}
+/**
+ * The targets that mean "dead space": the root, and any block list inside it. A host that
+ * widens or pads `.block-list` moves the whole visible side gutter onto the list, which
+ * reports itself rather than the root. Everything else the editor renders has its own
+ * identity and is declined here.
+ */
+function isDeadSpace(root, target) {
+    if (target === root)
+        return true;
+    return target instanceof Element && target.classList.contains('block-list');
+}
+/**
+ * Where the caret goes for a resolved hit: an internal child path (empty for a
+ * character-addressed surface) plus the offset within that leaf. Null declines the click.
+ */
+function landingFor(hit, probeX, probeY) {
+    if (hit.caretTargetAtPoint)
+        return hit.caretTargetAtPoint(probeX, probeY);
+    // A kind with only the drag hook addresses cells and named no caret landing.
+    if (hit.foreignDragHitTest)
+        return null;
+    // Reading mode flips contenteditable off, and a non-editable leaf has no character position.
+    if (!hit.charSurface?.matches('[contenteditable="true"]'))
+        return null;
+    const offset = offsetFromViewportPoint(hit.charSurface, probeX, probeY);
+    return offset === null ? null : { path: [], offset };
+}

package/dist/selection/drag-pointer.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Pointer drag lifecycle for cross-block selection. Runs on a shared
+ * `createPointerDragSession`, whose document-level listeners deliver events even after the
+ * pointer leaves the originating block.
+ */
+import type { UserScrollport } from '../cursor/scroll-ancestors';
+import type { SelectionState } from './selection-state.svelte';
+import type { SelectionPoint } from './primitives';
+import type { BlockElLookup } from '../editor-keys';
+export interface DragContext {
+    editorRoot: HTMLElement;
+    /** What autoscrolls this drag: an element, or the window (`cursor/scroll-ancestors`). */
+    scrollContainer: UserScrollport;
+    selection: SelectionState;
+    getBlockElByPath: BlockElLookup;
+    /** Aborted on editor unmount; forwarded to the session's teardown. */
+    lifetimeSignal?: AbortSignal;
+}
+/** Document-level pointer listeners for a cross-block drag started at `down`, plus a disposer. */
+export declare function installDragListener(ctx: DragContext, anchorPoint: SelectionPoint, down: PointerEvent): {
+    dispose(): void;
+};