@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/components/blocks/table/TableCellBlock.svelte.d.ts

@@ -24,6 +24,7 @@ declare const TableCellBlock: import("svelte").Component<$$ComponentProps, {
     setSelection: (start: number, end: number) => void;
     measurePartialRects: (startOffset: number, endOffset: number) => DOMRect[];
     isCommandActive: (id: CommandId) => boolean;
+    afterSourceCommit: (run: () => void) => void;
     runCommand: (id: CommandId) => boolean;
 }, "">;
 type TableCellBlock = ReturnType<typeof TableCellBlock>;

package/dist/components/blocks/table/TableRowBlock.svelte

@@ -1,34 +1,20 @@
 <script lang="ts">
 	import { getContext } from 'svelte';
-	import type {
-		BlockEditActions,
-		ContainerEditActions,
-		FocusActions
-	} from '../../../action-contracts';
-	import { CURSOR_END, CURSOR_START, type BlockComponent } from '../../../block-component';
+	import type { TableContext } from '../../../action-contracts';
+	import { entryEdge, type BlockComponent } from '../../../block-component';
 	import type { NodeView } from '../../../core/node-views';
 	import {
-		BLOCK_EDIT_KEY,
-		CONTAINER_EDIT_KEY,
-		EDITOR_DOC_KEY,
-		EDITOR_POLICIES_KEY,
 		EDITOR_SERVICES_KEY,
-		FOCUS_KEY,
-		PARENT_SCOPE_SINK_KEY,
-		type EditorDoc,
-		type EditorPolicies,
-		type EditorServices,
-		type ParentScopeSink
+		TABLE_CONTEXT_KEY,
+		type EditorServices
 	} from '../../../editor-keys';
 	import type { TableAlignment } from '../../../core/nodes';
-	import { createBlockListState } from '../../../reactivity/block-list-state.svelte';
 	import { useMountGauge } from '../../../perf/use-mount-gauge.svelte';
-	import {
-		createStandardNestedActions,
-		setNestedActionsContexts,
-		type NodeScope
-	} from '../../../editor-actions/nested/nested-actions';
+	import { useMeasuredChild } from '../../../reactivity/use-measured-child.svelte';
+	import { createContainerActions } from '../../../editor-actions/nested/container-actions';
 	import { publishRefSlot, type RefSlots } from '../../../reactivity/publish-ref.svelte';
+	import type { ChildList } from '../../../reactivity/child-list';
+	import { useBlockDecorations } from '../../../decorations/use-block-decorations.svelte';
 	import TableCellBlock from './TableCellBlock.svelte';
 
 	let {
@@ -51,101 +37,62 @@
 		slots?: RefSlots<BlockComponent>;
 	} = $props();
 
-	// A row's position among the table's children IS its row index.
+	// A row's position among the table's children is its row index.
 	const rowIdx = $derived(index);
 
-	const parentBlockEdit = getContext<BlockEditActions>(BLOCK_EDIT_KEY);
-	const parentFocus = getContext<FocusActions>(FOCUS_KEY);
-	const parentContainerEdit = getContext<ContainerEditActions>(CONTAINER_EDIT_KEY);
-	const { stickyColumn, registryView } = getContext<EditorServices>(EDITOR_SERVICES_KEY);
-	const getPresentationMode = getContext<EditorPolicies | undefined>(
-		EDITOR_POLICIES_KEY
-	)?.presentationMode;
-	const linkRef = getContext<EditorDoc | undefined>(EDITOR_DOC_KEY)?.linkRef;
+	const { decorations, events } = getContext<EditorServices>(EDITOR_SERVICES_KEY);
 
-	const cellsState = createBlockListState(() => node);
+	const { state: cellsState } = createContainerActions({
+		getNode: () => node,
+		getIndex: () => index,
+		getPath: () => myPath,
+		childList: () => cellList
+	});
 
 	let rowEl: HTMLElement | undefined = $state();
-	const parentSink = getContext<ParentScopeSink | undefined>(PARENT_SCOPE_SINK_KEY);
+	// Absent only when a row mounts outside a table, as a unit test's might.
+	const tableContext = getContext<TableContext | undefined>(TABLE_CONTEXT_KEY);
 
 	useMountGauge();
 
-	// A `display: contents` row has no box, so measure a cell: every cell stretches to
-	// the grid row track, making its border-box height the row height. Enrolling in the
-	// table scope's batched pass keeps a fling to one reflow, not one per mounted row.
-	$effect(() => {
-		void index;
-		if (!parentSink) return;
-		const currentIndex = index;
-		return parentSink.registerRow(
-			id,
-			() => {
-				const cell = rowEl?.querySelector(':scope > .table-cell') as HTMLElement | null;
-				return cell?.getBoundingClientRect().height ?? 0;
-			},
-			(h) => parentSink.setChildSubtotal(currentIndex, h)
-		);
+	// The row renders no block host, so its own element carries the decorations addressed to it.
+	const blockDecorations = useBlockDecorations({
+		getPath: () => myPath,
+		getEl: () => rowEl ?? null,
+		engine: decorations,
+		onRenderError: (error) => events.emit('error', error),
+		badgeRefusal: 'a table row renders no box of its own to hold one'
 	});
 
-	// Skip the mount run (mirrors BlockHost): a read here interleaved with the prior row's
-	// subtotal write forces one reflow per row mounted in the frame (VR-4). The batched
-	// pass owns mount measurement; this effect re-measures only on a later edit.
-	let firstRun = true;
-	$effect(() => {
-		void node.raw;
-		if (firstRun) {
-			firstRun = false;
-			return;
-		}
-		parentSink?.measureRowNow(id);
-	});
-
-	const scope: NodeScope = {
-		get index() {
-			return index;
+	// A `display: contents` row has no box, so its first cell, stretched to the row track, gives
+	// the row's height. Read through the first cell's id, so a moved first column is watched anew.
+	useMeasuredChild({
+		getId: () => id,
+		getPath: () => myPath,
+		getEl: () => {
+			void cellsState.innerBlockIds[0];
+			return rowEl?.querySelector<HTMLElement>(':scope > .table-cell') ?? null;
 		},
-		get node() {
-			return node;
-		},
-		get path() {
-			return myPath;
-		}
-	};
-
-	const bundle = createStandardNestedActions(cellsState, {
-		scope,
-		stickyColumn,
-		grammar: registryView.grammar,
-		getPresentationMode,
-		linkRef,
-		parent: {
-			blockEdit: parentBlockEdit,
-			focus: parentFocus,
-			containerEdit: parentContainerEdit
-		}
+		getRaw: () => node.raw
 	});
 
-	setNestedActionsContexts(bundle);
-
 	// ── BlockComponent interface ────────────────────────────────────────
 
 	export const editable = true;
 	export const focusable = true;
 
-	// The TableBlock twin's rule: a start arrival enters the first cell, anything else the
-	// last, and the sentinel rides into the cell so its door clamps and classifies.
-	function rowLanding(offset: number): { colIdx: number; at: number } {
-		const atStart = offset === 0 || offset === CURSOR_START;
-		return atStart ? { colIdx: 0, at: CURSOR_START } : { colIdx: columnCount - 1, at: CURSOR_END };
+	function entryCell(offset: number): { colIdx: number; at: number } {
+		const edge = entryEdge(offset);
+		return { colIdx: edge.child === 'first' ? 0 : columnCount - 1, at: edge.offset };
 	}
 
 	export function focus(offset: number): void {
-		const { colIdx, at } = rowLanding(offset);
+		const { colIdx, at } = entryCell(offset);
 		cellsState.innerBlockRefs[colIdx]?.focus(at);
 	}
 
 	export function parkCaret(offset: number): void {
-		const { colIdx, at } = rowLanding(offset);
+		const { colIdx, at } = entryCell(offset);
 		cellsState.innerBlockRefs[colIdx]?.parkCaret?.(at);
 	}
 
@@ -159,13 +106,17 @@
 		cellRef?.focus(rest.length === 0 ? offset : 0);
 	}
 
-	export function getBlockComponentByPath(path: number[]): BlockComponent | null {
-		if (path.length === 0) return null;
-		const [colIdx, ...rest] = path;
-		const cellRef = cellsState.innerBlockRefs[colIdx];
-		if (!cellRef) return null;
-		if (rest.length === 0) return cellRef;
-		return cellRef.getBlockComponentByPath?.(rest) ?? null;
+	// Cells aren't windowed, so a mounted row has every cell in range; the grid's own sideways
+	// scroll is what brings a far column into view.
+	const cellList: ChildList = {
+		count: () => node.children?.length ?? 0,
+		refs: cellsState.refSlots,
+		windowing: { revealChild: async () => {}, isInWindow: () => true },
+		bringChildIntoView: (colIdx) => tableContext?.revealColumn(rowIdx, colIdx)
+	};
+
+	function childList(): ChildList {
+		return cellList;
 	}
 
 	export function getCursorPosition(): { path: number[]; offset: number } | null {
@@ -177,8 +128,8 @@
 		return null;
 	}
 
-	// The ONE surface literal, the cell's twin: a row reaches every caller through its published
-	// slot, so a second literal to type-check against would only be a decoy.
+	// The one place this shape is written, as in the cell: a row reaches every caller through
+	// its registered reference, so a second copy to type-check against would mislead.
 	$effect(() => {
 		if (!slots) return;
 		const self = {
@@ -189,15 +140,20 @@
 			getCursorOffset,
 			getCursorPosition,
 			focusByPath,
-			getBlockComponentByPath
+			childList
 		} satisfies BlockComponent;
 		return publishRefSlot(slots, index, self, rowEl);
 	});
 </script>
 
 <!-- No whitespace between the row and its cells: a stray text node joins the table's
-	raw-offset walk and misplaces a parked cross-block caret. -->
-<div bind:this={rowEl} class="table-row" role="row" data-table-row-idx={rowIdx}>
+	raw-offset traversal and misplaces a remembered cross-block caret. -->
+<div
+	bind:this={rowEl}
+	class={['table-row', ...blockDecorations.classes]}
+	role="row"
+	data-table-row-idx={rowIdx}
+>
 	{#each node.children ?? [] as cellNode, colIdx (cellsState.innerBlockIds[colIdx])}
 		<TableCellBlock
 			node={cellNode}

package/dist/components/blocks/table/TableRowBlock.svelte.d.ts

@@ -19,7 +19,6 @@ declare const TableRowBlock: import("svelte").Component<$$ComponentProps, {
     parkCaret: (offset: number) => void;
     getCursorOffset: () => number | null;
     focusByPath: (path: number[], offset: number) => void;
-    getBlockComponentByPath: (path: number[]) => BlockComponent | null;
     getCursorPosition: () => {
         path: number[];
         offset: number;

package/dist/components/blocks/table/cell-keydown-plan.d.ts

@@ -1,17 +1,12 @@
-export interface CellKeyInput {
-    key: string;
-    ctrlOrMeta: boolean;
-    shiftKey: boolean;
-    altKey: boolean;
-}
+import { type ChordKeys } from '../../../schema/keybindings';
 export interface CellKeyState {
     rowIdx: number;
     colIdx: number;
     columnCount: number;
     rowCount: number;
     offset: number;
-    /** The cell's landable extremes. A mode that paints no marker puts a leading or trailing
-     *  run out of the caret's reach, and a hop testing raw 0 / raw length never fires. */
+    /** The first and last offsets the caret can sit at in the cell. A mode that draws no marker
+     *  puts a leading or trailing run out of reach, so a test of raw 0 or the length never fires. */
     contentStart: number;
     contentEnd: number;
     collapsed: boolean;
@@ -34,4 +29,4 @@ export type CellKeyPlan = {
     kind: 'exit';
     direction: 'up' | 'down';
 };
-export declare function cellKeydownPlan(e: CellKeyInput, s: CellKeyState): CellKeyPlan;
+export declare function cellKeydownPlan(e: ChordKeys, s: CellKeyState): CellKeyPlan;

package/dist/components/blocks/table/cell-keydown-plan.js

@@ -1,20 +1,16 @@
 /**
- * Pure keydown → plan for a table cell's caret-dependent navigation: cell hop at a text boundary,
- * row hop, table exit, the row-appending end of Tab/Enter. The branches ignore Alt and Mod, which
- * the command dispatcher claims first: an unclaimed modified arrow must still navigate, and
- * `native` hands it to the prose prelude, which moves among siblings by index.
+ * Turns a keydown into a plan for a table cell's caret-dependent navigation: move to the next cell
+ * at a text boundary, move a row, leave the table, and the row-appending end of Tab and Enter. The
+ * branches ignore Alt and Mod, which the command dispatcher takes first: a modified arrow nothing
+ * took must still navigate, and `native` hands it to the shared prose handling, which moves
+ * between siblings by index.
  */
 import { cellAbove, cellBelow, nextCell, prevCell } from './table-navigation';
-// CapsLock reports the letter uppercased, so the select-all chord tests for both
-// spellings rather than against a single literal.
-function isLetterA(key) {
-    return key === 'a' || key === 'A';
-}
+import { isSelectAllChord } from '../../../schema/keybindings';
 export function cellKeydownPlan(e, s) {
     const pos = { rowIdx: s.rowIdx, colIdx: s.colIdx };
-    // Two stages, like every other block: the cell's own text natively, then the document. A
-    // table stage in between was this editor's alone; Docs and friends go straight to the page.
-    if (e.ctrlOrMeta && isLetterA(e.key) && !e.shiftKey && !e.altKey) {
+    // Two stages, like every other block: the cell's own text first, then the document.
+    if (isSelectAllChord(e)) {
         return {
             kind: 'select-all-step',
             step: s.selectAllCount === 0 ? 'native' : 'document'

package/dist/components/blocks/table/cell-pointer.d.ts

@@ -1,9 +1,10 @@
 /**
- * Cell-aware pointer drag and shift+click for tables. Builds the shallow-path
- * intra-table multi-cell SelectionState (anchor.path === focus.path === tablePath,
- * offsets are cellIdx-based) when input crosses cell boundaries inside one table.
+ * Pointer drag and Shift+click across a table's cells, and the cell hit tests they use. A
+ * rectangle inside one table is a selection whose two endpoints both name the table's path,
+ * with flagged row-major cell indices as offsets.
  */
 import type { SelectionState } from '../../../selection/selection-state.svelte';
+import type { PaddingPress } from '../../../selection/cross-block/pointer';
 export interface CellAnchor {
     tableEl: HTMLElement;
     tablePath: number[];
@@ -16,12 +17,15 @@ export interface CellDragContext {
     selection: SelectionState;
     lifetimeSignal?: AbortSignal;
 }
-/**
- * Pointer-drag from inside `anchor`'s cell: drives the multi-cell encoding while the
- * pointer stays in the table, and extends focus to the foreign block underneath once
- * it leaves. Anchor cell coords are frozen; only the focus tracks the pointer.
- */
-export declare function installCellDragListener(ctx: CellDragContext, anchor: CellAnchor, down: PointerEvent): {
+/** A press in the anchor cell's padding that the editor placed, so no native drag selects in the
+ *  cell and the session paints the range there itself. */
+export interface CellPaddingPress {
+    surface: HTMLElement;
+    press: PaddingPress;
+}
+/** A drag from inside `anchor`'s cell selects a cell rectangle while the pointer stays in the
+ *  table and extends to the block underneath once it leaves; the anchor cell stays fixed. */
+export declare function installCellDragListener(ctx: CellDragContext, anchor: CellAnchor, down: PointerEvent, padding?: CellPaddingPress | null): {
     dispose(): void;
 };
 /** Shift+click on a cell when the previous focus was another cell of the same table. */
@@ -29,28 +33,19 @@ export declare function handleCellShiftClick(selection: SelectionState, anchor:
     rowIdx: number;
     colIdx: number;
 }): void;
-/**
- * The mounted table rows, in DOM order. Row windowing unmounts row 0 once the table
- * scrolls past it (VR-K1), so index 0 is the first MOUNTED row — still fine for column
- * geometry, since the column tracks are uniform.
- */
+/** The mounted rows in DOM order; under row windowing the first need not be row 0, which
+ *  column geometry can ignore because every row shares the column tracks. */
 export declare function mountedRowEls(tableEl: HTMLElement): HTMLElement[];
 /** The cells of one row, in column order. */
 export declare function rowCellEls(rowEl: Element): HTMLElement[];
-/**
- * A viewport point → its cell within `tableEl`, or null when the point falls outside
- * this specific table. Thin entry over `cellCoordsOfElement`.
- */
+/** The cell of `tableEl` under a viewport point, or null outside this table. */
 export declare function cellAtPoint(clientX: number, clientY: number, tableEl: HTMLElement): {
     rowIdx: number;
     colIdx: number;
     cellEl: HTMLElement;
 } | null;
-/**
- * An element (click target, previously focused element) → its cell coords within
- * `tableEl`. Identity-checks the owning table, so a sibling table can't masquerade
- * as the originating one.
- */
+/** The cell of `tableEl` an element sits in; the owning table is compared by identity, so a
+ *  cell of a nested or sibling table never answers for this one. */
 export declare function cellCoordsOfElement(el: Element | null, tableEl: HTMLElement): {
     rowIdx: number;
     colIdx: number;

package/dist/components/blocks/table/cell-pointer.js

@@ -1,27 +1,22 @@
 /**
- * Cell-aware pointer drag and shift+click for tables. Builds the shallow-path
- * intra-table multi-cell SelectionState (anchor.path === focus.path === tablePath,
- * offsets are cellIdx-based) when input crosses cell boundaries inside one table.
+ * Pointer drag and Shift+click across a table's cells, and the cell hit tests they use. A
+ * rectangle inside one table is a selection whose two endpoints both name the table's path,
+ * with flagged row-major cell indices as offsets.
  */
+import { cellPoint } from '../../../selection/primitives';
+import { rowMajorCellIndex } from '../../../cursor/coordinate-spaces';
 import { createPointerDragSession } from '../../../selection/pointer-session';
 import { blockNearPoint } from '../../../selection/nearest-block';
 import { firstScrollableDescendant } from '../../../cursor/scroll-ancestors';
-// ── Public API ─────────────────────────────────────────────────────────────
-/**
- * Pointer-drag from inside `anchor`'s cell: drives the multi-cell encoding while the
- * pointer stays in the table, and extends focus to the foreign block underneath once
- * it leaves. Anchor cell coords are frozen; only the focus tracks the pointer.
- */
-export function installCellDragListener(ctx, anchor, down) {
-    const anchorCellIdx = anchor.rowIdx * anchor.columnCount + anchor.colIdx;
-    // cellCoordinate marks the offset row-major, so a drag that exits to a foreign block
-    // gets the whole-row snap (table-endpoint-snap.ts) and copy/delete agree on the same
-    // rows. Same-table extends compare equal paths and short-circuit the snap.
-    const anchorPoint = {
-        path: anchor.tablePath.slice(),
-        offset: anchorCellIdx,
-        cellCoordinate: true
-    };
+import { TABLE_CELL_SELECTOR } from '../../block-content-selector';
+import { caretOffsetAtPoint } from '../../../cursor/point-offset';
+import { applySingleBlockRange } from '../../../selection/native-bridge';
+/** A drag from inside `anchor`'s cell selects a cell rectangle while the pointer stays in the
+ *  table and extends to the block underneath once it leaves; the anchor cell stays fixed. */
+export function installCellDragListener(ctx, anchor, down, padding = null) {
+    // Flagged as a cell index, so a drag that leaves the table snaps to whole rows
+    // (table-endpoint-snap.ts) and copy and delete agree on which rows it covers.
+    const anchorPoint = anchorCellPoint(anchor);
     // `anchor.tableEl` is `[role="table"]`; the scrollable element is its first
     // scrollable descendant (the `.table-block` grid).
     const tableScrollEl = firstScrollableDescendant(anchor.tableEl) ?? anchor.tableEl;
@@ -29,10 +24,11 @@ export function installCellDragListener(ctx, anchor, down) {
         const cellHit = cellAtPoint(clientX, clientY, anchor.tableEl);
         if (cellHit) {
             if (cellHit.rowIdx === anchor.rowIdx && cellHit.colIdx === anchor.colIdx) {
-                // Back in the anchor cell: collapse so native resumes the intra-cell selection.
+                // Back in the anchor cell: collapse so the browser resumes selecting inside it.
                 if (ctx.selection.isCrossBlock) {
                     ctx.selection.collapse();
                 }
+                paintInAnchorCell(clientX, clientY);
                 return;
             }
             extendToCell(cellHit.rowIdx, cellHit.colIdx);
@@ -45,18 +41,16 @@ export function installCellDragListener(ctx, anchor, down) {
             return;
         extendToForeignBlock(clientX, clientY);
     }
+    function paintInAnchorCell(clientX, clientY) {
+        if (!padding?.press.placed())
+            return;
+        const focus = caretOffsetAtPoint(padding.surface, clientX, clientY);
+        if (focus !== null)
+            applySingleBlockRange(padding.surface, padding.press.offset, focus);
+    }
     function extendToCell(rowIdx, colIdx) {
-        const cellIdx = rowIdx * anchor.columnCount + colIdx;
-        const focusPoint = {
-            path: anchor.tablePath.slice(),
-            offset: cellIdx
-        };
-        if (!ctx.selection.isCustomRendered) {
-            ctx.selection.enterCrossBlock(anchorPoint, focusPoint);
-        }
-        else {
-            ctx.selection.extendFocus(focusPoint);
-        }
+        const focus = cellPoint(anchor.tablePath, rowMajorCellIndex(rowIdx, colIdx, anchor.columnCount));
+        enterOrExtend(ctx.selection, anchorPoint, focus);
     }
     function extendToForeignBlock(clientX, clientY) {
         // Nearest, not under: one coalesced frame can hand over a point off every block (the
@@ -65,16 +59,11 @@ export function installCellDragListener(ctx, anchor, down) {
         if (!near)
             return;
         // Shared with the cross-block drag, so a table destination carries cellCoordinate for the
-        // whole-row snap symmetrically with the anchor, and a surfaceless kind is not hit-tested.
+        // whole-row snap just as the anchor does, and a kind with no editable element is skipped.
         const focusPoint = near.endpointHere();
         if (!focusPoint)
             return;
-        if (!ctx.selection.isCustomRendered) {
-            ctx.selection.enterCrossBlock(anchorPoint, focusPoint);
-        }
-        else {
-            ctx.selection.extendFocus(focusPoint);
-        }
+        enterOrExtend(ctx.selection, anchorPoint, focusPoint);
     }
     return createPointerDragSession(down, {
         onMove: (p) => processMove(p.clientX, p.clientY),
@@ -84,55 +73,44 @@ export function installCellDragListener(ctx, anchor, down) {
 }
 /** Shift+click on a cell when the previous focus was another cell of the same table. */
 export function handleCellShiftClick(selection, anchor, target) {
-    const anchorCellIdx = anchor.rowIdx * anchor.columnCount + anchor.colIdx;
-    const focusCellIdx = target.rowIdx * anchor.columnCount + target.colIdx;
-    const tablePath = anchor.tablePath.slice();
-    if (selection.isCustomRendered) {
-        selection.extendFocus({ path: tablePath, offset: focusCellIdx });
-        return;
-    }
-    // Flagged row-major to match the drag anchor, so a later exit-the-table extend snaps
-    // whole rows. The focus stays unflagged: same-table extends short-circuit the snap.
-    selection.enterCrossBlock({
-        path: tablePath.slice(),
-        offset: anchorCellIdx,
-        cellCoordinate: true
-    }, { path: tablePath.slice(), offset: focusCellIdx });
+    const focus = cellPoint(anchor.tablePath, rowMajorCellIndex(target.rowIdx, target.colIdx, anchor.columnCount));
+    enterOrExtend(selection, anchorCellPoint(anchor), focus);
+}
+// ── Shared ─────────────────────────────────────────────────────────────────
+function anchorCellPoint(anchor) {
+    return cellPoint(anchor.tablePath, rowMajorCellIndex(anchor.rowIdx, anchor.colIdx, anchor.columnCount));
+}
+/** The first move past the anchor starts the range; later ones only move its focus. */
+function enterOrExtend(selection, anchor, focus) {
+    if (selection.isCustomRendered)
+        selection.extendFocus(focus);
+    else
+        selection.enterCrossBlock(anchor, focus);
 }
 // ── DOM geometry ─────────────────────────────────────────────────────────────
 //
-// Selector contract: rows carry `data-table-row-idx`, cells carry `role="cell"`. Two
-// other readers walk the same selectors — `selection/path-lookup.ts` upward and
-// `Editor.svelte`'s `getBlockElByPath` downward — so a markup change lands in all three.
-/**
- * The mounted table rows, in DOM order. Row windowing unmounts row 0 once the table
- * scrolls past it (VR-K1), so index 0 is the first MOUNTED row — still fine for column
- * geometry, since the column tracks are uniform.
- */
+// Rows carry `data-table-row-idx` and cells match `TABLE_CELL_SELECTOR`; `selection/path-lookup.ts`
+// and `components/block-el-lookup.ts` read the same markup, so a change to it reaches all three.
+/** The mounted rows in DOM order; under row windowing the first need not be row 0, which
+ *  column geometry can ignore because every row shares the column tracks. */
 export function mountedRowEls(tableEl) {
     return Array.from(tableEl.querySelectorAll(':scope > [data-table-row-idx]'));
 }
 /** The cells of one row, in column order. */
 export function rowCellEls(rowEl) {
-    return Array.from(rowEl.querySelectorAll(':scope > [role="cell"]'));
+    return Array.from(rowEl.querySelectorAll(`:scope > ${TABLE_CELL_SELECTOR}`));
 }
 // ── Hit testing ────────────────────────────────────────────────────────────
-/**
- * A viewport point → its cell within `tableEl`, or null when the point falls outside
- * this specific table. Thin entry over `cellCoordsOfElement`.
- */
+/** The cell of `tableEl` under a viewport point, or null outside this table. */
 export function cellAtPoint(clientX, clientY, tableEl) {
     return cellCoordsOfElement(document.elementFromPoint(clientX, clientY), tableEl);
 }
-/**
- * An element (click target, previously focused element) → its cell coords within
- * `tableEl`. Identity-checks the owning table, so a sibling table can't masquerade
- * as the originating one.
- */
+/** The cell of `tableEl` an element sits in; the owning table is compared by identity, so a
+ *  cell of a nested or sibling table never answers for this one. */
 export function cellCoordsOfElement(el, tableEl) {
     if (!el)
         return null;
-    const cellEl = el.closest('[role="cell"]');
+    const cellEl = el.closest(TABLE_CELL_SELECTOR);
     if (!cellEl)
         return null;
     const rowEl = cellEl.closest('[data-table-row-idx]');