@voithos-labs/aragonite 0.10.1

package/dist/cursor/scroll-ancestors.js

@@ -0,0 +1,89 @@
+/**
+ * "What scrolls" and "what clips" are two walks, never one: SCROLLING asks for
+ * `auto`/`scroll` and stops at the first answer, CLIPPING asks for anything that bounds
+ * the visible region and collects the whole chain, since visibility is their intersection.
+ * An `overflow: hidden` auto-height card matches a clipping predicate while doing neither.
+ * `selection/drag-pointer.ts` keeps its own inner walk, so a change here is not one to it.
+ */
+// Scrollable through script — `element.scrollTop = n` moves it. `hidden` qualifies.
+const SCRIPT_SCROLLABLE_VALUES = new Set(['auto', 'scroll', 'hidden']);
+// Scrollable by the USER, which is what a drag may autoscroll. `hidden` is excluded by
+// convention, not capability: a user cannot wheel it back, so autoscrolling it would
+// strand content out of reach.
+const USER_SCROLLABLE_VALUES = new Set(['auto', 'scroll']);
+// What can bound the visible region. `clip` joins here and only here — it never scrolls,
+// so it is no autoscroll answer, but a block past its edge is unreachable.
+const VIEW_BOUNDING_VALUES = new Set([...SCRIPT_SCROLLABLE_VALUES, 'clip']);
+function isScriptScrollable(el) {
+    const cs = getComputedStyle(el);
+    return SCRIPT_SCROLLABLE_VALUES.has(cs.overflowX) || SCRIPT_SCROLLABLE_VALUES.has(cs.overflowY);
+}
+// Never a candidate in either walk: when the page box IS the scrollport, the window
+// viewport is the rect to measure and the thing to scroll, and neither box is that rect.
+function isPageBox(el) {
+    return el === document.body || el === document.documentElement;
+}
+export function nearestScrollContainer(el, stopAt) {
+    let cur = el.parentElement;
+    while (cur && cur !== stopAt) {
+        if (isScriptScrollable(cur))
+            return cur;
+        cur = cur.parentElement;
+    }
+    return null;
+}
+/**
+ * What a drag autoscrolls to bring more of `el` into reach: the nearest user-scrollable
+ * ancestor, or the window when the page's own viewport is the scrollport. Total on
+ * purpose — a null for the page-scrolled case reads as "no autoscroll targets", and
+ * `document.scrollingElement` is no substitute (its rect is the document box).
+ */
+export function userScrollportFor(el) {
+    let cur = el.parentElement;
+    while (cur && !isPageBox(cur)) {
+        const cs = getComputedStyle(cur);
+        if (USER_SCROLLABLE_VALUES.has(cs.overflowX) || USER_SCROLLABLE_VALUES.has(cs.overflowY)) {
+            return cur;
+        }
+        cur = cur.parentElement;
+    }
+    return window;
+}
+/**
+ * Every ancestor that bounds what can be seen of `el`, outermost-last. The whole chain,
+ * not the nearest: only the intersection answers "is this visible", and the innermost
+ * match alone can be a rounded card that bounds nothing. Callers intersect the window
+ * viewport with these; an empty result means the window alone bounds it.
+ */
+export function clippingAncestors(el) {
+    const bounds = [];
+    let cur = el.parentElement;
+    while (cur && !isPageBox(cur)) {
+        const cs = getComputedStyle(cur);
+        if (VIEW_BOUNDING_VALUES.has(cs.overflowX) || VIEW_BOUNDING_VALUES.has(cs.overflowY)) {
+            bounds.push(cur);
+        }
+        cur = cur.parentElement;
+    }
+    return bounds;
+}
+/** First scrollable descendant of `el` in document order. A block-host wrapper sits
+ *  OUTSIDE a block's internal scroll container, so finding what scrolls beneath the host
+ *  means looking inward, not up. */
+export function firstScrollableDescendant(el) {
+    const queue = [];
+    for (const child of el.children) {
+        if (child instanceof HTMLElement)
+            queue.push(child);
+    }
+    while (queue.length > 0) {
+        const cur = queue.shift();
+        if (isScriptScrollable(cur))
+            return cur;
+        for (const child of cur.children) {
+            if (child instanceof HTMLElement)
+                queue.push(child);
+        }
+    }
+    return null;
+}

package/dist/cursor/scrollport.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The scroll container windowing measures and writes, as one shape whatever owns the scroll:
+ * the editor root under `scrollMode="self"`, the ancestor `userScrollportFor` resolves (or the
+ * page viewport) under `"host"`. One implementation reads this; the mode only picks the target.
+ * See `docs/design/virtual-rendering.md`.
+ */
+import type { UserScrollport } from './scroll-ancestors';
+export interface Scrollport {
+    /** Client-coordinate top of the visible box — 0 when the page viewport is the port. Paired
+     *  with a block's own client rect, it maps that block into the port's content space. */
+    viewportTop(): number;
+    viewportHeight(): number;
+    /** Width available to content, for the height oracle's line-wrap estimates. */
+    contentWidth(): number;
+    scrollTop(): number;
+    setScrollTop(value: number): void;
+    /** Fires on user and programmatic scrolls alike; returns the unsubscribe. */
+    subscribe(onScroll: () => void): () => void;
+}
+export declare function createScrollport(target: UserScrollport): Scrollport;

package/dist/cursor/scrollport.js

@@ -0,0 +1,41 @@
+export function createScrollport(target) {
+    return target === window ? pageScrollport() : elementScrollport(target);
+}
+// ── Internal ───────────────────────────────────────────────────────────────
+function elementScrollport(el) {
+    return {
+        viewportTop: () => el.getBoundingClientRect().top,
+        viewportHeight: () => el.clientHeight,
+        contentWidth: () => el.clientWidth,
+        scrollTop: () => el.scrollTop,
+        setScrollTop: (value) => {
+            el.scrollTop = value;
+        },
+        subscribe(onScroll) {
+            el.addEventListener('scroll', onScroll, { passive: true });
+            return () => el.removeEventListener('scroll', onScroll);
+        }
+    };
+}
+/** The page's own viewport. Measure and write come from different places on purpose, the split
+ *  `selection/autoscroll.ts` makes: the viewport is the box the fold belongs to, whereas
+ *  `document.scrollingElement` — whose box is the whole multi-thousand-pixel document — is the
+ *  only thing that moves. */
+function pageScrollport() {
+    const scroller = () => document.scrollingElement;
+    return {
+        viewportTop: () => 0,
+        viewportHeight: () => document.documentElement.clientHeight,
+        contentWidth: () => document.documentElement.clientWidth,
+        scrollTop: () => scroller()?.scrollTop ?? 0,
+        setScrollTop: (value) => {
+            const el = scroller();
+            if (el)
+                el.scrollTop = value;
+        },
+        subscribe(onScroll) {
+            window.addEventListener('scroll', onScroll, { passive: true });
+            return () => window.removeEventListener('scroll', onScroll);
+        }
+    };
+}

package/dist/cursor/sticky-column.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Sticky column: the editor-relative pixel X that survives repeated vertical arrows and
+ * intermediate clamping. Two-axis contract for `focusAtColumn` surfaces. CAPTURE: the focused
+ * block records X before any cross-block transition, via `noteKey` (G2.10). CONSUME: landings
+ * route through `consumeStickyLanding` (`editor-actions/focus/focus-landing.ts`), which null-checks
+ * and falls back, so `focusAtColumn` is a pure receiver whose x is always finite.
+ */
+import type { EditorX } from './coordinate-spaces';
+export interface StickyColumnState {
+    get(): EditorX | null;
+    /** Idempotent — the no-op-when-set is what preserves the original intent through
+     *  within-block clamping. Non-finite input is ignored. */
+    capture(x: EditorX): void;
+    reset(): void;
+    /**
+     * The only door a keydown handler may use; `reset()` stays public for the lifecycle,
+     * commit, undo and paste callers, whose unconditional clear has no key to classify.
+     * `measureX` is consulted only on the capture branch and only the caller can supply it
+     * (the X comes from the live caret) — a caller holding a range rather than a caret
+     * omits it, and a capture key then PRESERVES the column rather than clearing it.
+     */
+    noteKey(e: Pick<KeyboardEvent, 'key' | 'altKey'>, measureX?: () => EditorX | null): void;
+}
+export declare function createStickyColumnState(): StickyColumnState;
+/**
+ * Keys that neither capture nor reset; every key not here and not a vertical arrow resets.
+ * Bare modifiers are read from the chord parser rather than re-listed — a local copy
+ * missing AltGraph/CapsLock is how a modifier tap mid-arrow-run dropped the column.
+ */
+export declare const PRESERVE_KEYS_NON_ARROW: readonly string[];
+/** What a keydown does to sticky column, decided purely from `e.key`. */
+export type StickyKeyAction = 'capture' | 'reset' | 'preserve';
+/** The decision {@link StickyColumnState.noteKey} enacts. Pure on the key, so the matrix is
+ *  testable without a DOM or a state instance. */
+export declare function classifyStickyKey(key: string): StickyKeyAction;

package/dist/cursor/sticky-column.js

@@ -0,0 +1,64 @@
+/**
+ * Sticky column: the editor-relative pixel X that survives repeated vertical arrows and
+ * intermediate clamping. Two-axis contract for `focusAtColumn` surfaces. CAPTURE: the focused
+ * block records X before any cross-block transition, via `noteKey` (G2.10). CONSUME: landings
+ * route through `consumeStickyLanding` (`editor-actions/focus/focus-landing.ts`), which null-checks
+ * and falls back, so `focusAtColumn` is a pure receiver whose x is always finite.
+ */
+import { isInteractionTraceEnabled, traceStickyCapture, traceStickyReset } from '../debug/interaction-trace';
+import { BARE_MODIFIER_KEYS } from '../schema/keybindings';
+export function createStickyColumnState() {
+    let stickyX = null;
+    const state = {
+        get: () => stickyX,
+        capture: (x) => {
+            if (stickyX !== null)
+                return;
+            if (!Number.isFinite(x))
+                return;
+            stickyX = x;
+            traceStickyCapture(x);
+        },
+        // Reset fires on nearly every keystroke, so the enabled gate short-circuits first.
+        reset: () => {
+            if (isInteractionTraceEnabled() && stickyX !== null)
+                traceStickyReset();
+            stickyX = null;
+        },
+        noteKey: (e, measureX) => {
+            // Alt+Arrow is the block-reorder chord, not caret nav.
+            if (e.altKey && (e.key === 'ArrowUp' || e.key === 'ArrowDown'))
+                return;
+            const action = classifyStickyKey(e.key);
+            if (action === 'reset') {
+                state.reset();
+                return;
+            }
+            if (action !== 'capture')
+                return;
+            const x = measureX?.();
+            if (x !== null && x !== undefined)
+                state.capture(x);
+        }
+    };
+    return state;
+}
+/**
+ * Keys that neither capture nor reset; every key not here and not a vertical arrow resets.
+ * Bare modifiers are read from the chord parser rather than re-listed — a local copy
+ * missing AltGraph/CapsLock is how a modifier tap mid-arrow-run dropped the column.
+ */
+export const PRESERVE_KEYS_NON_ARROW = [
+    'PageUp',
+    'PageDown',
+    ...BARE_MODIFIER_KEYS
+];
+/** The decision {@link StickyColumnState.noteKey} enacts. Pure on the key, so the matrix is
+ *  testable without a DOM or a state instance. */
+export function classifyStickyKey(key) {
+    if (key === 'ArrowUp' || key === 'ArrowDown')
+        return 'capture';
+    if (PRESERVE_KEYS_NON_ARROW.includes(key))
+        return 'preserve';
+    return 'reset';
+}

package/dist/cursor/sticky-measure.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Pixel-X measurement for sticky column tracking. Coordinates are editor-relative, so
+ * values are invariant to vertical scrolling inside the editor.
+ */
+import type { StickyColumnDirection } from '../block-component';
+import { type DomTextOffset, type EditorX } from './coordinate-spaces';
+export declare function getCurrentCursorEditorRelativeX(el: HTMLElement): EditorX | null;
+export declare function getOffsetRect(container: HTMLElement, offset: DomTextOffset): DOMRect | null;
+/**
+ * Offset on the first or last caret-bearing visual line whose collapsed-range rect is
+ * closest to `editorRelativeX`. Linear scan — `getClientRects` left values are
+ * non-monotonic on BiDi lines, so binary search is invalid. Widget-only lines are
+ * transparent (their collapsed ranges return null rects); `minOffset` excludes the
+ * ambient-marker prefix.
+ */
+export declare function findOffsetNearestX(container: HTMLElement, editorRelativeX: EditorX, from: StickyColumnDirection, minOffset?: DomTextOffset): DomTextOffset;

package/dist/cursor/sticky-measure.js

@@ -0,0 +1,97 @@
+/**
+ * Pixel-X measurement for sticky column tracking. Coordinates are editor-relative, so
+ * values are invariant to vertical scrolling inside the editor.
+ */
+import { asDomTextOffset, asViewportX, toEditorX, toViewportX } from './coordinate-spaces';
+import { containerDomTextLength, findDomTextOffsetTarget } from './widget-offset';
+import { firstUsefulRect } from './visual-lines';
+// Half a line height of padding on each side of the probe line — wide enough for
+// ascender/descender variation, narrow enough to exclude the neighbouring line.
+const LINE_BAND_TOLERANCE = 0.5;
+export function getCurrentCursorEditorRelativeX(el) {
+    const sel = window.getSelection();
+    if (!sel || sel.rangeCount === 0)
+        return null;
+    const range = sel.getRangeAt(0);
+    const rect = firstUsefulRect(range);
+    const viewportX = asViewportX(rect ? rect.left : el.getBoundingClientRect().left);
+    return toEditorX(viewportX, editorLeftOf(el));
+}
+export function getOffsetRect(container, offset) {
+    const pos = findDomTextOffsetTarget(container, offset);
+    if (!pos)
+        return null;
+    const range = document.createRange();
+    try {
+        range.setStart(pos.node, pos.offset);
+    }
+    catch {
+        return null;
+    }
+    range.collapse(true);
+    return firstUsefulRect(range);
+}
+/**
+ * Offset on the first or last caret-bearing visual line whose collapsed-range rect is
+ * closest to `editorRelativeX`. Linear scan — `getClientRects` left values are
+ * non-monotonic on BiDi lines, so binary search is invalid. Widget-only lines are
+ * transparent (their collapsed ranges return null rects); `minOffset` excludes the
+ * ambient-marker prefix.
+ */
+export function findOffsetNearestX(container, editorRelativeX, from, minOffset = asDomTextOffset(0)) {
+    const totalLen = containerDomTextLength(container);
+    if (totalLen <= minOffset)
+        return minOffset;
+    const targetViewportX = toViewportX(editorRelativeX, editorLeftOf(container));
+    // Only offsets near the probed edge can be the answer, so walk inward and stop a few
+    // lines past it: the band filter below discards anything further regardless, making
+    // this identical to a full scan at O(lines-near-edge) instead of O(raw length).
+    const forward = from === 'above';
+    const STOP_AFTER_LINES = 3;
+    const candidates = [];
+    // The probed edge's own line: min top (above) / max bottom (below), first candidate wins a tie.
+    let edgeRect = null;
+    let lineH = 0;
+    for (let k = 0; k <= totalLen - minOffset; k++) {
+        const offset = asDomTextOffset(forward ? minOffset + k : totalLen - k);
+        const rect = getOffsetRect(container, offset);
+        if (!rect)
+            continue;
+        if (lineH === 0)
+            lineH = Math.max(1, rect.bottom - rect.top);
+        if (edgeRect) {
+            const distancePastEdge = forward ? rect.top - edgeRect.top : edgeRect.bottom - rect.bottom;
+            if (distancePastEdge > STOP_AFTER_LINES * lineH)
+                break;
+        }
+        candidates.push({ offset, rect });
+        if (!edgeRect || (forward ? rect.top < edgeRect.top : rect.bottom > edgeRect.bottom)) {
+            edgeRect = rect;
+        }
+    }
+    if (!edgeRect)
+        return minOffset;
+    const lineTop = edgeRect.top;
+    const lineBottom = edgeRect.bottom;
+    const lineHeight = Math.max(1, lineBottom - lineTop);
+    const tolerance = lineHeight * LINE_BAND_TOLERANCE;
+    let bestOffset = candidates[0].offset;
+    let bestDelta = Infinity;
+    for (const { offset, rect } of candidates) {
+        if (rect.top > lineBottom + tolerance)
+            continue;
+        if (rect.bottom < lineTop - tolerance)
+            continue;
+        const delta = Math.abs(rect.left - targetViewportX);
+        if (delta < bestDelta) {
+            bestDelta = delta;
+            bestOffset = offset;
+        }
+    }
+    return bestOffset;
+}
+// ── Internal ─────────────────────────────────────────────────────────────────
+function editorLeftOf(el) {
+    const editor = el.closest('.editor');
+    return editor ? editor.getBoundingClientRect().left : 0;
+}

package/dist/cursor/typography-estimates.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Empirical pixel estimates of the editor font's line box, measured at
+ * {@link ESTIMATE_BASE_FONT_SIZE} and shared by `height-oracle.ts` and `visual-lines.ts`.
+ * Character width has no CSS number to derive from, so the set is mirrored by hand at one scale.
+ * The editor's type scale is font-relative, so consumers scale these by the root's live computed
+ * font size — an estimate calibrated for one scale can miss the windowing watermark entirely.
+ */
+/** The computed root font size the estimates below were measured at. */
+export declare const ESTIMATE_BASE_FONT_SIZE = 16;
+export declare const HEIGHT_ESTIMATES: {
+    readonly proseLineHeight: 24;
+    readonly codeLineHeight: 20;
+    readonly avgCharWidth: 8;
+    readonly blockChrome: 16;
+    readonly imageBlockMinHeight: 200;
+};
+/** Fallback for a `normal` computed `lineHeight` (parses to NaN) — a generic line box,
+ *  independent of the per-kind estimates above. */
+export declare const FALLBACK_LINE_HEIGHT = 20;
+/** Fallback content width when no editor element is measurable yet (pre-mount, jsdom). */
+export declare const FALLBACK_CONTENT_WIDTH = 800;

package/dist/cursor/typography-estimates.js

@@ -0,0 +1,21 @@
+/**
+ * Empirical pixel estimates of the editor font's line box, measured at
+ * {@link ESTIMATE_BASE_FONT_SIZE} and shared by `height-oracle.ts` and `visual-lines.ts`.
+ * Character width has no CSS number to derive from, so the set is mirrored by hand at one scale.
+ * The editor's type scale is font-relative, so consumers scale these by the root's live computed
+ * font size — an estimate calibrated for one scale can miss the windowing watermark entirely.
+ */
+/** The computed root font size the estimates below were measured at. */
+export const ESTIMATE_BASE_FONT_SIZE = 16;
+export const HEIGHT_ESTIMATES = {
+    proseLineHeight: 24, // px per wrapped prose line
+    codeLineHeight: 20, // px per code source line
+    avgCharWidth: 8, // px, for chars-per-line from a container width
+    blockChrome: 16, // px of margin/padding per block
+    imageBlockMinHeight: 200 // px floor for an image-bearing paragraph
+};
+/** Fallback for a `normal` computed `lineHeight` (parses to NaN) — a generic line box,
+ *  independent of the per-kind estimates above. */
+export const FALLBACK_LINE_HEIGHT = 20;
+/** Fallback content width when no editor element is measurable yet (pre-mount, jsdom). */
+export const FALLBACK_CONTENT_WIDTH = 800;

package/dist/cursor/visual-lines.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Whether the cursor sits on the first or last visual line of a wrapping element. Offsets
+ * alone can't answer it past 2 wrapped lines, so cursor Y is compared to the first/last
+ * line's Y. The text-node walk works around collapsed ranges next to non-text children
+ * (dimmed marker spans) returning null rects — measuring around real text always works.
+ */
+/** The first rect that can position a caret: the leading client rect when it has real
+ *  height, else the bounding rect. `widthTolerant` also accepts a zero-height rect with width. */
+export declare function firstUsefulRect(range: Range, widthTolerant?: boolean): DOMRect | null;
+export declare function getRangeTop(range: Range): number | null;
+/** Non-collapsed ranges reliably return rects where collapsed ones don't. */
+export declare function getCharRangeTop(container: Node, offset: number, atEnd: boolean): number | null;
+/** Skips non-text children (dimmed marker spans) that would otherwise leave the block's
+ *  first line unmeasurable, and hidden marker text, which measures to no rect at all. */
+export declare function findFirstTextNode(root: Node): Text | null;
+export declare function findLastTextNode(root: Node): Text | null;
+/**
+ * True if the selection inside `el` sits on the first visual line; empty containers return true.
+ * `fallbackOffset` (the snapped caret intent from `ambient-cursor.getRaw`) resolves the case
+ * where there is no live range — Chromium drops the caret range next to atomic
+ * contenteditable=false islands across event-loop yields. It is compared against the block's
+ * first LANDABLE offset, which a leading hidden run moves off raw 0.
+ */
+export declare function isAtFirstVisualLine(el: HTMLElement, fallbackOffset: number, contentStart: number): boolean;
+export declare function isAtLastVisualLine(el: HTMLElement, fallbackOffset: number, contentEnd: number): boolean;

package/dist/cursor/visual-lines.js

@@ -0,0 +1,125 @@
+/**
+ * Whether the cursor sits on the first or last visual line of a wrapping element. Offsets
+ * alone can't answer it past 2 wrapped lines, so cursor Y is compared to the first/last
+ * line's Y. The text-node walk works around collapsed ranges next to non-text children
+ * (dimmed marker spans) returning null rects — measuring around real text always works.
+ */
+import { domDescendants } from './dom-walk';
+import { FALLBACK_LINE_HEIGHT } from './typography-estimates';
+import { isHiddenMarkerText } from './widget-offset';
+// Fraction of a line height within which the cursor Y counts as the boundary line —
+// sub-line, so sub/superscript or inline-image jitter doesn't read as a different line.
+const SAME_LINE_TOLERANCE = 0.8;
+/** The first rect that can position a caret: the leading client rect when it has real
+ *  height, else the bounding rect. `widthTolerant` also accepts a zero-height rect with width. */
+export function firstUsefulRect(range, widthTolerant = true) {
+    const rects = range.getClientRects();
+    if (rects.length > 0 && rects[0].height > 0)
+        return rects[0];
+    const br = range.getBoundingClientRect();
+    if (br.height > 0 || (widthTolerant && br.width > 0))
+        return br;
+    return null;
+}
+export function getRangeTop(range) {
+    return firstUsefulRect(range, false)?.top ?? null;
+}
+/** Non-collapsed ranges reliably return rects where collapsed ones don't. */
+export function getCharRangeTop(container, offset, atEnd) {
+    try {
+        const range = document.createRange();
+        if (atEnd) {
+            range.setStart(container, Math.max(0, offset - 1));
+            range.setEnd(container, offset);
+        }
+        else {
+            range.setStart(container, offset);
+            range.setEnd(container, offset + 1);
+        }
+        return firstUsefulRect(range)?.top ?? null;
+    }
+    catch {
+        // offset out of bounds
+    }
+    return null;
+}
+/** Skips non-text children (dimmed marker spans) that would otherwise leave the block's
+ *  first line unmeasurable, and hidden marker text, which measures to no rect at all. */
+export function findFirstTextNode(root) {
+    return measurableText(root, containerOf(root), false);
+}
+export function findLastTextNode(root) {
+    return measurableText(root, containerOf(root), true);
+}
+/**
+ * True if the selection inside `el` sits on the first visual line; empty containers return true.
+ * `fallbackOffset` (the snapped caret intent from `ambient-cursor.getRaw`) resolves the case
+ * where there is no live range — Chromium drops the caret range next to atomic
+ * contenteditable=false islands across event-loop yields. It is compared against the block's
+ * first LANDABLE offset, which a leading hidden run moves off raw 0.
+ */
+export function isAtFirstVisualLine(el, fallbackOffset, contentStart) {
+    return isAtEdgeVisualLine(el, () => fallbackOffset <= contentStart, {
+        isEmpty: (el.textContent ?? '').length === 0,
+        boundaryTop: () => {
+            const firstText = findFirstTextNode(el);
+            const top = firstText ? getCharRangeTop(firstText, 0, false) : null;
+            return top ?? collapsedContentsTop(el, true);
+        }
+    });
+}
+export function isAtLastVisualLine(el, fallbackOffset, contentEnd) {
+    return isAtEdgeVisualLine(el, () => fallbackOffset >= contentEnd, {
+        isEmpty: contentEnd === 0,
+        boundaryTop: () => {
+            const lastText = findLastTextNode(el);
+            const top = lastText ? getCharRangeTop(lastText, lastText.textContent.length, true) : null;
+            return top ?? collapsedContentsTop(el, false);
+        }
+    });
+}
+// ── Internal ────────────────────────────────────────────────────────────────
+/** The shared skeleton of the two edge predicates: `fallback` answers where geometry cannot — a
+ *  dropped range, an unmeasurable collapsed caret, an unmeasurable boundary line — and
+ *  `boundaryTop` measures the edge line each side's own way. */
+function isAtEdgeVisualLine(el, fallback, edge) {
+    const sel = window.getSelection();
+    if (!sel || sel.rangeCount === 0)
+        return fallback();
+    if (edge.isEmpty)
+        return true;
+    const cursorRange = sel.getRangeAt(0);
+    const cursorTop = getRangeTop(cursorRange);
+    if (cursorTop === null)
+        return cursorRange.collapsed ? fallback() : true;
+    const edgeTop = edge.boundaryTop();
+    if (edgeTop === null)
+        return fallback();
+    const lineHeight = parseFloat(getComputedStyle(el).lineHeight) || FALLBACK_LINE_HEIGHT;
+    return Math.abs(cursorTop - edgeTop) < lineHeight * SAME_LINE_TOLERANCE;
+}
+/** The boundary line's collapsed-contents fallback measurement. */
+function collapsedContentsTop(el, toStart) {
+    const range = document.createRange();
+    range.selectNodeContents(el);
+    range.collapse(toStart);
+    return getRangeTop(range);
+}
+/** Hidden-run classification needs the walk container; a bare text-node root has none. */
+function containerOf(root) {
+    return root instanceof HTMLElement ? root : null;
+}
+function measurableText(node, container, fromEnd) {
+    for (const current of domDescendants(node, undefined, { fromEnd })) {
+        if (current.nodeType !== Node.TEXT_NODE)
+            continue;
+        if (isMeasurableText(current, container))
+            return current;
+    }
+    return null;
+}
+function isMeasurableText(text, container) {
+    if ((text.textContent?.length ?? 0) === 0)
+        return false;
+    return container === null || !isHiddenMarkerText(text, container);
+}