@voithos-labs/aragonite 0.10.3 → 0.10.4

package/dist/plugins/mermaid/MermaidBlock.svelte

@@ -32,6 +32,7 @@
 		updateOwnMetadata,
 		handleKeydown,
 		moveFocusOut,
+		captureScrollPosition,
 		getPresentationMode,
 		getTheme
 	} = createContainerBlock({
@@ -142,22 +143,20 @@
 	const view = createPanZoom();
 	const overlayView = createPanZoom();
 
-	// Focus-gated so the in-document diagram never hijacks the page: unfocused, a bare
-	// wheel scrolls and a stray drag cannot pan. Any descendant focus counts.
-	const isFocused = () => !!boxEl?.contains(document.activeElement);
+	// Armed by focus, so an unfocused diagram hijacks neither the page nor the editor's own drag.
+	// Tracked rather than probed: the editor reads the same fact as markup, so there is one value.
+	let gestureArmed = $state(false);
 
 	function onViewportWheel(e: WheelEvent): void {
-		if (!isFocused() || !(e.ctrlKey || e.metaKey)) return;
+		if (!gestureArmed || !(e.ctrlKey || e.metaKey)) return;
 		e.preventDefault();
 		e.stopPropagation();
 		view.zoomBy(e.deltaY);
 	}
 
 	function onViewportPointerDown(e: PointerEvent): void {
-		// Never preventDefault, so the browser's focus-on-mousedown still lands: the
-		// first click focuses, and only a drag on the now-focused block pans.
 		e.stopPropagation();
-		if (isFocused()) view.beginPan(e);
+		if (gestureArmed) view.beginPan(e);
 	}
 
 	function onOverlayWheel(e: WheelEvent): void {
@@ -219,8 +218,11 @@
 		// there too, so this closes the command path.
 		if (isReading) return;
 		if (!editing) seedDraft();
+		// Captured BEFORE the flip: the card reaches its fitted height only after mounting, and
+		// a scrollport at the document's end clamps against the short layout in between.
+		const restoreScroll = captureScrollPosition();
 		editRequested = true;
-		void tick().then(() => textareaEl?.focus());
+		void restoreScroll().then(() => textareaEl?.focus());
 	}
 
 	function cancelEdit(): void {
@@ -306,7 +308,13 @@
 </script>
 
 <!-- svelte-ignore a11y_no_static_element_interactions -->
-<div class="mermaid-block" bind:this={boxEl} onkeydown={handleKeydown}>
+<div
+	class="mermaid-block"
+	bind:this={boxEl}
+	onkeydown={handleKeydown}
+	onfocusin={() => (gestureArmed = true)}
+	onfocusout={(e) => (gestureArmed = boxEl?.contains(e.relatedTarget as Node | null) ?? false)}
+>
 	{#if editing}
 		<textarea
 			bind:this={textareaEl}
@@ -330,6 +338,7 @@
 			<!-- svelte-ignore a11y_no_noninteractive_tabindex -->
 			<div
 				class="mermaid-viewport"
+				data-pointer-gesture={gestureArmed ? '' : undefined}
 				tabindex="0"
 				role="img"
 				aria-label="Mermaid diagram"
@@ -392,6 +401,7 @@
 			</div>
 			<div
 				class="mermaid-overlay-viewport"
+				data-pointer-gesture
 				onwheel={onOverlayWheel}
 				onpointerdown={(e) => {
 					e.stopPropagation();

package/dist/plugins/parrot/ParrotBlock.svelte

@@ -273,7 +273,9 @@ cNd.........................................;lOc
 		font-size: 1.1em;
 		line-height: 1.1;
 		letter-spacing: 0.05em;
-		/* one frame tall, in the reel's own rows so a step lands on the next frame exactly */
+		/* one frame tall, in the reel's own rows so a step lands on the next frame exactly; the
+		   em line is the same height for engines without lh (Safari before 16.4) */
+		height: calc(var(--parrot-rows) * 1.1em);
 		height: calc(var(--parrot-rows) * 1lh);
 		/* wider than a phone column, and the editor root pans if it isn't contained; the bar
 		   would sit across the bird, which is decoration rather than a pane to scroll */

package/dist/reactivity/list-windowing.svelte.js

@@ -43,7 +43,23 @@ export function createListWindowing(deps) {
     // structural rebuild needs the OLD ordering to remap the anchor by id, and by then
     // `getChildIds()` already reflects the new children. Copied — it is spliced in place.
     let modelChildIds = [];
-    function buildModel() {
+    /** What the CURRENT model holds, keyed by id, for a rebuild to carry across. The two lengths
+     *  diverge for one tick after a child change, and a slot past the model's end reads 0. */
+    function heightsById() {
+        const carried = new Map();
+        const known = Math.min(modelChildIds.length, model.size);
+        for (let i = 0; i < known; i++)
+            carried.set(modelChildIds[i], model.heightOf(i));
+        return carried;
+    }
+    /**
+     * A surviving block keeps the height the model measured (VR-15); `carried` is null only
+     * where a width or type-scale change has earned a reseed from the oracle. The cache behind
+     * those heights can be gone (a mode flip drops it, and a block whose box never moved reports
+     * no resize to put it back), so reseeding a structural rebuild would trade a whole document
+     * of measurements for estimates and scroll the reader by the difference.
+     */
+    function buildModel(carried) {
         const width = estimateWidth(deps.getListEl(), deps.getPort()?.contentWidth() ?? 0);
         const children = deps.getChildren();
         // Indexed, and off the snapshot: `map` pays a `has` trap beside every `get`, once per child.
@@ -51,11 +67,13 @@ export function createListWindowing(deps) {
         const count = children.length;
         const heights = new Array(count);
         for (let i = 0; i < count; i++) {
-            heights[i] = deps.oracle.height(modelChildIds[i], children[i], width);
+            const id = modelChildIds[i];
+            heights[i] =
+                deps.oracle.measured(id) ?? carried?.get(id) ?? deps.oracle.estimate(children[i], width);
         }
         return new HeightModel(heights);
     }
-    let model = $state(buildModel());
+    let model = $state(buildModel(null));
     let heightVersion = $state(0);
     // One scope-owned batched pass rather than a per-child effect, which would interleave a
     // layout read with the prior child's write → one forced reflow per mounted block on a
@@ -153,7 +171,7 @@ export function createListWindowing(deps) {
         mutate();
         const delta = model.offsetOf(anchorIndex) - before;
         if (delta !== 0 && port)
-            port.setScrollTop(port.scrollTop() + delta);
+            port.scrollBy(delta);
     }
     // The structural-rebuild variant of correctAnchor. A count change shifts every index
     // above it, so the numeric form would measure a DIFFERENT block at index N and mis-correct
@@ -182,7 +200,7 @@ export function createListWindowing(deps) {
             return;
         const delta = model.offsetOf(newIndex) - before;
         if (delta !== 0 && port)
-            port.setScrollTop(port.scrollTop() + delta);
+            port.scrollBy(delta);
     }
     let lastWidthVersion = deps.getWidthVersion();
     // Rebuild on any structural child change or an editor WIDTH change, never per keystroke.
@@ -202,8 +220,10 @@ export function createListWindowing(deps) {
             // the re-measure compares measured-before against all-estimate-after, and lands the
             // anchor a block off wherever the poisoned model names a different top child (#188).
             // Width only — re-measuring on a structural edit costs a reflow per split.
+            // Read off the OLD model, so the carry is taken before the rebuild replaces it.
+            const carried = widthChanged ? null : heightsById();
             correctAnchorByStableId(() => {
-                model = buildModel();
+                model = buildModel(carried);
                 heightVersion++;
                 if (widthChanged)
                     remeasureMounted();

package/dist/schema/commands.d.ts

@@ -19,10 +19,10 @@ export type GlobalCommandId = (typeof GLOBAL_COMMAND_IDS)[number];
 export type BlockCommandId = (typeof BLOCK_COMMAND_IDS)[number];
 export type CommandId = GlobalCommandId | BlockCommandId;
 /**
- * Commands whose arms rewrite one block's bytes around that block's own selection and have no
- * cross-block reading: the dispatch seam declines them outright while a range is painted.
- * Membership is the arm's shape, not the id's prefix — the link card mints its link over one
- * block's offsets, and a range gives it no one block to mint into.
+ * Commands whose arms rewrite one block and have no cross-block reading: the dispatch seam
+ * declines them outright while a range is painted. Membership is the arm's shape, not the id's
+ * prefix: the link card mints over one block's offsets and a heading level belongs to one block,
+ * so a range spanning blocks leaves neither of them a subject to act on.
  */
 export declare const RANGE_DECLINED_COMMAND_IDS: ReadonlySet<string>;
 /**
@@ -34,7 +34,9 @@ export declare const RANGE_DECLINED_COMMAND_IDS: ReadonlySet<string>;
 export declare const CROSS_BLOCK_RANGE_COMMAND_IDS: ReadonlySet<string>;
 /**
  * The command ids a host's selection toolbar invokes through `EditorInstance.runCommand`. The
- * rest of the vocabulary stays internal until the command registry unifies it.
+ * rest of the vocabulary stays internal until the command registry unifies it. Every id here
+ * answers the range question in one of the two sets above, so `canRunCommand` tells a bar which
+ * of its buttons a cross-block selection leaves nothing to act on.
  */
 export declare const TOOLBAR_COMMANDS: {
     readonly toggleStrong: "format.toggleStrong";
@@ -43,6 +45,8 @@ export declare const TOOLBAR_COMMANDS: {
     readonly toggleCode: "format.toggleCode";
     /** The link editor Mod+K opens: over a selection it creates, inside a link it edits. */
     readonly editLink: "link.openCard";
+    /** The heading picker's arm, taking the level as its argument; 0 is normal text. */
+    readonly setHeading: "heading.cycle";
 };
 /** Minimal context a global command needs; HistoryActions is structurally compatible. */
 export interface GlobalCommandContext {

package/dist/schema/commands.js

@@ -44,13 +44,14 @@ export const BLOCK_COMMAND_IDS = [
     'chrome.descendToBody'
 ];
 /**
- * Commands whose arms rewrite one block's bytes around that block's own selection and have no
- * cross-block reading: the dispatch seam declines them outright while a range is painted.
- * Membership is the arm's shape, not the id's prefix — the link card mints its link over one
- * block's offsets, and a range gives it no one block to mint into.
+ * Commands whose arms rewrite one block and have no cross-block reading: the dispatch seam
+ * declines them outright while a range is painted. Membership is the arm's shape, not the id's
+ * prefix: the link card mints over one block's offsets and a heading level belongs to one block,
+ * so a range spanning blocks leaves neither of them a subject to act on.
  */
 export const RANGE_DECLINED_COMMAND_IDS = new Set([
-    'link.openCard'
+    'link.openCard',
+    'heading.cycle'
 ]);
 /**
  * The same one-block arms, but with a cross-block one behind them
@@ -66,7 +67,9 @@ export const CROSS_BLOCK_RANGE_COMMAND_IDS = new Set([
 ]);
 /**
  * The command ids a host's selection toolbar invokes through `EditorInstance.runCommand`. The
- * rest of the vocabulary stays internal until the command registry unifies it.
+ * rest of the vocabulary stays internal until the command registry unifies it. Every id here
+ * answers the range question in one of the two sets above, so `canRunCommand` tells a bar which
+ * of its buttons a cross-block selection leaves nothing to act on.
  */
 export const TOOLBAR_COMMANDS = {
     toggleStrong: 'format.toggleStrong',
@@ -74,7 +77,9 @@ export const TOOLBAR_COMMANDS = {
     toggleStrikethrough: 'format.toggleStrikethrough',
     toggleCode: 'format.toggleCode',
     /** The link editor Mod+K opens: over a selection it creates, inside a link it edits. */
-    editLink: 'link.openCard'
+    editLink: 'link.openCard',
+    /** The heading picker's arm, taking the level as its argument; 0 is normal text. */
+    setHeading: 'heading.cycle'
 };
 const globalCommands = new Map();
 export function registerCommand(id, run) {

package/dist/schema/operations.d.ts

@@ -39,7 +39,7 @@ export interface OperationDetailMap {
         parentItemIdx?: number;
         nestedItemIdx?: number;
     } | {
-        source: 'paste-dispatch' | 'paste-dispatch-table-cell' | 'cross-block-covered-block';
+        source: 'paste-dispatch' | 'paste-dispatch-table-cell' | 'cross-block-covered-block' | 'selection-drop';
     };
     paste: {
         count: number;

package/dist/schema/reserved-chords.js

@@ -27,6 +27,18 @@ export const HARDCODED_CHORD_SITES = [
         keys: [],
         note: 'The Mod-held `data-mod-active` affordance tracks flag state only — no keystroke is consumed.'
     },
+    {
+        file: 'selection/selection-drop.ts',
+        chords: [],
+        keys: [],
+        note: 'Ctrl/Alt at the DROP is the platform copy modifier, read off a DragEvent — no keystroke is consumed.'
+    },
+    {
+        file: 'selection/multi-click.ts',
+        chords: [],
+        keys: [],
+        note: 'A modified multi-click is left to the browser (Shift extends, Mod activates) — no keystroke is consumed.'
+    },
     {
         file: 'components/GapCaret.svelte',
         chords: [],

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

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

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

@@ -5,18 +5,17 @@
  */
 import { tableCellCount } from '../table-endpoint-snap';
 import { CURSOR_END } from '../../block-component';
-import { normalizeLineEndings, terminateLine } from '../../core/lines';
+import { normalizeLineEndings } from '../../core/lines';
 import { performCrossBlockDelete } from './ops';
 import { charOffsetOf } from '../primitives';
 import { focusCollapsedCaret } from '../native-bridge';
 import { blockCoveredWhole } from '../covered-block';
 import { pasteDispatch } from '../../tree-operations/paste/dispatch';
 import { applyPasteTransforms } from '../../tree-operations/paste/paste-transforms';
-import { parse } from '../../core/parser';
 import { blockNodeAt, isBlockNode, nodeAt } from '../../tree-operations/node-primitives';
 import { pathsEqual } from '../path-math';
 import { replaceBlockAtParent } from '../../tree-operations/paste/replace-block-at-parent';
-import { ensureEditableContainers, normalizeReplacementTrivia } from '../../tree-operations';
+import { parseReplacement } from '../../tree-operations/paste/replacement-parse';
 import { emitClipboardError } from '../../editor-events';
 export async function handleCrossBlockPaste(ctx, mutCtx, e, replacement) {
     if (!ctx.selection.isCrossBlock)
@@ -130,24 +129,19 @@ async function replaceCoveredBlockWithPaste(ctx, mutCtx, pasted, 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. 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)
+    // ride here too; both rules live in the helper, applied at both sites.
+    const parsed = parseReplacement(covered, applyPasteTransforms(pasted, ctx.activePlugins), ctx.grammar);
+    if (!parsed)
         return;
-    const replacement = normalizeReplacementTrivia(covered, parsed.children);
-    for (const node of replacement)
-        ensureEditableContainers(node);
     mutCtx.pushUndoSnapshot();
     ctx.selection.collapse();
     await replaceBlockAtParent({
         doc,
         blockPath,
-        replacement,
+        replacement: parsed.replacement,
         controller: ctx.pasteCoordinator,
         undoEntry: 'join',
-        focusReplacementIndex: replacement.length - 1,
+        focusReplacementIndex: parsed.replacement.length - 1,
         focusOffset: CURSOR_END,
         source: 'cross-block-covered-block',
         ...(ctx.grammar ? { grammar: ctx.grammar } : {}),

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

@@ -10,10 +10,8 @@ import { performCrossBlockDelete } from './ops';
 import { charOffsetOf } from '../primitives';
 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 { parseReplacement } from '../../tree-operations/paste/replacement-parse';
 import { blockNodeAt, normalizeBodyWrite, writeOwnRaw } from '../../tree-operations/node-primitives';
 import { updateNodeContent, settledCaretTarget } from '../../tree-operations/content-write';
 import { focusCollapsedCaret } from '../native-bridge';
@@ -123,26 +121,18 @@ async function replaceCoveredBlockWithText(ctx, mutCtx, typed, blockPath) {
     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)
+    const parsed = parseReplacement(covered, typed, ctx.grammar);
+    if (!parsed)
         return;
-    const replacement = normalizeReplacementTrivia(covered, parsed.children);
-    for (const node of replacement)
-        ensureEditableContainers(node);
     mutCtx.pushUndoSnapshot();
     ctx.selection.collapse();
     await replaceBlockAtParent({
         doc,
         blockPath,
-        replacement,
+        replacement: parsed.replacement,
         controller: ctx.pasteCoordinator,
         undoEntry: 'join',
-        focusReplacementIndex: replacement.length - 1,
+        focusReplacementIndex: parsed.replacement.length - 1,
         focusOffset: CURSOR_END,
         source: 'cross-block-covered-block',
         ...(ctx.grammar ? { grammar: ctx.grammar } : {})

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

@@ -45,5 +45,8 @@ export interface DeadSpaceCaret {
      * whichever way the drag goes. A coordinate-addressed kind (a table) anchors nothing.
      */
     anchorAtPoint(root: HTMLElement, x: number, y: number): SelectionEndpoint | null;
+    /** The path of the block a press names, the point clamped into the nearest band: what the
+     *  click ladder selects in for a press on the margin or a block's own box. */
+    blockPathNearPoint(root: HTMLElement, x: number, y: number): number[] | null;
 }
 export declare function createDeadSpaceCaret(deps: DeadSpaceCaretDeps): DeadSpaceCaret;

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

@@ -88,7 +88,8 @@ export function createDeadSpaceCaret(deps) {
         leafOf(component, landing.path)?.snapCaretToPoint?.(probeX, probeY);
         return true;
     }
-    function anchorAtPoint(root, x, y) {
+    /** 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)
@@ -97,8 +98,13 @@ export function createDeadSpaceCaret(deps) {
             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 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
@@ -112,9 +118,13 @@ export function createDeadSpaceCaret(deps) {
             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) &&

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

@@ -7,6 +7,7 @@ import type { UserScrollport } from '../cursor/scroll-ancestors';
 import type { SelectionState } from './selection-state.svelte';
 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`). */
@@ -20,6 +21,24 @@ export interface DragContext {
      * 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: SelectionEndpoint, down: PointerEvent): {

package/dist/selection/drag-pointer.js

@@ -3,6 +3,7 @@
  * `createPointerDragSession`, whose document-level listeners deliver events even after the
  * pointer leaves the originating block.
  */
+import { caretOffsetAtPoint } from '../cursor/point-offset';
 import { applyCollapsedCaret, applySingleBlockRange, clearNativeSelection } from './native-bridge';
 import { isWholeBlockEndpoint } from './primitives';
 import { comparePaths } from './path-math';
@@ -18,6 +19,10 @@ 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)
@@ -48,6 +53,43 @@ export function installDragListener(ctx, anchorPoint, down) {
             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

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

@@ -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;