@voithos-labs/aragonite 0.10.2 → 0.10.3

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,7 +4,7 @@
  */
 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';

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

@@ -5,14 +5,15 @@
  */
 import { tableCellCount } from '../table-endpoint-snap';
 import { CURSOR_END } from '../../block-component';
-import { normalizeLineEndings } from '../../core/lines';
+import { normalizeLineEndings, terminateLine } 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';
@@ -32,10 +33,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 +99,59 @@ 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'
-    });
+    // ride here too; both rules live in the helper, applied at both sites. Terminated in the
+    // covered block's OWN ending, or an unterminated clipboard line leaves the block below
+    // flowing into the last one pasted (G4.20).
+    const parsed = parse(terminateLine(applyPasteTransforms(pasted, ctx.activePlugins), covered.raw), { 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);
+    const replacement = normalizeReplacementTrivia(covered, parsed.children);
     for (const node of replacement)
         ensureEditableContainers(node);
     mutCtx.pushUndoSnapshot();
     ctx.selection.collapse();
     await replaceBlockAtParent({
         doc,
-        blockPath: tablePath,
+        blockPath,
         replacement,
         controller: ctx.pasteCoordinator,
         undoEntry: 'join',
         focusReplacementIndex: 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,51 @@
  * 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 { parse } from '../../core/parser';
+import { terminateLine } from '../../core/lines';
+import { replaceBlockAtParent } from '../../tree-operations/paste/replace-block-at-parent';
+import { ensureEditableContainers, normalizeReplacementTrivia } from '../../tree-operations';
+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 +56,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 +111,42 @@ 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;
+    // Terminated in the block's OWN ending: an unterminated line leaves the block below flowing
+    // into the one the character just minted (G4.20).
+    const parsed = parse(terminateLine(typed, covered.raw), {
+        grammar: ctx.grammar,
+        scope: 'fragment'
+    });
+    if (parsed.children.length === 0)
+        return;
+    const replacement = normalizeReplacementTrivia(covered, parsed.children);
+    for (const node of replacement)
+        ensureEditableContainers(node);
+    mutCtx.pushUndoSnapshot();
+    ctx.selection.collapse();
+    await replaceBlockAtParent({
+        doc,
+        blockPath,
+        replacement,
+        controller: ctx.pasteCoordinator,
+        undoEntry: 'join',
+        focusReplacementIndex: 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,14 @@ 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;
 }
 export declare function createDeadSpaceCaret(deps: DeadSpaceCaretDeps): DeadSpaceCaret;

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

@@ -55,6 +55,13 @@ export function createDeadSpaceCaret(deps) {
         const hit = blockAtPoint(root, probeX, probeY);
         if (!hit)
             return false;
+        // Prose lands the caret on the line the click is level with, as any editor does. A block
+        // with no character surface (an equation, a table, a rule) has no such line, and a revealed
+        // source is one only while it is being edited: a click that was not ON the block is a click
+        // on nothing, and focuses nothing (the click's owner then blurs what was being edited).
+        const transient = hit.charSurface?.classList.contains('md-source-surface') ?? false;
+        if ((!hit.charSurface || transient) && !pressedOnBlockContent(root, x, y))
+            return false;
         const landing = landingFor(hit, probeX, probeY);
         if (!landing)
             return false;
@@ -81,7 +88,33 @@ export function createDeadSpaceCaret(deps) {
         leafOf(component, landing.path)?.snapCaretToPoint?.(probeX, probeY);
         return true;
     }
+    function anchorAtPoint(root, x, y) {
+        const blocks = measureBlocks(root);
+        const band = nearestBand(blocks.map((b) => b.rect), y);
+        if (!band)
+            return null;
+        if (band.belowAll && lastMountedTopLevel(blocks) !== deps.lastBlockIndex())
+            return null;
+        const { x: probeX, y: probeY } = probePointIn(blocks[band.index].rect, x, y, band.belowAll);
+        const hit = blockAtPoint(root, probeX, probeY);
+        if (!hit)
+            return null;
+        // No character surface to measure against — a rendered equation, a rule, a table — so the
+        // block is the unit, and the funnel picks the side by the drag's direction. An offset would
+        // put a range END at the block's start and leave it out; a cell would make the drag a caret
+        // placement in the nearest column. A rule names no landing at all, and is a unit all the same.
+        if (!hit.charSurface)
+            return { path: hit.path.slice(), wholeBlock: true };
+        const landing = landingFor(hit, probeX, probeY);
+        if (!landing)
+            return null;
+        if (landing.path.length > 0)
+            return { path: hit.path.slice(), wholeBlock: true };
+        return { path: hit.path.slice(), offset: landing.offset };
+    }
     return {
+        isDeadSpaceTarget: isDeadSpace,
+        anchorAtPoint,
         notePress(root, event) {
             pressedOnDeadSpace =
                 isDeadSpace(root, event.target) &&
@@ -155,6 +188,15 @@ function isDeadSpace(root, target) {
         return true;
     return target instanceof Element && target.classList.contains('block-list');
 }
+/** Whether the ORIGINAL point (not the clamped probe) sits inside some block's content: on a
+ *  descendant of a host, not on the host's own box or the dead space around it. */
+function pressedOnBlockContent(root, x, y) {
+    const direct = document.elementFromPoint(x, y);
+    if (!(direct instanceof Element) || isDeadSpace(root, direct))
+        return false;
+    const host = direct.closest('[data-block-path]');
+    return host !== null && host !== direct;
+}
 /**
  * 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.
@@ -165,8 +207,12 @@ function landingFor(hit, probeX, probeY) {
     // A kind with only the drag hook addresses cells and named no caret landing.
     if (hit.foreignDragHitTest)
         return null;
+    // A leaf with no character surface (a rule, a folded equation) reached here was pressed on
+    // its own box: the block itself is the landing, and its `focus` ignores the offset.
+    if (!hit.charSurface)
+        return { path: [], offset: 0 };
     // Reading mode flips contenteditable off, and a non-editable leaf has no character position.
-    if (!hit.charSurface?.matches('[contenteditable="true"]'))
+    if (!hit.charSurface.matches('[contenteditable="true"]'))
         return null;
     const offset = offsetFromViewportPoint(hit.charSurface, probeX, probeY);
     return offset === null ? null : { path: [], offset };

package/dist/selection/double-click-trim.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Word selection without its trailing space. Windows Chromium's double-click takes the whitespace
+ * after a word (the desktop-Word convention); a formatting toggle over that range would wrap the
+ * space too, and every other platform selects the bare word. The browser paints its own range
+ * before any `dblclick` handler runs, so the word is selected HERE, on the second press, with
+ * the native selection suppressed: the trimmed range is the first one ever painted.
+ */
+/** Trim trailing whitespace off the document's current selection when it ends in a text node.
+ *  A selection that is only whitespace is left alone: collapsing it would undo the click. */
+export declare function trimDoubleClickSelection(doc: Document): boolean;
+/**
+ * Select the word under the point of a double-click's second press, trimmed, synchronously.
+ * Word edges come from the engine's own `modify` walk so they match what its double-click would
+ * have chosen. False when the point names no text position; the caller then leaves the press to
+ * the browser.
+ */
+export declare function selectWordAtPoint(doc: Document, x: number, y: number): boolean;

package/dist/selection/double-click-trim.js

@@ -0,0 +1,57 @@
+/**
+ * Word selection without its trailing space. Windows Chromium's double-click takes the whitespace
+ * after a word (the desktop-Word convention); a formatting toggle over that range would wrap the
+ * space too, and every other platform selects the bare word. The browser paints its own range
+ * before any `dblclick` handler runs, so the word is selected HERE, on the second press, with
+ * the native selection suppressed: the trimmed range is the first one ever painted.
+ */
+/** Trim trailing whitespace off the document's current selection when it ends in a text node.
+ *  A selection that is only whitespace is left alone: collapsing it would undo the click. */
+export function trimDoubleClickSelection(doc) {
+    const sel = doc.getSelection();
+    if (!sel || sel.rangeCount === 0 || sel.isCollapsed)
+        return false;
+    const range = sel.getRangeAt(0);
+    const endNode = range.endContainer;
+    if (!(endNode instanceof Text))
+        return false;
+    const text = range.toString();
+    const trimmed = text.trimEnd().length;
+    if (trimmed === 0 || trimmed === text.length)
+        return false;
+    const cut = text.length - trimmed;
+    if (cut > range.endOffset)
+        return false;
+    sel.setBaseAndExtent(range.startContainer, range.startOffset, endNode, range.endOffset - cut);
+    return true;
+}
+/**
+ * Select the word under the point of a double-click's second press, trimmed, synchronously.
+ * Word edges come from the engine's own `modify` walk so they match what its double-click would
+ * have chosen. False when the point names no text position; the caller then leaves the press to
+ * the browser.
+ */
+export function selectWordAtPoint(doc, x, y) {
+    const sel = doc.getSelection();
+    const hit = textPositionAt(doc, x, y);
+    if (!sel || !hit || typeof sel.modify !== 'function')
+        return false;
+    sel.setBaseAndExtent(hit.node, hit.offset, hit.node, hit.offset);
+    sel.modify('move', 'backward', 'word');
+    sel.modify('extend', 'forward', 'word');
+    if (sel.isCollapsed)
+        return false;
+    trimDoubleClickSelection(doc);
+    return true;
+}
+function textPositionAt(doc, x, y) {
+    const position = doc.caretPositionFromPoint?.(x, y);
+    if (position?.offsetNode instanceof Text) {
+        return { node: position.offsetNode, offset: position.offset };
+    }
+    const range = doc.caretRangeFromPoint?.(x, y);
+    if (range?.startContainer instanceof Text) {
+        return { node: range.startContainer, offset: range.startOffset };
+    }
+    return null;
+}

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

@@ -5,7 +5,7 @@
  */
 import type { UserScrollport } from '../cursor/scroll-ancestors';
 import type { SelectionState } from './selection-state.svelte';
-import type { SelectionPoint } from './primitives';
+import type { SelectionEndpoint } from './primitives';
 import type { BlockElLookup } from '../editor-keys';
 export interface DragContext {
     editorRoot: HTMLElement;
@@ -15,8 +15,13 @@ export interface DragContext {
     getBlockElByPath: BlockElLookup;
     /** Aborted on editor unmount; forwarded to the session's teardown. */
     lifetimeSignal?: AbortSignal;
+    /**
+     * The press began outside every editable surface (the editor's margin), so no native drag
+     * is extending a selection underneath: the session paints the same-block range itself.
+     */
+    paintSameBlock?: boolean;
 }
 /** 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): {
+export declare function installDragListener(ctx: DragContext, anchorPoint: SelectionEndpoint, down: PointerEvent): {
     dispose(): void;
 };