@voithos-labs/aragonite 0.10.2 → 0.10.4

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,43 @@ export function createDeadSpaceCaret(deps) {
         leafOf(component, landing.path)?.snapCaretToPoint?.(probeX, probeY);
         return true;
     }
+    /** The nearest block's hit for a press, with the probe point clamped into its band. */
+    function hitNearPoint(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);
+        return hit && { hit, probeX, probeY };
+    }
+    function anchorAtPoint(root, x, y) {
+        const near = hitNearPoint(root, x, y);
+        if (!near)
+            return null;
+        const { hit, probeX, probeY } = near;
+        // 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 };
+    }
+    function blockPathNearPoint(root, x, y) {
+        return hitNearPoint(root, x, y)?.hit.path.slice() ?? null;
+    }
     return {
+        isDeadSpaceTarget: isDeadSpace,
+        anchorAtPoint,
+        blockPathNearPoint,
         notePress(root, event) {
             pressedOnDeadSpace =
                 isDeadSpace(root, event.target) &&
@@ -155,6 +198,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 +217,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/drag-pointer.d.ts

@@ -5,8 +5,9 @@
  */
 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';
+import { type SelectionPoint } from './primitives';
 export interface DragContext {
     editorRoot: HTMLElement;
     /** What autoscrolls this drag: an element, or the window (`cursor/scroll-ancestors`). */
@@ -15,8 +16,31 @@ 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;
+    /** A drag continuing a multi-click: the range grows by that rung's unit. */
+    granularity?: DragGranularity;
+}
+/** The unit a multi-click drag grows by. Spans are raw offsets; the press's own span is the
+ *  floor the range never shrinks below. */
+export interface DragGranularity {
+    /** Where the press selected; a pointer that names no other block paints here. */
+    surface: HTMLElement;
+    anchorSpan: {
+        start: number;
+        end: number;
+    };
+    spanAround(offset: number): {
+        start: number;
+        end: number;
+    };
+    /** A focus in another block, pushed to the unit's boundary on the side away from the anchor. */
+    expandFocus(point: SelectionPoint, side: 'before' | 'after'): SelectionEndpoint;
 }
 /** 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;
 };

package/dist/selection/drag-pointer.js

@@ -3,7 +3,9 @@
  * `createPointerDragSession`, whose document-level listeners deliver events even after the
  * pointer leaves the originating block.
  */
-import { applyCollapsedCaret } from './native-bridge';
+import { caretOffsetAtPoint } from '../cursor/point-offset';
+import { applyCollapsedCaret, applySingleBlockRange, clearNativeSelection } from './native-bridge';
+import { isWholeBlockEndpoint } from './primitives';
 import { comparePaths } from './path-math';
 import { createPointerDragSession } from './pointer-session';
 import { blockNearPoint } from './nearest-block';
@@ -17,25 +19,116 @@ export function installDragListener(ctx, anchorPoint, down) {
         const near = blockNearPoint(ctx.editorRoot, clientX, clientY);
         if (!near)
             return;
+        if (ctx.granularity) {
+            processGranularMove(ctx.granularity, near, clientX, clientY);
+            return;
+        }
         if (comparePaths(near.path, anchorPoint.path) === 0) {
+            if (!('offset' in anchorPoint)) {
+                if (ctx.paintSameBlock)
+                    takeAnchorBlockWhole();
+                return;
+            }
             if (ctx.selection.isCrossBlock) {
                 // Pointer returned to the anchor block: collapse so the overlay stops painting a
                 // stale remote range. The browser's drag has been extending the native selection
                 // underneath all along, so handing back gives the right single-block highlight.
                 ctx.selection.collapse();
             }
+            if (ctx.paintSameBlock)
+                paintSameBlockRange(near.endpointHere());
             return;
         }
         const focusPoint = near.endpointHere();
         if (!focusPoint)
             return;
-        if (!ctx.selection.isCrossBlock) {
+        if (isWholeBlockEndpoint(focusPoint) && !reachedCentreLine(near.path, clientY))
+            return;
+        // A whole unit re-enters rather than extends: its anchor's side is resolved against the
+        // new focus by the entry, where an extend would keep the unit's start as the anchor.
+        if (!ctx.selection.isCrossBlock || ctx.selection.wholeUnitPath) {
             ctx.selection.enterCrossBlock(anchorPoint, focusPoint);
         }
         else {
             ctx.selection.extendFocus(focusPoint);
         }
     }
+    // The anchor's side flips with the drag's direction (the press's span ends the range going up,
+    // starts it going down), so a flip re-enters; a same-side move only extends.
+    let anchorAfter = null;
+    function processGranularMove(unit, near, clientX, clientY) {
+        const anchorIsChar = 'offset' in anchorPoint && !anchorPoint.cellCoordinate;
+        if (!anchorIsChar || comparePaths(near.path, anchorPoint.path) === 0) {
+            if (ctx.selection.isCrossBlock)
+                ctx.selection.collapse();
+            anchorAfter = null;
+            const offset = caretOffsetAtPoint(unit.surface, clientX, clientY);
+            if (offset === null)
+                return;
+            const span = unit.spanAround(offset);
+            unit.surface.focus({ preventScroll: true });
+            applySingleBlockRange(unit.surface, Math.min(unit.anchorSpan.start, span.start), Math.max(unit.anchorSpan.end, span.end));
+            return;
+        }
+        const focusPoint = near.endpointHere();
+        if (!focusPoint)
+            return;
+        if (isWholeBlockEndpoint(focusPoint) && !reachedCentreLine(near.path, clientY))
+            return;
+        const after = comparePaths(near.path, anchorPoint.path) > 0;
+        const focus = isWholeBlockEndpoint(focusPoint)
+            ? focusPoint
+            : unit.expandFocus(focusPoint, after ? 'after' : 'before');
+        if (!ctx.selection.isCrossBlock || anchorAfter !== after) {
+            anchorAfter = after;
+            ctx.selection.enterCrossBlock({
+                path: anchorPoint.path.slice(),
+                offset: after ? unit.anchorSpan.start : unit.anchorSpan.end
+            }, focus);
+        }
+        else {
+            ctx.selection.extendFocus(focus);
+        }
+    }
+    // A block with no positions inside it is in or out as a unit, and the unit joins the range
+    // once the pointer has crossed its centre line coming from the anchor's side: a sweep that
+    // merely touched its edge has not asked for it. Not reached, the last focus stands, so the
+    // range grows to the block only when the pointer commits to it.
+    function reachedCentreLine(path, clientY) {
+        const box = ctx.getBlockElByPath(path)?.getBoundingClientRect();
+        if (!box)
+            return true;
+        const middle = box.top + box.height / 2;
+        return comparePaths(anchorPoint.path, path) < 0 ? clientY >= middle : clientY <= middle;
+    }
+    // A whole-block anchor (a table, an equation) has nothing to paint natively either, and a range
+    // that only appears once the pointer reaches ANOTHER block reads as a drag that does nothing.
+    // The block is taken whole the moment the pointer moves, as the unit the state stores and the
+    // overlay paints (`wholeUnitPath`); a pointer returning from outside takes it whole again.
+    function takeAnchorBlockWhole() {
+        if (ctx.selection.wholeUnitPath)
+            return;
+        // Both ends whole: the pointer's position INSIDE the block is not a rectangle to grow (a
+        // press beside a table dragged up over it would otherwise select the rows below the
+        // pointer, the opposite of the sweep). The block is the unit until the drag leaves it.
+        ctx.selection.enterCrossBlock(anchorPoint, {
+            path: anchorPoint.path.slice(),
+            wholeBlock: true
+        });
+    }
+    // A margin-started drag has no native selection under it, so the range inside the anchor
+    // block is written here, and the block takes focus so the range is live for the next key.
+    function paintSameBlockRange(focusPoint) {
+        if (!focusPoint || !('offset' in focusPoint) || !('offset' in anchorPoint))
+            return;
+        const blockEl = ctx.getBlockElByPath(anchorPoint.path);
+        if (!blockEl)
+            return;
+        // A no-op once it holds focus; the range is a DOM Range, so it is written low-to-high (a
+        // drag from the right margin leftward would otherwise collapse it).
+        blockEl.focus({ preventScroll: true });
+        applySingleBlockRange(blockEl, Math.min(anchorPoint.offset, focusPoint.offset), Math.max(anchorPoint.offset, focusPoint.offset));
+    }
     // Pointer may land on a scrollable element directly (the table's `.table-block` edge), so
     // search from `target` itself, not its parent.
     function scrollableSelfOrAncestor(target) {
@@ -79,6 +172,14 @@ function parkCaretInFocusBlock(ctx) {
     const focus = ctx.selection.focus;
     if (!focus)
         return;
+    // A whole unit has no text node for a caret: focus parks on the editor root, whose keydown
+    // and clipboard arms serve a custom range (as they do for a windowed-out block), with no
+    // native range left behind for the browser to act on.
+    if (ctx.selection.wholeUnitPath) {
+        clearNativeSelection();
+        ctx.editorRoot.focus({ preventScroll: true });
+        return;
+    }
     // A drag ending inside a table leaves a focus addressing the table block by cell index; the
     // landing is the cell that actually holds a caret.
     const landing = ctx.selection.cellLandingFor(focus);

package/dist/selection/gap-caret.js

@@ -4,7 +4,7 @@
  * in, boolean out; `tryGapStop` is the one seam that turns it into an arrival.
  * The gap is deliberately not a `SelectionPoint`: it is never a cross-block endpoint.
  */
-import { isBlockNode, nodeAt } from '../tree-operations/node-ops';
+import { isBlockNode, nodeAt } from '../tree-operations/node-primitives';
 import { tryGetBlockKindDescriptor } from '../schema/block-kind-descriptor';
 import { isReadingMode } from '../presentation-mode';
 import { placeGapCaret } from './caret-doors';

package/dist/selection/keyboard-extend.d.ts

@@ -18,8 +18,9 @@ export declare function scrollFocusBlockIntoView(selection: SelectionState, getB
 /**
  * Extend focus to the next leaf in document order (Shift+ArrowDown / Shift+ArrowRight leaving
  * the block), entering cross-block mode if needed. Returns true if focus moved. `axis` =
- * 'vertical' skips vertically-transparent leaves, mirroring single-block focus dispatch;
- * 'horizontal' lands unconditionally so an image-only paragraph is selectable in one step.
+ * 'vertical' skips vertically-transparent leaves — a range covers one either way, so unlike a
+ * collapsed caret it needs no object stop; 'horizontal' lands unconditionally so an image-only
+ * paragraph is selectable in one step.
  */
 export declare function extendFocusToNextBlock(selection: SelectionState, doc: Document, currentBlockEl: HTMLElement, currentBlockPath: number[], axis?: 'horizontal' | 'vertical', getBlockElByPath?: BlockElLookup): boolean;
 /**

package/dist/selection/keyboard-extend.js

@@ -3,7 +3,7 @@ import { isVerticallyTransparentNode } from '../core/inline/transparency';
 import { readNativeCaretInBlock, applyCollapsedCaret, focusCollapsedCaret, applySingleBlockRange, clearNativeSelection } from './native-bridge';
 import { offsetFromViewportPoint } from '../cursor/point-offset';
 import { nextPath, previousPath, firstPath, lastPath, firstLeafAtOrAfter, lastLeafAtOrBefore, findCellPathForElement } from './path-lookup';
-import { nodeAt } from '../tree-operations/node-ops';
+import { nodeAt } from '../tree-operations/node-primitives';
 import { comparePaths, isStrictAncestorOf, pathsEqual } from './path-math';
 import { displayLength } from '../core/lines';
 // ── Enter / Collapse / Scroll ──────────────────────────────────────────────
@@ -79,8 +79,9 @@ function extendFocusOrRestore(selection, target, offset, getBlockElByPath) {
 /**
  * Extend focus to the next leaf in document order (Shift+ArrowDown / Shift+ArrowRight leaving
  * the block), entering cross-block mode if needed. Returns true if focus moved. `axis` =
- * 'vertical' skips vertically-transparent leaves, mirroring single-block focus dispatch;
- * 'horizontal' lands unconditionally so an image-only paragraph is selectable in one step.
+ * 'vertical' skips vertically-transparent leaves — a range covers one either way, so unlike a
+ * collapsed caret it needs no object stop; 'horizontal' lands unconditionally so an image-only
+ * paragraph is selectable in one step.
  */
 export function extendFocusToNextBlock(selection, doc, currentBlockEl, currentBlockPath, axis = 'horizontal', getBlockElByPath) {
     const leafTarget = axis === 'vertical'

package/dist/selection/multi-click.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The click ladder past the caret: the second press of a run selects the word under it, the
+ * third the surface's content, and a drag from either extends at that granularity. Owned from
+ * the second press, so the browser paints nothing of its own: its word rule is per platform,
+ * its walk enters atomic islands, and a marker here never joins a word.
+ */
+import type { UserScrollport } from '../cursor/scroll-ancestors';
+import type { BlockElLookup } from '../editor-keys';
+import type { SelectionState } from './selection-state.svelte';
+export type ClickGranularity = 'word' | 'block';
+export interface Span {
+    start: number;
+    end: number;
+}
+/**
+ * [start, end) of the segment at `offset` in `text`: the word ending there when it is one, else
+ * the segment starting there (whitespace or punctuation, as the engine would take). Null on
+ * empty text, or on a platform with no segmenter.
+ */
+export declare function wordSpanAt(text: string, offset: number): Span | null;
+/** The raw span `granularity` takes around a raw offset in `surface`; null where the word rule
+ *  has nothing to read. */
+export declare function spanAround(surface: HTMLElement, granularity: ClickGranularity, rawOffset: number): Span | null;
+/** The rung a press's click count reaches; the run stays at the block rung past three. */
+export declare function granularityForClickCount(clickCount: number): ClickGranularity | null;
+export interface MultiClickDeps {
+    editorRoot: HTMLElement;
+    selection: SelectionState;
+    getBlockElByPath: BlockElLookup;
+    getScrollContainer(): UserScrollport;
+    lifetimeSignal?: AbortSignal;
+    /** A press outside every editable surface (the margin, a container's own box) names the
+     *  nearest block, as a single click there does; null where the press is chrome's. */
+    marginBlockAt(target: EventTarget | null, clientX: number, clientY: number): number[] | null;
+}
+/**
+ * Root listeners for the ladder. The count rides the mousedown (a pointer event carries none),
+ * and the drag rides the pointerdown of the same press, so both are heard. The mousedown is
+ * cancelled, never the pointerdown (that would silence the click), and so is the mouseup: the
+ * browser's release seats a caret at a press that landed off a glyph, over the range just painted.
+ */
+export declare function installMultiClickSelect(deps: MultiClickDeps): () => void;

package/dist/selection/multi-click.js

@@ -0,0 +1,203 @@
+/**
+ * The click ladder past the caret: the second press of a run selects the word under it, the
+ * third the surface's content, and a drag from either extends at that granularity. Owned from
+ * the second press, so the browser paints nothing of its own: its word rule is per platform,
+ * its walk enters atomic islands, and a marker here never joins a word.
+ */
+import { ambientLengthOf } from '../ambient/ambient-dom';
+import { asDomTextOffset, asRawOffset, toClampedRawOffset, toDomTextOffset } from '../cursor/coordinate-spaces';
+import { caretOffsetAtPoint } from '../cursor/point-offset';
+import { containerDomTextLength, maskedWalkText } from '../cursor/widget-offset';
+import { isWholeBlockInputProxy } from '../editor-actions/whole-block-focus-surface';
+import { installDragListener } from './drag-pointer';
+import { applySingleBlockRange, applySurfaceContentRange } from './native-bridge';
+import { blockNearPoint } from './nearest-block';
+// ── The word rule ────────────────────────────────────────────────────────────
+let segmenter;
+function wordSegmenter() {
+    if (segmenter === undefined) {
+        segmenter =
+            typeof Intl.Segmenter === 'function'
+                ? new Intl.Segmenter(undefined, { granularity: 'word' })
+                : null;
+    }
+    return segmenter;
+}
+/**
+ * [start, end) of the segment at `offset` in `text`: the word ending there when it is one, else
+ * the segment starting there (whitespace or punctuation, as the engine would take). Null on
+ * empty text, or on a platform with no segmenter.
+ */
+export function wordSpanAt(text, offset) {
+    const seg = wordSegmenter();
+    if (!seg || text.length === 0)
+        return null;
+    const segments = seg.segment(text);
+    const at = Math.max(0, Math.min(offset, text.length));
+    const left = at > 0 ? segments.containing(at - 1) : undefined;
+    const right = at < text.length ? segments.containing(at) : undefined;
+    if (left && right && left.index === right.index)
+        return spanOf(left);
+    if (left?.isWordLike)
+        return spanOf(left);
+    const pick = right ?? left;
+    return pick ? spanOf(pick) : null;
+}
+function spanOf(segment) {
+    return { start: segment.index, end: segment.index + segment.segment.length };
+}
+/** The raw span `granularity` takes around a raw offset in `surface`; null where the word rule
+ *  has nothing to read. */
+export function spanAround(surface, granularity, rawOffset) {
+    const ambient = ambientLengthOf(surface);
+    if (granularity === 'block') {
+        return { start: 0, end: toClampedRawOffset(containerDomTextLength(surface), ambient) };
+    }
+    const walk = toDomTextOffset(asRawOffset(rawOffset), ambient);
+    const span = wordSpanAt(maskedWalkText(surface), walk);
+    if (!span)
+        return null;
+    return {
+        start: toClampedRawOffset(asDomTextOffset(span.start), ambient),
+        end: toClampedRawOffset(asDomTextOffset(span.end), ambient)
+    };
+}
+/** The rung a press's click count reaches; the run stays at the block rung past three. */
+export function granularityForClickCount(clickCount) {
+    if (clickCount === 2)
+        return 'word';
+    return clickCount >= 3 ? 'block' : null;
+}
+/**
+ * Root listeners for the ladder. The count rides the mousedown (a pointer event carries none),
+ * and the drag rides the pointerdown of the same press, so both are heard. The mousedown is
+ * cancelled, never the pointerdown (that would silence the click), and so is the mouseup: the
+ * browser's release seats a caret at a press that landed off a glyph, over the range just painted.
+ */
+export function installMultiClickSelect(deps) {
+    let lastPointerDown = null;
+    let claimed = false;
+    const onPointerDown = (e) => {
+        lastPointerDown = e;
+    };
+    const onMouseUp = (e) => {
+        if (claimed)
+            e.preventDefault();
+    };
+    const onMouseDown = (e) => {
+        claimed = false;
+        const granularity = granularityForClickCount(e.detail);
+        if (!granularity || e.button !== 0 || e.shiftKey || e.ctrlKey || e.metaKey || e.altKey)
+            return;
+        if (pressesInlineWidget(e.target))
+            return;
+        const press = pressedSurface(deps, e);
+        if (!press)
+            return;
+        const anchorSpan = selectAtPoint(press.surface, granularity, e.clientX, e.clientY);
+        if (!anchorSpan)
+            return;
+        e.preventDefault();
+        claimed = true;
+        const anchor = press.anchor ?? blockNearPoint(deps.editorRoot, e.clientX, e.clientY)?.endpointHere();
+        if (!anchor || !lastPointerDown)
+            return;
+        installDragListener({
+            editorRoot: deps.editorRoot,
+            scrollContainer: deps.getScrollContainer(),
+            selection: deps.selection,
+            getBlockElByPath: deps.getBlockElByPath,
+            lifetimeSignal: deps.lifetimeSignal,
+            granularity: createGranularity(deps.getBlockElByPath, press.surface, granularity, anchorSpan)
+        }, anchor, lastPointerDown);
+    };
+    deps.editorRoot.addEventListener('pointerdown', onPointerDown);
+    deps.editorRoot.addEventListener('mousedown', onMouseDown);
+    deps.editorRoot.addEventListener('mouseup', onMouseUp);
+    return () => {
+        deps.editorRoot.removeEventListener('pointerdown', onPointerDown);
+        deps.editorRoot.removeEventListener('mousedown', onMouseDown);
+        deps.editorRoot.removeEventListener('mouseup', onMouseUp);
+    };
+}
+/** The surface a press selects in: the editable under it, else the nearest block's, the way a
+ *  single click in the margin lands there. A block with no text surface is nobody's word. */
+function pressedSurface(deps, e) {
+    // Up through an island inside the editable (a list's `- ` prefix) to the surface itself.
+    const own = surfaceOf(e.target);
+    if (own)
+        return isWholeBlockInputProxy(own) ? null : { surface: own, anchor: null };
+    const path = deps.marginBlockAt(e.target, e.clientX, e.clientY);
+    const block = path && deps.getBlockElByPath(path);
+    if (!block)
+        return null;
+    // A container's own box (a quote's gutter) selects in the leaf nearest the press, the way a
+    // click beside a line lands in that line.
+    const surface = block.contentEditable === 'true' ? block : nearestSurfaceIn(block, e.clientY);
+    const surfacePath = surface && pathOfSurface(surface);
+    const offset = surface && caretOffsetAtPoint(surface, e.clientX, e.clientY);
+    if (!surface)
+        return null;
+    return { surface, anchor: surfacePath && offset !== null ? { path: surfacePath, offset } : null };
+}
+function nearestSurfaceIn(block, clientY) {
+    let best = null;
+    let bestDistance = Infinity;
+    for (const el of block.querySelectorAll('[contenteditable="true"]')) {
+        const rect = el.getBoundingClientRect();
+        const distance = clientY < rect.top ? rect.top - clientY : Math.max(0, clientY - rect.bottom);
+        if (distance < bestDistance) {
+            best = el;
+            bestDistance = distance;
+        }
+    }
+    return best;
+}
+/** The path of the block a surface is the content of; null for a surface addressed some other
+ *  way (a table's cell), whose drag is not a char-point drag. */
+function pathOfSurface(surface) {
+    const host = surface.closest('[data-block-path]');
+    const raw = host?.getAttribute('data-block-path');
+    if (!raw || !host?.contains(surface))
+        return null;
+    const path = JSON.parse(raw);
+    return host.querySelector('[contenteditable="true"]') === surface ? path : null;
+}
+/** Paint the rung's span at the press and answer it, in raw offsets. */
+function selectAtPoint(surface, granularity, clientX, clientY) {
+    if (granularity === 'block') {
+        applySurfaceContentRange(surface);
+        return spanAround(surface, 'block', 0);
+    }
+    const offset = caretOffsetAtPoint(surface, clientX, clientY);
+    const span = offset === null ? null : spanAround(surface, 'word', offset);
+    if (!span || span.start === span.end)
+        return null;
+    applySingleBlockRange(surface, span.start, span.end);
+    return span;
+}
+function createGranularity(getBlockElByPath, surface, granularity, anchorSpan) {
+    return {
+        surface,
+        anchorSpan,
+        spanAround: (offset) => spanAround(surface, granularity, offset) ?? { start: offset, end: offset },
+        expandFocus: (point, side) => {
+            const el = point.cellCoordinate ? null : getBlockElByPath(point.path);
+            const span = el && spanAround(el, granularity, point.offset);
+            if (!span)
+                return point;
+            return { path: point.path.slice(), offset: side === 'after' ? span.end : span.start };
+        }
+    };
+}
+/** A press on an inline widget is that widget's own gesture (a footnote's double-click takes
+ *  its whole token), so the ladder leaves it alone. */
+function pressesInlineWidget(target) {
+    return target instanceof Element && target.closest('[data-inline-widget]') !== null;
+}
+function surfaceOf(target) {
+    let el = target instanceof HTMLElement ? target : null;
+    while (el && el.contentEditable !== 'true')
+        el = el.parentElement;
+    return el;
+}

package/dist/selection/native-bridge.d.ts

@@ -25,6 +25,9 @@ export declare function applyCollapsedCaret(blockEl: HTMLElement, point: Selecti
  * Returns whether an element was found; a missing target is a no-op.
  */
 export declare function focusCollapsedCaret(getBlockElByPath: (path: number[]) => HTMLElement | null, point: SelectionPoint): boolean;
+/** Select a surface's content whole, past its ambient prefix: the first-press Ctrl+A range and
+ *  the triple-click one. */
+export declare function applySurfaceContentRange(el: HTMLElement): void;
 export declare function applySingleBlockRange(blockEl: HTMLElement, startOffset: number, endOffset: number): void;
 export declare function clearNativeSelection(): void;
 /**

package/dist/selection/native-bridge.js

@@ -4,9 +4,10 @@
  * DOM→raw conversion subtracts the length of a leading ambient marker span, whose textContent
  * counts toward DOM offsets but not raw.
  */
-import { asRawOffset, toClampedRawOffset, toDomTextOffset } from '../cursor/coordinate-spaces';
+import { asDomTextOffset, asRawOffset, toClampedRawOffset, toDomTextOffset } from '../cursor/coordinate-spaces';
+import { createRangeFromOffsets } from '../cursor/content-offsets';
 import { clampToLandableRaw, createRangeAtDomTextOffsets, domTextOffsetAtNode } from '../cursor/widget-offset';
-import { ambientLengthOf, placeCaretAfterAmbientSpan } from '../ambient/ambient-dom';
+import { ambientLengthOf, ambientSpanOf, placeCaretAfterAmbientSpan } from '../ambient/ambient-dom';
 // ── Read native → SelectionPoint ────────────────────────────────────────────
 /**
  * Read the collapsed caret inside `blockEl` into a raw-semantic SelectionPoint.
@@ -64,12 +65,40 @@ export function focusCollapsedCaret(getBlockElByPath, point) {
     blockEl.focus();
     return true;
 }
+/** Select a surface's content whole, past its ambient prefix: the first-press Ctrl+A range and
+ *  the triple-click one. */
+export function applySurfaceContentRange(el) {
+    const ambient = ambientSpanOf(el);
+    const ambientLen = ambient?.textContent?.length ?? 0;
+    const textLen = el.textContent?.length ?? 0;
+    if (ambient && textLen > ambientLen) {
+        if (!placeCaretAfterAmbientSpan(el))
+            return;
+        // textLen counts the full textContent (marker included) — a DomTextOffset by construction.
+        const endRange = createRangeFromOffsets(el, asDomTextOffset(textLen), asDomTextOffset(textLen));
+        if (endRange) {
+            window.getSelection()?.extend(endRange.endContainer, endRange.endOffset);
+        }
+        return;
+    }
+    const range = document.createRange();
+    range.selectNodeContents(el);
+    const sel = window.getSelection();
+    sel?.removeAllRanges();
+    sel?.addRange(range);
+}
 export function applySingleBlockRange(blockEl, startOffset, endOffset) {
     const ambient = ambientLengthOf(blockEl);
     const range = createRangeAtDomTextOffsets(blockEl, toDomTextOffset(asRawOffset(startOffset), ambient), toDomTextOffset(asRawOffset(endOffset), ambient));
     if (!range)
         return;
     const sel = window.getSelection();
+    // A start at raw 0 under an ambient marker goes AFTER the island, as a caret does: Chromium
+    // drops a range that opens inside its contenteditable="false".
+    if (ambient > 0 && startOffset <= 0 && placeCaretAfterAmbientSpan(blockEl)) {
+        sel?.extend(range.endContainer, range.endOffset);
+        return;
+    }
     sel?.removeAllRanges();
     sel?.addRange(range);
 }

package/dist/selection/path-lookup.d.ts

@@ -27,6 +27,14 @@ export declare function findBlockPathForElement(el: Element | null): number[] |
  * cell grid; addresses the grid by selector contract (`data-table-row-idx`, `role="cell"`).
  */
 export declare function findCellPathForElement(el: Element | null): number[] | null;
-/** The path of the editing SURFACE `el` sits in — the enclosing cell where there is one, else
- *  the enclosing block. The pairing {@link findCellPathForElement} says every producer owes. */
+/** The editing SURFACE `el` sits in: the enclosing cell where there is one, else the enclosing
+ *  block, and which of the two answered — a caller whose bytes live at a different scope for a
+ *  cell reads the flag rather than re-deriving the pairing. */
+export interface EditingSurface {
+    path: number[];
+    inCell: boolean;
+}
+/** The pairing {@link findCellPathForElement} says every producer owes, in one place. */
+export declare function findSurfaceForElement(el: Element | null): EditingSurface | null;
+/** {@link findSurfaceForElement} for a caller that needs only the path. */
 export declare function findSurfacePathForElement(el: Element | null): number[] | null;