@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/selection/selection-state.svelte.js

@@ -1,34 +1,55 @@
 /**
- * Reactive state for the editor-owned selection modes: a cross-block `anchor`/`focus` pair,
- * and the collapsed `gapCaret` (`gap-caret.ts`). Both are null in single-block mode, where the
- * native browser selection rules, and the two are mutually exclusive here rather than at any
- * call site. Transitions: `docs/design/editor.md` § Cross-block selection.
+ * Reactive state for the selections the editor owns: a cross-block range, a gap caret
+ * (`gap-caret.ts`), or an inline widget selected whole. At most one is live, since every mutator
+ * writes all three through one private writer; all are null while the browser's own selection
+ * rules. Transitions: `docs/design/editor.md` § Cross-block selection.
  */
-import { nodeAt } from '../tree-operations/node-primitives';
+import { isBlockNode, nodeAt } from '../tree-operations/node-primitives';
 import { isWholeBlockEndpoint, normalize } from './primitives';
-import { cellEndpointDeepPath, normalizeTableEndpoint, snapCrossBlockTableEndpoints } from './table-endpoint-snap';
+import { cellEndpointDeepPath, normalizeTableEndpoint, snapCrossBlockTableEndpoints, wholeTableEndpoint } from './table-endpoint-snap';
 import { normalizeCharEndpoint } from './char-endpoint-snap';
-import { pathsEqual } from './path-math';
+import { comparePaths, pathsEqual } from './path-math';
 import { displayLength } from '../core/lines';
 import { assertInvariant } from '../assert';
 import { checkCrossBlockEndpointCoordinates } from '../invariants/selection-endpoints';
+import { isWholeBlockUnit } from '../schema/whole-block-unit';
 export function createSelectionState(options) {
     return new SelectionStateImpl(options);
 }
 // ── Implementation ──────────────────────────────────────────────────────────
+// Normalization flags both corners of a rectangle, so either flag names the pair's space.
+function isCellPair(a, f) {
+    return a.cellCoordinate === true || f.cellCoordinate === true;
+}
 class SelectionStateImpl {
+    // Separate cells, so a reader of one kind (the image overlay reads the widget) doesn't re-run
+    // on every write of another, such as each move of a drag.
     #anchor = $state(null);
     #focus = $state(null);
     #gapCaret = $state(null);
     #wholeUnit = $state(null);
+    #widget = $state(null);
     #selectAllCount = $state(0);
     #onChange;
     #getDoc;
+    #widgetSpan;
     #batchDepth = 0;
     #notifyPending = false;
+    // False once a notification that is not a caret placement joins the pending flush.
+    #placementOnly = true;
     constructor(options) {
         this.#onChange = options?.onChange;
         this.#getDoc = options?.getDoc;
+        this.#widgetSpan = options?.widgetSpan;
+    }
+    // The only writer of the five cells, so no mutator can set one kind without ending the others.
+    #claim(next) {
+        const range = next && 'range' in next ? next.range : null;
+        this.#anchor = range?.anchor ?? null;
+        this.#focus = range?.focus ?? null;
+        this.#wholeUnit = range?.wholeUnit ?? null;
+        this.#gapCaret = next && 'gap' in next ? next.gap : null;
+        this.#widget = next && 'widget' in next ? next.widget : null;
     }
     batch(mutate) {
         this.#batchDepth += 1;
@@ -39,16 +60,23 @@ class SelectionStateImpl {
             this.#batchDepth -= 1;
             if (this.#batchDepth === 0 && this.#notifyPending) {
                 this.#notifyPending = false;
-                this.#onChange?.();
+                this.#flush();
             }
         }
     }
-    #notify() {
+    #notify(fromPlacement = false) {
+        if (!fromPlacement)
+            this.#placementOnly = false;
         if (this.#batchDepth > 0) {
             this.#notifyPending = true;
             return;
         }
-        this.#onChange?.();
+        this.#flush();
+    }
+    #flush() {
+        const placementOnly = this.#placementOnly;
+        this.#placementOnly = true;
+        this.#onChange?.({ placementOnly });
     }
     get anchor() {
         return this.#anchor;
@@ -68,10 +96,27 @@ class SelectionStateImpl {
     get wholeUnitPath() {
         return this.#wholeUnit?.slice() ?? null;
     }
+    get widget() {
+        const widget = this.#widget;
+        return widget && copyWidget(widget);
+    }
+    widgetRange() {
+        const widget = this.#widget;
+        const span = widget && this.#widgetSpan?.(copyWidget(widget));
+        return widget && span
+            ? { path: widget.paragraphPath.slice(), start: span.start, end: span.end }
+            : null;
+    }
+    widgetCaret() {
+        const widget = this.#widget;
+        if (!widget)
+            return null;
+        const live = this.widgetRange();
+        const fromStart = widget.preSelectOffset === widget.sourceStart;
+        const offset = live ? (fromStart ? live.start : live.end) : widget.preSelectOffset;
+        return { path: widget.paragraphPath.slice(), offset };
+    }
     get isCustomRendered() {
-        const getDoc = this.#getDoc;
-        if (!getDoc)
-            return this.isCrossBlock;
         const anchor = this.#anchor;
         const focus = this.#focus;
         if (!anchor || !focus)
@@ -80,12 +125,8 @@ class SelectionStateImpl {
             return true;
         if (!pathsEqual(anchor.path, focus.path))
             return true;
-        if (anchor.offset === focus.offset)
-            return false;
-        const node = nodeAt(getDoc(), anchor.path);
-        if (!node)
-            return false;
-        return node.kind === 'table';
+        // A same-path pair is one cell (the browser's) or a rectangle of cells (the overlay's).
+        return anchor.offset !== focus.offset && isCellPair(anchor, focus);
     }
     get start() {
         return this.#normalizedSnapped()?.start ?? null;
@@ -108,34 +149,33 @@ class SelectionStateImpl {
         return this.#selectAllCount;
     }
     enterCrossBlock(anchor, focus) {
-        this.#gapCaret = null;
-        // Both ends the same surface-less block: the unit itself is the range, stored as its full
-        // byte span and flagged, since below a same-path pair is refused as prose.
+        // Both ends on one block with no text: the block is the range, stored as its full span
+        // (a table's first and last cell) and flagged whole, as a same-path pair is refused below.
         if (isWholeBlockEndpoint(anchor) &&
             isWholeBlockEndpoint(focus) &&
             pathsEqual(anchor.path, focus.path)) {
             const path = anchor.path.slice();
-            this.#anchor = { path, offset: 0 };
-            this.#focus = { path: path.slice(), offset: this.#byteLengthAt(path) };
-            this.#wholeUnit = path.slice();
+            const doc = this.#getDoc?.();
+            const a = (doc && wholeTableEndpoint(doc, path, 'start')) ?? { path, offset: 0 };
+            const f = (doc && wholeTableEndpoint(doc, path, 'end')) ?? {
+                path: path.slice(),
+                offset: this.#byteLengthAt(path)
+            };
+            this.#assertEndpointCoordinates(a, f);
+            this.#claim({ range: { anchor: a, focus: f, wholeUnit: path.slice() } });
             this.#notify();
             return;
         }
-        this.#wholeUnit = null;
         const a = this.#normalizePoint(anchor, focus.path);
         const f = this.#normalizePoint(focus, anchor.path);
-        // A same-path prose pair is a single-block range the browser owns; storing it mints an
-        // INVISIBLE cross-block state. Refuse it here so no entry path can. Intra-table rects
-        // share the table path but flag a cell coordinate, and the same-offset keyboard seed is
-        // kept so its immediate `extendFocus` has an anchor.
+        // A same-path text pair is a single-block range the browser owns, refused here where every
+        // entry path passes; a cell rectangle and the keyboard's equal-offset first pair are kept.
         if (this.#isSamePathProseRange(a, f)) {
-            this.#anchor = null;
-            this.#focus = null;
+            this.#claim(null);
         }
         else {
             this.#assertEndpointCoordinates(a, f);
-            this.#anchor = a;
-            this.#focus = f;
+            this.#claim({ range: { anchor: a, focus: f, wholeUnit: null } });
         }
         this.#notify();
     }
@@ -143,105 +183,105 @@ class SelectionStateImpl {
         if (!this.#anchor) {
             throw new Error('SelectionState.extendFocus called without an anchor');
         }
-        this.#gapCaret = null;
-        // Leaving a whole unit: its anchor is the block as a whole again, so the side it means
-        // (start below the new focus, end above it) is resolved afresh rather than kept at 0.
-        if (this.#wholeUnit) {
-            const unit = { path: this.#wholeUnit, wholeBlock: true };
-            this.#anchor = this.#normalizePoint(unit, point.path);
-            this.#wholeUnit = null;
-        }
-        const f = this.#normalizePoint(point, this.#anchor.path);
-        // A focus back on the anchor's prose leaf contracts to a single-block range. No
-        // `offset !== offset` guard, unlike #isSamePathProseRange: extendFocus never seeds, so
-        // landing exactly on the anchor offset is a collapse that must not be stored either.
-        if (pathsEqual(this.#anchor.path, f.path) &&
-            !this.#anchor.cellCoordinate &&
-            !f.cellCoordinate) {
-            this.#anchor = null;
-            this.#focus = null;
+        // Leaving a whole-block range: its anchor is the block as a whole again, so the side it
+        // means (start below the new focus, end above it) is resolved afresh rather than kept at 0.
+        const anchor = this.#wholeUnit
+            ? this.#normalizePoint({ path: this.#wholeUnit, wholeBlock: true }, point.path)
+            : this.#anchor;
+        const f = this.#normalizePoint(point, anchor.path);
+        // A focus back on the anchor's text leaf shrinks to a single-block range, even at the
+        // anchor's own offset: `extendFocus` never starts a pair, so landing there is a collapse.
+        if (pathsEqual(anchor.path, f.path) && !isCellPair(anchor, f)) {
+            this.#claim(null);
         }
         else {
-            this.#assertEndpointCoordinates(this.#anchor, f);
-            this.#focus = f;
+            this.#assertEndpointCoordinates(anchor, f);
+            this.#claim({ range: { anchor, focus: f, wholeUnit: null } });
         }
         this.#notify();
     }
-    // G1.29 at the storing seam, the belt behind #normalizePoint: both entries carry it because
-    // both store an endpoint pair.
     #byteLengthAt(path) {
         const doc = this.#getDoc?.();
         const node = doc ? nodeAt(doc, path) : null;
         return node && 'raw' in node ? displayLength(node.raw) : 0;
     }
+    // The endpoint coordinate check backs up `#normalizePoint` at every write of anchor and focus.
     #assertEndpointCoordinates(anchor, focus) {
         const getDoc = this.#getDoc;
         if (!getDoc)
             return;
         assertInvariant('cross-block-endpoint-coordinates', () => checkCrossBlockEndpointCoordinates(getDoc(), anchor, focus));
     }
-    // Same prose leaf, distinct offsets: the shape that must never enter cross-block state.
-    // Equal-offset pairs are excluded so the keyboard entry seed survives to its extend.
+    // Same text leaf, distinct offsets: the shape that must never enter cross-block state.
+    // Equal-offset pairs are excluded so the keyboard's starting pair survives to its extend.
     #isSamePathProseRange(a, f) {
-        return (pathsEqual(a.path, f.path) && !a.cellCoordinate && !f.cellCoordinate && a.offset !== f.offset);
+        return pathsEqual(a.path, f.path) && !isCellPair(a, f) && a.offset !== f.offset;
     }
-    // The funnel every entry path (keyboard, shift-click, drag, select-all, undo restore) goes
-    // through: a table endpoint can never be stored as a deep cell path with a char offset, and a
-    // char offset can never be stored outside the space its own block addresses (both funnels'
-    // headers). Never normalize at a call site instead. Idempotent; without a doc nothing can be
-    // measured, so points pass raw.
+    // The one place every entry path normalizes: a table endpoint becomes a flagged cell index and
+    // a character offset is clamped into its block. Without a document, points pass through.
     #normalizePoint(point, otherPath) {
         const getDoc = this.#getDoc;
         if (!getDoc) {
             return isWholeBlockEndpoint(point) ? { path: point.path.slice(), offset: 0 } : point;
         }
         const doc = getDoc();
-        if (isWholeBlockEndpoint(point))
-            return normalizeCharEndpoint(doc, point, otherPath);
+        if (isWholeBlockEndpoint(point)) {
+            const side = comparePaths(point.path, otherPath) > 0 ? 'end' : 'start';
+            return (wholeTableEndpoint(doc, point.path, side) ?? normalizeCharEndpoint(doc, point, otherPath));
+        }
         if (point.cellCoordinate)
             return point;
         const snapped = normalizeTableEndpoint(doc, point.path, point.offset);
         return snapped.cellCoordinate ? snapped : normalizeCharEndpoint(doc, snapped, otherPath);
     }
     collapse() {
-        if (!this.#hasCaretClaim())
-            return;
-        this.#anchor = null;
-        this.#focus = null;
-        this.#gapCaret = null;
-        this.#wholeUnit = null;
-        this.#notify();
+        const announce = this.#hasCaretClaim();
+        this.#claim(null);
+        if (announce)
+            this.#notify();
+    }
+    dropForDocumentSwap() {
+        this.#claim(null);
     }
     clear() {
-        if (!this.#hasCaretClaim() && this.#selectAllCount === 0)
-            return;
-        this.#anchor = null;
-        this.#focus = null;
-        this.#gapCaret = null;
-        this.#wholeUnit = null;
+        const announce = this.#hasCaretClaim() || this.#selectAllCount !== 0;
+        this.#claim(null);
         this.#selectAllCount = 0;
-        this.#notify();
+        if (announce)
+            this.#notify();
     }
-    // Every field the two clears zero: a guard reading fewer of them would swallow the
-    // notification for the ones it does not see.
+    // A range or a gap caret: what the clears announce ending. A widget is left out, since the
+    // caret that replaces it announces itself.
     #hasCaretClaim() {
         return this.#anchor !== null || this.#focus !== null || this.#gapCaret !== null;
     }
-    // The mutual exclusion's other half: a gap and a range are never live together, and the
-    // copy is what keeps a caller's own position object from writing through.
+    // The copy keeps a caller's own position object from writing through.
     setGapCaret(pos) {
-        this.#anchor = null;
-        this.#focus = null;
-        this.#wholeUnit = null;
-        this.#gapCaret = { parentPath: pos.parentPath.slice(), index: pos.index };
+        this.#claim({ gap: { parentPath: pos.parentPath.slice(), index: pos.index } });
         this.#notify();
     }
     clearGapCaret() {
         if (this.#gapCaret === null)
             return;
-        this.#gapCaret = null;
+        this.#claim(null);
+        this.#notify();
+    }
+    selectWidget(target) {
+        this.#claim({ widget: copyWidget(target) });
         this.#notify();
     }
+    followWidgetEdit(path, editEnd, delta) {
+        const widget = this.#widget;
+        if (!widget || widget.sourceStart < editEnd || !pathsEqual(widget.paragraphPath, path))
+            return;
+        this.#claim({
+            widget: {
+                paragraphPath: widget.paragraphPath.slice(),
+                sourceStart: widget.sourceStart + delta,
+                preSelectOffset: widget.preSelectOffset + delta
+            }
+        });
+    }
     incrementSelectAllCount() {
         this.#selectAllCount += 1;
         this.#notify();
@@ -251,22 +291,16 @@ class SelectionStateImpl {
             return 'custom';
         if (anchor.offset === focus.offset)
             return 'collapsed';
-        // Same path, distinct offsets: a table cell rect (flagged endpoint, or a table node
-        // under the shared path) paints via the overlay; prose is a native range.
-        if (anchor.cellCoordinate || focus.cellCoordinate)
+        if (isCellPair(anchor, focus))
             return 'custom';
-        const getDoc = this.#getDoc;
-        if (!getDoc)
-            return 'single-block';
-        const node = nodeAt(getDoc(), anchor.path);
-        return node?.kind === 'table' ? 'custom' : 'single-block';
+        const doc = this.#getDoc?.();
+        const node = doc ? nodeAt(doc, anchor.path) : null;
+        return node && isBlockNode(node) && isWholeBlockUnit(node) ? 'whole-block' : 'single-block';
     }
     cellLandingFor(point) {
         const getDoc = this.#getDoc;
         if (!getDoc)
             return point;
-        // Resolution is the door's, on the node kind: a context-established intra-table endpoint
-        // is unflagged and still a cell index, and a non-table path answers null.
         const deepPath = cellEndpointDeepPath(getDoc(), point);
         return deepPath ? { path: deepPath, offset: 0 } : point;
     }
@@ -279,4 +313,16 @@ class SelectionStateImpl {
     announceSelection() {
         this.#notify();
     }
+    announcePlacement() {
+        this.#notify(true);
+    }
+}
+// Copied at both ends, as the gap caret is: neither a caller's object nor a reader's copy can
+// write the stored widget without a notification.
+function copyWidget(target) {
+    return {
+        paragraphPath: target.paragraphPath.slice(),
+        sourceStart: target.sourceStart,
+        preSelectOffset: target.preSelectOffset
+    };
 }

package/dist/selection/shared-keydown.d.ts

@@ -1,34 +1,37 @@
 /**
  * Shared keydown prelude for contenteditable blocks: Ctrl+A counter, cross-block dispatch,
- * sticky-column capture/reset, undo/redo, arrow boundary navigation. Block-specific handlers
+ * the caret memory's key note, undo/redo, arrow boundary navigation. Block-specific handlers
  * (Enter, Backspace, Tab, formatting) stay in each component.
  */
 import type { FocusActions, HistoryActions } from '../action-contracts';
-import type { BlockElLookup, DocumentGetter } from '../editor-keys';
-import type { StickyColumnState } from '../cursor/sticky-column';
-import type { EdgeAffinityState } from '../cursor/edge-affinity';
+import type { DocumentGetter } from '../editor-keys';
+import type { CaretMemory } from '../cursor/caret-memory';
+import type { ScrollOwner } from '../cursor/scroll-owner';
 import type { SelectionState } from './selection-state.svelte';
 import type { CrossBlockHandlers } from './cross-block/dispatch';
-import type { PluginActivation } from '../schema/plugin-activation';
+import type { CommandDispatchContext } from '../schema/block-commands';
+import type { Reading } from '../schema/reading';
 export interface SharedKeydownContext extends LandableBoundsContext {
     getEl(): HTMLElement | null;
-    /** Current caret offset in raw-content coordinates (ambient marker excluded). */
+    /** Current caret offset in raw-content coordinates (the container's marker prefix excluded). */
     getCursorOffset(): number | null;
-    /** Shift-selection focus offset in raw-content coordinates (ambient marker excluded). */
+    /** Shift-selection focus offset in raw-content coordinates (the marker prefix excluded). */
     getFocusOffset(): number | null;
     getIndex(): number;
     getMyPath(): number[];
     getDoc: DocumentGetter;
     crossBlock: CrossBlockHandlers;
     selection: SelectionState;
-    stickyColumn: StickyColumnState;
-    edgeAffinity: EdgeAffinityState;
+    caretMemory: CaretMemory;
     history: HistoryActions;
     focus: FocusActions;
-    getBlockElByPath: BlockElLookup;
-    /** The plugins this instance activated; without it the suppression below swallows a
-     *  chord another editor's plugin claimed. `undefined` = every installed plugin. */
-    activePlugins: PluginActivation | undefined;
+    /** Brings the block a Shift+Arrow extends into to the nearest edge. */
+    scrollOwner: Pick<ScrollOwner, 'place'>;
+    /** The editor's command dispatch: the caret memory reads a chord by its current binding, and
+     *  the history suppression below takes only this editor's plugin chords. */
+    commands: CommandDispatchContext;
+    /** How the editor reads its bytes, whose grammar the vertical extension skips leaves by. */
+    reading: Reading;
 }
 /** True when the event was fully handled; the caller must skip its block-specific branches. */
 export declare function handleSharedKeydown(e: KeyboardEvent, ctx: SharedKeydownContext): Promise<boolean>;
@@ -36,25 +39,17 @@ export interface LandableBounds {
     start: number;
     end: number;
 }
-/** The reads the bounds need, so a block-edge gate outside this file can ask without standing up
+/** The reads the bounds need, so a block-edge check outside this file can ask without building
  *  the whole keydown context. */
 export interface LandableBoundsContext {
-    /** textContent length in raw-content coordinates (ambient marker excluded). */
+    /** textContent length in raw-content coordinates (the marker prefix excluded). */
     getTextLen(): number;
-    getAmbientLength(): number;
 }
-/**
- * The raw offsets a caret can actually reach in this block, from the walk that decides where a
- * caret lands. A mode that hides a block's own markers with no reveal puts those bytes out of
- * reach, so the exits move in to what the DOM can land — the kind's declared content range is
- * not that bound: paragraph, fenced code and table cell each declare the whole raw and still
- * open or close with a run nothing paints. Every block-edge gate reads this, not 0/length.
- */
+/** The raw offsets a caret can reach in the block, from the same walk that places it: hidden
+ *  markers put bytes out of reach, so every block-edge check reads this, not 0 and length. */
 export declare function caretLandableBounds(ctx: LandableBoundsContext, el: HTMLElement): LandableBounds;
-/**
- * Routes historyUndo/historyRedo through the undo controller and delegates cross-block
- * paste/type-replace. True when the caller should return early from its own `onBeforeInput`.
- */
+/** Routes historyUndo/historyRedo through the undo controller and delegates cross-block paste
+ *  and typing; true when the caller should return early from its own `onBeforeInput`. */
 export declare function handleSharedBeforeInput(e: InputEvent, ctx: {
     history: HistoryActions;
     crossBlock: CrossBlockHandlers;

package/dist/selection/shared-keydown.js

@@ -1,41 +1,29 @@
 /**
  * Shared keydown prelude for contenteditable blocks: Ctrl+A counter, cross-block dispatch,
- * sticky-column capture/reset, undo/redo, arrow boundary navigation. Block-specific handlers
+ * the caret memory's key note, undo/redo, arrow boundary navigation. Block-specific handlers
  * (Enter, Backspace, Tab, formatting) stay in each component.
  */
+import { commandAtBlock } from './cross-block/keydown';
 import { extendFocusToNextBlock, extendFocusToPreviousBlock, scrollFocusBlockIntoView } from './keyboard-extend';
 import { getCurrentCursorEditorRelativeX } from '../cursor/sticky-measure';
 import { landableRawBounds } from '../cursor/widget-offset';
 import { isAtFirstVisualLine, isAtLastVisualLine } from '../cursor/visual-lines';
-import { eventToChord } from '../schema/keybindings';
+import { endsSelectAllRun, eventToChord } from '../schema/keybindings';
 import { isDefaultGlobalChord } from '../schema/commands';
 /** True when the event was fully handled; the caller must skip its block-specific branches. */
 export async function handleSharedKeydown(e, ctx) {
-    // Bare modifier keys don't reset the Ctrl+A doubling counter: pressing Control before 'a' is
-    // part of the chord, not a separate action.
-    const isCtrlA = (e.ctrlKey || e.metaKey) && e.key === 'a' && !e.shiftKey;
-    const isBareModifier = e.key === 'Control' ||
-        e.key === 'Shift' ||
-        e.key === 'Alt' ||
-        e.key === 'Meta' ||
-        e.key === 'AltGraph' ||
-        e.key === 'CapsLock';
-    if (!isCtrlA && !isBareModifier) {
+    if (endsSelectAllRun(e))
         ctx.selection.resetSelectAllCount();
-    }
     if (await ctx.crossBlock.handleKeyDown(e))
         return true;
     const el = ctx.getEl();
     if (!el)
         return false;
-    ctx.stickyColumn.noteKey(e, () => getCurrentCursorEditorRelativeX(el));
-    ctx.edgeAffinity.note(e);
-    // Native contenteditable history stays suppressed on keydown, since Ctrl+Y doesn't fire
-    // beforeinput historyRedo in Chromium/WebView2. The DEFAULT table is the right question here:
-    // it names the chords with a native history default, and running the command is the block's
-    // own override-aware dispatch, one branch further on.
+    ctx.caretMemory.noteKey(e, commandAtBlock(e, ctx), () => getCurrentCursorEditorRelativeX(el));
+    // Ctrl+Y fires no `historyRedo` beforeinput in Chromium and WebView2, so every chord with a
+    // native history default is suppressed here; the block's own dispatch runs the command.
     const historyChord = eventToChord(e);
-    if (historyChord && isDefaultGlobalChord(historyChord, ctx.activePlugins)) {
+    if (historyChord && isDefaultGlobalChord(historyChord, ctx.commands.activation)) {
         e.preventDefault();
         return false;
     }
@@ -51,13 +39,13 @@ export async function handleSharedKeydown(e, ctx) {
     const shiftOffset = e.shiftKey ? ctx.getFocusOffset() : null;
     if (e.key === 'ArrowUp') {
         const offset = shiftOffset ?? ctx.getCursorOffset() ?? 0;
-        if (isAtFirstVisualLine(el, offset, bounds().start)) {
+        if (isAtFirstVisualLine(el, offset, bounds())) {
             // Cross the boundary only when focus is already at the block's first reachable
             // offset, so native Shift+ArrowUp extension has nowhere left to go within it.
             if (e.shiftKey && offset <= bounds().start) {
                 e.preventDefault();
-                extendFocusToPreviousBlock(ctx.selection, ctx.getDoc(), el, myPath, 'start');
-                scrollFocusBlockIntoView(ctx.selection, ctx.getBlockElByPath);
+                extendFocusToPreviousBlock(ctx.selection, ctx.getDoc(), ctx.reading.grammar, el, myPath, 'start');
+                scrollFocusBlockIntoView(ctx.selection, ctx.scrollOwner);
                 return true;
             }
             if (!e.shiftKey && !e.altKey) {
@@ -69,13 +57,13 @@ export async function handleSharedKeydown(e, ctx) {
     }
     if (e.key === 'ArrowDown') {
         const offset = shiftOffset ?? ctx.getCursorOffset() ?? 0;
-        if (isAtLastVisualLine(el, offset, bounds().end)) {
+        if (isAtLastVisualLine(el, offset, bounds())) {
             // Cross the boundary only when focus is already at the block's last reachable
             // offset, so native Shift+ArrowDown extension has nowhere left to go.
             if (e.shiftKey && offset >= bounds().end) {
                 e.preventDefault();
-                extendFocusToNextBlock(ctx.selection, ctx.getDoc(), el, myPath, 'vertical');
-                scrollFocusBlockIntoView(ctx.selection, ctx.getBlockElByPath);
+                extendFocusToNextBlock(ctx.selection, ctx.getDoc(), ctx.reading.grammar, el, myPath, 'vertical');
+                scrollFocusBlockIntoView(ctx.selection, ctx.scrollOwner);
                 return true;
             }
             if (!e.shiftKey && !e.altKey) {
@@ -86,15 +74,14 @@ export async function handleSharedKeydown(e, ctx) {
         }
     }
     if (e.key === 'ArrowLeft') {
-        // Shift+Arrow reads focus, not anchor: getCursorOffset() gives the range start, which is
-        // the anchor for a forward selection. That would extend cross-block while focus is
-        // contracting toward a non-zero anchor, and misfire for backward selections.
+        // Shift+Arrow reads the focus, since `getCursorOffset()` gives the range start: the anchor
+        // of a forward selection, which would extend across blocks while the focus contracts.
         const offset = e.shiftKey ? (ctx.getFocusOffset() ?? bounds().start) : ctx.getCursorOffset();
         if (offset !== null && offset <= bounds().start) {
             if (e.shiftKey) {
                 e.preventDefault();
-                extendFocusToPreviousBlock(ctx.selection, ctx.getDoc(), el, myPath);
-                scrollFocusBlockIntoView(ctx.selection, ctx.getBlockElByPath);
+                extendFocusToPreviousBlock(ctx.selection, ctx.getDoc(), ctx.reading.grammar, el, myPath);
+                scrollFocusBlockIntoView(ctx.selection, ctx.scrollOwner);
                 return true;
             }
             e.preventDefault();
@@ -107,8 +94,8 @@ export async function handleSharedKeydown(e, ctx) {
         if (offset !== null && offset >= bounds().end) {
             if (e.shiftKey) {
                 e.preventDefault();
-                extendFocusToNextBlock(ctx.selection, ctx.getDoc(), el, myPath);
-                scrollFocusBlockIntoView(ctx.selection, ctx.getBlockElByPath);
+                extendFocusToNextBlock(ctx.selection, ctx.getDoc(), ctx.reading.grammar, el, myPath);
+                scrollFocusBlockIntoView(ctx.selection, ctx.scrollOwner);
                 return true;
             }
             e.preventDefault();
@@ -118,21 +105,14 @@ export async function handleSharedKeydown(e, ctx) {
     }
     return false;
 }
-/**
- * The raw offsets a caret can actually reach in this block, from the walk that decides where a
- * caret lands. A mode that hides a block's own markers with no reveal puts those bytes out of
- * reach, so the exits move in to what the DOM can land — the kind's declared content range is
- * not that bound: paragraph, fenced code and table cell each declare the whole raw and still
- * open or close with a run nothing paints. Every block-edge gate reads this, not 0/length.
- */
+/** The raw offsets a caret can reach in the block, from the same walk that places it: hidden
+ *  markers put bytes out of reach, so every block-edge check reads this, not 0 and length. */
 export function caretLandableBounds(ctx, el) {
-    return landableRawBounds(el, ctx.getAmbientLength()) ?? { start: 0, end: ctx.getTextLen() };
+    return landableRawBounds(el) ?? { start: 0, end: ctx.getTextLen() };
 }
 // ── Shared beforeinput prelude ─────────────────────────────────────────────
-/**
- * Routes historyUndo/historyRedo through the undo controller and delegates cross-block
- * paste/type-replace. True when the caller should return early from its own `onBeforeInput`.
- */
+/** Routes historyUndo/historyRedo through the undo controller and delegates cross-block paste
+ *  and typing; true when the caller should return early from its own `onBeforeInput`. */
 export async function handleSharedBeforeInput(e, ctx) {
     if (e.inputType === 'historyUndo') {
         e.preventDefault();