@voithos-labs/aragonite 0.10.1

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

@@ -0,0 +1,61 @@
+/**
+ * Shared keydown prelude for contenteditable blocks: Ctrl+A counter, cross-block dispatch,
+ * sticky-column capture/reset, 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 { SelectionState } from './selection-state.svelte';
+import type { CrossBlockHandlers } from './cross-block/dispatch';
+import type { PluginActivation } from '../schema/plugin-activation';
+export interface SharedKeydownContext extends LandableBoundsContext {
+    getEl(): HTMLElement | null;
+    /** Current caret offset in raw-content coordinates (ambient marker excluded). */
+    getCursorOffset(): number | null;
+    /** Shift-selection focus offset in raw-content coordinates (ambient marker excluded). */
+    getFocusOffset(): number | null;
+    getIndex(): number;
+    getMyPath(): number[];
+    getDoc: DocumentGetter;
+    crossBlock: CrossBlockHandlers;
+    selection: SelectionState;
+    stickyColumn: StickyColumnState;
+    edgeAffinity: EdgeAffinityState;
+    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;
+}
+/** 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>;
+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 whole keydown context. */
+export interface LandableBoundsContext {
+    /** textContent length in raw-content coordinates (ambient marker 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.
+ */
+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`.
+ */
+export declare function handleSharedBeforeInput(e: InputEvent, ctx: {
+    history: HistoryActions;
+    crossBlock: CrossBlockHandlers;
+}): Promise<boolean>;

package/dist/selection/shared-keydown.js

@@ -0,0 +1,150 @@
+/**
+ * Shared keydown prelude for contenteditable blocks: Ctrl+A counter, cross-block dispatch,
+ * sticky-column capture/reset, undo/redo, arrow boundary navigation. Block-specific handlers
+ * (Enter, Backspace, Tab, formatting) stay in each component.
+ */
+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 { 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) {
+        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.
+    const historyChord = eventToChord(e);
+    if (historyChord && isDefaultGlobalChord(historyChord, ctx.activePlugins)) {
+        e.preventDefault();
+        return false;
+    }
+    // ── Arrow boundary navigation ─────────────────────────────────────────
+    const index = ctx.getIndex();
+    const myPath = ctx.getMyPath();
+    // Lazy: off the arrow path the block's bounds are never asked for, and the resolve
+    // walks the block's DOM.
+    let cachedBounds = null;
+    const bounds = () => (cachedBounds ??= caretLandableBounds(ctx, el));
+    // Read the focus offset (not the anchor) for Shift+Arrow: after a forward extension the
+    // anchor stays mid-block while the focus sits at the boundary.
+    const shiftOffset = e.shiftKey ? ctx.getFocusOffset() : null;
+    if (e.key === 'ArrowUp') {
+        const offset = shiftOffset ?? ctx.getCursorOffset() ?? 0;
+        if (isAtFirstVisualLine(el, offset, bounds().start)) {
+            // 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);
+                return true;
+            }
+            if (!e.shiftKey && !e.altKey) {
+                e.preventDefault();
+                void ctx.focus.moveFocus(index - 1, { stickyColumnFrom: 'below' });
+                return true;
+            }
+        }
+    }
+    if (e.key === 'ArrowDown') {
+        const offset = shiftOffset ?? ctx.getCursorOffset() ?? 0;
+        if (isAtLastVisualLine(el, offset, bounds().end)) {
+            // 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);
+                return true;
+            }
+            if (!e.shiftKey && !e.altKey) {
+                e.preventDefault();
+                void ctx.focus.moveFocus(index + 1, { stickyColumnFrom: 'above' });
+                return true;
+            }
+        }
+    }
+    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.
+        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);
+                return true;
+            }
+            e.preventDefault();
+            void ctx.focus.moveFocus(index - 1, 'end');
+            return true;
+        }
+    }
+    if (e.key === 'ArrowRight') {
+        const offset = e.shiftKey ? (ctx.getFocusOffset() ?? bounds().end) : ctx.getCursorOffset();
+        if (offset !== null && offset >= bounds().end) {
+            if (e.shiftKey) {
+                e.preventDefault();
+                extendFocusToNextBlock(ctx.selection, ctx.getDoc(), el, myPath);
+                scrollFocusBlockIntoView(ctx.selection, ctx.getBlockElByPath);
+                return true;
+            }
+            e.preventDefault();
+            void ctx.focus.moveFocus(index + 1, 'start');
+            return true;
+        }
+    }
+    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.
+ */
+export function caretLandableBounds(ctx, el) {
+    return landableRawBounds(el, ctx.getAmbientLength()) ?? { 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`.
+ */
+export async function handleSharedBeforeInput(e, ctx) {
+    if (e.inputType === 'historyUndo') {
+        e.preventDefault();
+        void ctx.history.requestUndo();
+        return true;
+    }
+    if (e.inputType === 'historyRedo') {
+        e.preventDefault();
+        void ctx.history.requestRedo();
+        return true;
+    }
+    if (await ctx.crossBlock.handleBeforeInput(e))
+        return true;
+    return false;
+}

package/dist/selection/table-endpoint-snap.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The cell-index space a selection endpoint inside a grid lives in. Offsets are INCLUSIVE cell
+ * indices, the space SelectionPoint already uses. The whole-row snap and the two metadata reads
+ * answer for a table alone; the coverage tenants answer for any `containerContract: 'grid'` kind.
+ * An intra-table pair is deliberately left unsnapped, so rectangular sub-cell selection survives.
+ */
+import type { DocumentView, NodeView } from '../core/node-views';
+import type { SelectionPoint } from './primitives';
+/**
+ * The char→cell conversion funnel: a cross-block endpoint inside a table must address the table
+ * block by row-major cell index, or a deep `[tableIdx, row, col]` path with a char offset routes
+ * the delete down the generic branch and corrupts the grid. SelectionState applies this to every
+ * incoming point, so entry paths never call it themselves. Non-table paths pass through.
+ */
+export declare function normalizeTableEndpoint(doc: DocumentView, path: number[], offset: number): SelectionPoint;
+/**
+ * How many cells a table's index space holds, the exclusive upper bound on any row-major cell
+ * index. `node` must be a table block; the metadata read is unchecked, so other kinds give NaN.
+ * Lives beside the bounds check below so a caller's clamp and the check cannot drift apart.
+ */
+export declare function tableCellCount(node: NodeView): number;
+/** One cell of a grid, with the doc-absolute path that addresses it. */
+export interface GridCell {
+    node: NodeView;
+    path: number[];
+}
+/**
+ * `point`'s index in `grid`'s cell space, null where it addresses no cell of it — the side the
+ * range runs past, which reads as the grid's own edge. A table's endpoint arrives on the grid path
+ * already carrying the index; a plugin grid's keeps the deep `[grid, row, col]` path G1.29 permits,
+ * and resolves through the same width {@link coveredGridCells} decodes with.
+ */
+export declare function gridEndpointCellIndex(grid: NodeView, gridPath: number[], point: SelectionPoint): number | null;
+/**
+ * The cells a range covers inside one grid, in document order. `from`/`to` are the range's own cell
+ * indices IN DOCUMENT ORDER (`from <= to`; unordered inputs answer with fewer cells or none), null
+ * on a side the range runs past. Both inside is the RECTANGLE they span — what the overlay paints
+ * and `range-delete-table` clears; one inside is a run to that cell inclusive. Rows of cells is the
+ * whole shape asked: children that are not rows of cells answer with no cells, rows of unequal
+ * width with the wrong cells or none, every index being row 0's width.
+ */
+export declare function coveredGridCells(grid: NodeView, gridPath: number[], from: number | null, to: number | null): GridCell[];
+/**
+ * Inverse of {@link normalizeTableEndpoint}: expand an endpoint addressing a table block to its
+ * deep `[tableIdx, row, col]` leaf path so reveal/caret placement reaches an off-window cell.
+ * Null when the path is already a leaf or the index lands outside the grid. Resolution is on the
+ * NODE KIND, not the `cellCoordinate` flag: an intra-table focus is unflagged (see
+ * {@link SelectionPoint}) yet still a cell index. Callers reach it through
+ * `SelectionState.cellLandingFor`, which is where the landing rule lives.
+ */
+export declare function cellEndpointDeepPath(doc: DocumentView, point: SelectionPoint): number[] | null;
+export declare function snapCrossBlockTableEndpoints(doc: DocumentView, start: SelectionPoint, end: SelectionPoint): {
+    start: SelectionPoint;
+    end: SelectionPoint;
+};

package/dist/selection/table-endpoint-snap.js

@@ -0,0 +1,143 @@
+/**
+ * The cell-index space a selection endpoint inside a grid lives in. Offsets are INCLUSIVE cell
+ * indices, the space SelectionPoint already uses. The whole-row snap and the two metadata reads
+ * answer for a table alone; the coverage tenants answer for any `containerContract: 'grid'` kind.
+ * An intra-table pair is deliberately left unsnapped, so rectangular sub-cell selection survives.
+ */
+import { metadataOf } from '../core/nodes';
+import { isBlockNode, nodeAt } from '../tree-operations/node-ops';
+import { cellIndexOf } from './primitives';
+import { asCellIndex, cellRowCol } from '../cursor/coordinate-spaces';
+import { comparePaths, pathHasPrefix } from './path-math';
+import { devWarn } from '../dev-warn';
+/**
+ * The char→cell conversion funnel: a cross-block endpoint inside a table must address the table
+ * block by row-major cell index, or a deep `[tableIdx, row, col]` path with a char offset routes
+ * the delete down the generic branch and corrupts the grid. SelectionState applies this to every
+ * incoming point, so entry paths never call it themselves. Non-table paths pass through.
+ */
+export function normalizeTableEndpoint(doc, path, offset) {
+    for (let d = 0; d < path.length - 1; d++) {
+        const node = nodeAt(doc, path.slice(0, d + 1));
+        if (node && isBlockNode(node) && node.kind === 'table') {
+            const colCount = metadataOf(node, 'table').columnCount;
+            const rowIdx = path[d + 1];
+            const colIdx = path[d + 2] ?? 0;
+            return {
+                path: path.slice(0, d + 1),
+                offset: asCellIndex(rowIdx * colCount + colIdx),
+                cellCoordinate: true
+            };
+        }
+    }
+    return { path: path.slice(), offset };
+}
+/**
+ * How many cells a table's index space holds, the exclusive upper bound on any row-major cell
+ * index. `node` must be a table block; the metadata read is unchecked, so other kinds give NaN.
+ * Lives beside the bounds check below so a caller's clamp and the check cannot drift apart.
+ */
+export function tableCellCount(node) {
+    return (node.children?.length ?? 0) * metadataOf(node, 'table').columnCount;
+}
+/** A grid's own width, row 0's cell count — not `metadata.columnCount`: `containerContract: 'grid'`
+ *  is a plugin contract, and a kind with no table metadata reaches here. A column mutation splices
+ *  each row and the count together, so the two agree on a table. */
+function gridColumnCount(grid) {
+    return grid.children?.[0]?.children?.length ?? 0;
+}
+/**
+ * `point`'s index in `grid`'s cell space, null where it addresses no cell of it — the side the
+ * range runs past, which reads as the grid's own edge. A table's endpoint arrives on the grid path
+ * already carrying the index; a plugin grid's keeps the deep `[grid, row, col]` path G1.29 permits,
+ * and resolves through the same width {@link coveredGridCells} decodes with.
+ */
+export function gridEndpointCellIndex(grid, gridPath, point) {
+    if (!pathHasPrefix(point.path, gridPath))
+        return null;
+    // On the grid's own path, resolution is the NODE KIND's, not the flag's ({@link
+    // cellEndpointDeepPath}): a table path IS cell space, so an intra-table rectangle's unflagged
+    // corner counts cells, while any other grid holds a char offset addressing no cell.
+    if (point.path.length === gridPath.length)
+        return point.cellCoordinate || grid.kind === 'table' ? point.offset : null;
+    const [row, col = 0] = point.path.slice(gridPath.length);
+    return row * gridColumnCount(grid) + col;
+}
+/**
+ * The cells a range covers inside one grid, in document order. `from`/`to` are the range's own cell
+ * indices IN DOCUMENT ORDER (`from <= to`; unordered inputs answer with fewer cells or none), null
+ * on a side the range runs past. Both inside is the RECTANGLE they span — what the overlay paints
+ * and `range-delete-table` clears; one inside is a run to that cell inclusive. Rows of cells is the
+ * whole shape asked: children that are not rows of cells answer with no cells, rows of unequal
+ * width with the wrong cells or none, every index being row 0's width.
+ */
+export function coveredGridCells(grid, gridPath, from, to) {
+    const rows = grid.children ?? [];
+    const colCount = gridColumnCount(grid);
+    if (rows.length === 0 || colCount < 1)
+        return [];
+    const lastIndex = rows.length * colCount - 1;
+    const clamp = (index) => Math.min(Math.max(index, 0), lastIndex);
+    const first = cellRowCol(asCellIndex(clamp(from ?? 0)), colCount);
+    const last = cellRowCol(asCellIndex(clamp(to ?? lastIndex)), colCount);
+    const rectangle = from !== null && to !== null;
+    const cells = [];
+    for (let row = first.row; row <= last.row; row++) {
+        const startCol = rectangle ? Math.min(first.col, last.col) : row === first.row ? first.col : 0;
+        const endCol = rectangle
+            ? Math.max(first.col, last.col)
+            : row === last.row
+                ? last.col
+                : colCount - 1;
+        for (let col = startCol; col <= endCol; col++) {
+            const node = rows[row]?.children?.[col];
+            if (node)
+                cells.push({ node, path: [...gridPath, row, col] });
+        }
+    }
+    return cells;
+}
+/**
+ * Inverse of {@link normalizeTableEndpoint}: expand an endpoint addressing a table block to its
+ * deep `[tableIdx, row, col]` leaf path so reveal/caret placement reaches an off-window cell.
+ * Null when the path is already a leaf or the index lands outside the grid. Resolution is on the
+ * NODE KIND, not the `cellCoordinate` flag: an intra-table focus is unflagged (see
+ * {@link SelectionPoint}) yet still a cell index. Callers reach it through
+ * `SelectionState.cellLandingFor`, which is where the landing rule lives.
+ */
+export function cellEndpointDeepPath(doc, point) {
+    const node = nodeAt(doc, point.path);
+    if (!node || !isBlockNode(node) || node.kind !== 'table')
+        return null;
+    const colCount = metadataOf(node, 'table').columnCount;
+    const cellIdx = asCellIndex(point.offset);
+    const cellCount = tableCellCount(node);
+    if (cellIdx < 0 || cellIdx >= cellCount) {
+        devWarn('table-endpoint-snap', 'cell index outside the grid', { point, colCount, cellCount });
+        return null;
+    }
+    const { row, col } = cellRowCol(cellIdx, colCount);
+    return [...point.path, row, col];
+}
+export function snapCrossBlockTableEndpoints(doc, start, end) {
+    if (comparePaths(start.path, end.path) === 0)
+        return { start, end };
+    return {
+        start: snapEndpoint(doc, start, 'start'),
+        end: snapEndpoint(doc, end, 'end')
+    };
+}
+function snapEndpoint(doc, point, side) {
+    if (!point.cellCoordinate)
+        return point;
+    const node = nodeAt(doc, point.path);
+    if (!node || !isBlockNode(node) || node.kind !== 'table')
+        return point;
+    const colCount = metadataOf(node, 'table').columnCount;
+    const cellIdx = cellIndexOf(point, 'snapCrossBlockTableEndpoints');
+    const { row } = cellRowCol(cellIdx, colCount);
+    const snappedOffset = side === 'start' ? row * colCount : row * colCount + colCount - 1;
+    if (snappedOffset === cellIdx)
+        return point;
+    return { ...point, offset: snappedOffset };
+}

package/dist/selection/table-rect-extend.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Keyboard extension geometry for an intra-table rectangle. Shift+Arrow grows the rectangle
+ * cell-by-cell rather than walking the next document-order leaf, which would descend into the
+ * table and snap the focus back to cellIdx 0. Vertical extension exits at the row boundary;
+ * horizontal extension clamps at the column edges, since a rectangle has no sideways exit.
+ */
+import type { DocumentView } from '../core/node-views';
+import type { SelectionPoint } from './primitives';
+export type ArrowKey = 'ArrowUp' | 'ArrowDown' | 'ArrowLeft' | 'ArrowRight';
+export type TableRectExtension = {
+    kind: 'cell';
+    offset: number;
+} | {
+    kind: 'exit';
+    direction: 'forward' | 'backward';
+    fromCellPath: number[];
+};
+/**
+ * The extension a Shift+Arrow produces for an intra-table rectangle, or null when the selection
+ * is not a same-table rectangle. `anchor === focus` is a valid one-cell rectangle, so the first
+ * Shift+Arrow starts here too. Offsets are cell indices, context-established by the shared path.
+ */
+export declare function intraTableRectExtension(doc: DocumentView, anchor: SelectionPoint | null, focus: SelectionPoint | null, key: ArrowKey): TableRectExtension | null;

package/dist/selection/table-rect-extend.js

@@ -0,0 +1,46 @@
+/**
+ * Keyboard extension geometry for an intra-table rectangle. Shift+Arrow grows the rectangle
+ * cell-by-cell rather than walking the next document-order leaf, which would descend into the
+ * table and snap the focus back to cellIdx 0. Vertical extension exits at the row boundary;
+ * horizontal extension clamps at the column edges, since a rectangle has no sideways exit.
+ */
+import { metadataOf } from '../core/nodes';
+import { isBlockNode, nodeAt } from '../tree-operations/node-ops';
+import { cellRowCol } from '../cursor/coordinate-spaces';
+import { pathsEqual } from './path-math';
+/**
+ * The extension a Shift+Arrow produces for an intra-table rectangle, or null when the selection
+ * is not a same-table rectangle. `anchor === focus` is a valid one-cell rectangle, so the first
+ * Shift+Arrow starts here too. Offsets are cell indices, context-established by the shared path.
+ */
+export function intraTableRectExtension(doc, anchor, focus, key) {
+    if (!anchor || !focus || !pathsEqual(anchor.path, focus.path))
+        return null;
+    const node = nodeAt(doc, focus.path);
+    if (!node || !isBlockNode(node) || node.kind !== 'table')
+        return null;
+    const colCount = metadataOf(node, 'table').columnCount;
+    const rowCount = node.children?.length ?? 0;
+    if (colCount === 0 || rowCount === 0)
+        return null;
+    const path = focus.path;
+    const { row, col } = cellRowCol(focus.offset, colCount);
+    switch (key) {
+        case 'ArrowDown':
+            return row < rowCount - 1
+                ? { kind: 'cell', offset: (row + 1) * colCount + col }
+                : {
+                    kind: 'exit',
+                    direction: 'forward',
+                    fromCellPath: [...path, rowCount - 1, colCount - 1]
+                };
+        case 'ArrowUp':
+            return row > 0
+                ? { kind: 'cell', offset: (row - 1) * colCount + col }
+                : { kind: 'exit', direction: 'backward', fromCellPath: [...path, 0, 0] };
+        case 'ArrowRight':
+            return { kind: 'cell', offset: row * colCount + Math.min(col + 1, colCount - 1) };
+        case 'ArrowLeft':
+            return { kind: 'cell', offset: row * colCount + Math.max(col - 1, 0) };
+    }
+}

package/dist/selection/widget-range-paint.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Paints `md-widget-selected` on atomic inline widgets the native Selection range overlaps,
+ * because `::selection` skips contenteditable=false content. Suspended while the cross-block
+ * overlay or the widget-selection popover owns the visual.
+ */
+export interface WidgetRangePainterOpts {
+    editorRoot: HTMLElement;
+    getSelectionIsCustomRendered: () => boolean;
+    getWidgetIsSelected: () => boolean;
+    lifetime: AbortSignal;
+}
+export declare function installWidgetRangePainter(opts: WidgetRangePainterOpts): void;

package/dist/selection/widget-range-paint.js

@@ -0,0 +1,44 @@
+/**
+ * Paints `md-widget-selected` on atomic inline widgets the native Selection range overlaps,
+ * because `::selection` skips contenteditable=false content. Suspended while the cross-block
+ * overlay or the widget-selection popover owns the visual.
+ */
+const WIDGET_SELECTOR = '[data-inline-widget]';
+const SELECTED_CLASS = 'md-widget-selected';
+export function installWidgetRangePainter(opts) {
+    const { editorRoot, getSelectionIsCustomRendered, getWidgetIsSelected, lifetime } = opts;
+    if (lifetime.aborted)
+        return;
+    function clearAll() {
+        const widgets = editorRoot.querySelectorAll(WIDGET_SELECTOR);
+        for (const w of widgets)
+            w.classList.remove(SELECTED_CLASS);
+    }
+    function paint() {
+        if (getSelectionIsCustomRendered() || getWidgetIsSelected()) {
+            clearAll();
+            return;
+        }
+        const sel = window.getSelection();
+        if (!sel || sel.rangeCount === 0 || sel.isCollapsed) {
+            clearAll();
+            return;
+        }
+        const anchor = sel.anchorNode;
+        if (!anchor || !editorRoot.contains(anchor)) {
+            clearAll();
+            return;
+        }
+        const range = sel.getRangeAt(0);
+        const widgets = editorRoot.querySelectorAll(WIDGET_SELECTOR);
+        for (const w of widgets) {
+            w.classList.toggle(SELECTED_CLASS, range.intersectsNode(w));
+        }
+    }
+    const handler = () => paint();
+    document.addEventListener('selectionchange', handler);
+    lifetime.addEventListener('abort', () => {
+        document.removeEventListener('selectionchange', handler);
+        clearAll();
+    }, { once: true });
+}