@voithos-labs/aragonite 0.10.1

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

@@ -0,0 +1,153 @@
+/**
+ * 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.
+ */
+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
+    };
+    // `anchor.tableEl` is `[role="table"]`; the scrollable element is its first
+    // scrollable descendant (the `.table-block` grid).
+    const tableScrollEl = firstScrollableDescendant(anchor.tableEl) ?? anchor.tableEl;
+    function processMove(clientX, clientY) {
+        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.
+                if (ctx.selection.isCrossBlock) {
+                    ctx.selection.collapse();
+                }
+                return;
+            }
+            extendToCell(cellHit.rowIdx, cellHit.colIdx);
+            return;
+        }
+        // Inside the table but not over a cell (a padding gap): hold the current focus,
+        // so crossing a cell border doesn't flicker.
+        const target = document.elementFromPoint(clientX, clientY);
+        if (target && anchor.tableEl.contains(target))
+            return;
+        extendToForeignBlock(clientX, clientY);
+    }
+    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);
+        }
+    }
+    function extendToForeignBlock(clientX, clientY) {
+        // Nearest, not under: one coalesced frame can hand over a point off every block (the
+        // margin, a gutter), and declining it would drop the whole gesture.
+        const near = blockNearPoint(ctx.editorRoot, clientX, clientY);
+        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.
+        const focusPoint = near.endpointHere();
+        if (!focusPoint)
+            return;
+        if (!ctx.selection.isCustomRendered) {
+            ctx.selection.enterCrossBlock(anchorPoint, focusPoint);
+        }
+        else {
+            ctx.selection.extendFocus(focusPoint);
+        }
+    }
+    return createPointerDragSession(down, {
+        onMove: (p) => processMove(p.clientX, p.clientY),
+        autoScroll: { getTargets: () => [tableScrollEl] },
+        lifetimeSignal: ctx.lifetimeSignal
+    });
+}
+/** 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 });
+}
+// ── 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.
+ */
+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"]'));
+}
+// ── Hit testing ────────────────────────────────────────────────────────────
+/**
+ * A viewport point → its cell within `tableEl`, or null when the point falls outside
+ * this specific table. Thin entry over `cellCoordsOfElement`.
+ */
+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.
+ */
+export function cellCoordsOfElement(el, tableEl) {
+    if (!el)
+        return null;
+    const cellEl = el.closest('[role="cell"]');
+    if (!cellEl)
+        return null;
+    const rowEl = cellEl.closest('[data-table-row-idx]');
+    if (!rowEl)
+        return null;
+    if (rowEl.closest('[role="table"]') !== tableEl)
+        return null;
+    const rowIdxAttr = rowEl.getAttribute('data-table-row-idx');
+    if (rowIdxAttr === null)
+        return null;
+    const rowIdx = Number(rowIdxAttr);
+    if (Number.isNaN(rowIdx))
+        return null;
+    const colIdx = rowCellEls(rowEl).indexOf(cellEl);
+    if (colIdx < 0)
+        return null;
+    return { rowIdx, colIdx, cellEl };
+}

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

@@ -0,0 +1,51 @@
+/**
+ * DOM-build for TableCellBlock's render $effect. Mirrors text-render.ts without the
+ * ambient prefix or block marker — a cell's entire raw is content, so every island
+ * offset is a raw offset. The component owns the effect and the pending-cursor
+ * restore; this factory owns the imperative build.
+ */
+import type { DocumentView, NodeView } from '../../../core/node-views';
+import type { LinkReferenceResolverRef, ResolveLinkUrl } from '../../../editor-keys';
+import type { PresentationMode } from '../../../presentation-mode';
+import type { IndexedDecoration } from '../../../decorations/buckets';
+import type { ReplaceDecoration, WidgetDecoration } from '../../../decorations/types';
+export interface CellRenderDeps {
+    get el(): HTMLElement | null;
+    get node(): NodeView;
+    get linkRef(): LinkReferenceResolverRef | undefined;
+    resolveLinkUrl: ResolveLinkUrl;
+    /** Effective mode. Read inside the render pass on purpose: the read is the
+     *  reactive dependency that re-renders every mounted cell on a mode flip. */
+    get presentationMode(): PresentationMode;
+    /** The editor's theme name, forwarded to widgets. NOT a render-key term: this DOM is
+     *  themed by CSS, so only a widget whose engine paints its own colors reads it. */
+    getTheme?: () => string;
+    /** Live root document for widgets that derive from it. A getter, so a pooled widget
+     *  re-reads the current document across edits rather than a mount-time snapshot. */
+    getDocument: () => DocumentView | undefined;
+    /** The editor's content version, so a widget can memoize a document-wide derivation
+     *  on it. Absent in a bare harness. */
+    getContentVersion?: () => number;
+    /** The editor's navigation door, forwarded to widgets whose gesture jumps elsewhere. */
+    navigateTo?: (path: number[]) => Promise<boolean>;
+    /** Position-sorted islands. A getter read inside the render pass on purpose: that
+     *  read is the reactive dependency that re-renders the cell on an island change. */
+    get islands(): IndexedDecoration<WidgetDecoration | ReplaceDecoration>[];
+    /** A widget's synchronous mount throw goes to the editor's `error` channel. Absent →
+     *  unsurfaced; the widget still falls back to its raw source. */
+    reportRenderError?: (error: unknown) => void;
+}
+export interface CellRender {
+    /**
+     * Rebuild the cell's children from current node state. Skips work on an unchanged
+     * memo key unless `forceRebuild` — pass it when a pending cursor restore needs the
+     * DOM re-anchored even though the key held.
+     */
+    render(opts?: {
+        forceRebuild?: boolean;
+        carryCaret?: boolean;
+    }): void;
+    /** Destroy every pooled widget instance and mounted island — called on unmount. */
+    dispose(): void;
+}
+export declare function createCellRender(deps: CellRenderDeps): CellRender;

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

@@ -0,0 +1,98 @@
+/**
+ * DOM-build for TableCellBlock's render $effect. Mirrors text-render.ts without the
+ * ambient prefix or block marker — a cell's entire raw is content, so every island
+ * offset is a raw offset. The component owns the effect and the pending-cursor
+ * restore; this factory owns the imperative build.
+ */
+import { computeInlineContent, contentLengthOf } from '../../../core/inline';
+import { renderInlineNodes } from '../../../core/inline-render';
+import { trimTrailingLineEnding } from '../../../core/lines';
+import { captureFocusedCaretWalkOffset, restoreCaretAtWalkOffset } from '../../../cursor/focused-caret';
+import { CONTENT_EMPTY_ATTR, holdsOnlyMarkerChrome } from '../../../cursor/widget-offset';
+import { applyIslandDecorations, islandRenderKeyPart } from '../../../decorations/island-dom';
+import { mountDecorationWidget } from '../../../decorations/widget-dom';
+import { devWarn } from '../../../dev-warn';
+import { getBlockKindDescriptor } from '../../../schema/block-kind-descriptor';
+import { createSvelteWidgetPool } from '../widget-portal';
+export function createCellRender(deps) {
+    let lastRenderedKey = '';
+    const widgetPool = createSvelteWidgetPool({
+        reportError: deps.reportRenderError,
+        getPresentationMode: () => deps.presentationMode,
+        getTheme: deps.getTheme,
+        getDocument: deps.getDocument,
+        getContentVersion: deps.getContentVersion,
+        navigateTo: deps.navigateTo
+    });
+    let islandDestroys = [];
+    function destroyIslands() {
+        for (const destroy of islandDestroys)
+            destroy();
+        islandDestroys = [];
+    }
+    function buildPortalWidget(node, raw) {
+        return widgetPool.acquire(node.kind, node, raw.slice(node.start, node.end));
+    }
+    function render(opts) {
+        const el = deps.el;
+        if (!el)
+            return;
+        const node = deps.node;
+        // Gating both the signature dependency and the resolver read on the bracket keeps
+        // an LRD change from re-rendering every cell. A false positive re-parses identically.
+        const hasRef = node.raw.includes('[');
+        // Key on the compact signature epoch, never the ~MB-scale string (text-render's twin).
+        const sig = hasRef ? String(deps.linkRef?.epoch ?? deps.linkRef?.signature ?? '') : '';
+        // Unconditional, unlike the ref gating: a mode flip re-renders every mounted cell.
+        // '' in source keeps the default key byte-identical but for one NUL (text-render's twin).
+        const mode = deps.presentationMode;
+        const modeKeyPart = mode === 'source' ? '' : mode;
+        const islands = deps.islands;
+        const renderKey = `${node.raw}\0${sig}\0${modeKeyPart}${islandRenderKeyPart(islands)}`;
+        const forceRebuild = opts?.forceRebuild ?? false;
+        if (renderKey === lastRenderedKey && !forceRebuild)
+            return;
+        const content = computeInlineContent(node, hasRef ? deps.linkRef?.current : undefined);
+        // An island-signature change rebuilds a focused cell with no edit-path pending
+        // offset, so carry the caret in walk space; the edit path opts out because its
+        // own restore runs after and wins (text-render's twin).
+        const caretWalkOffset = (opts?.carryCaret ?? true) ? captureFocusedCaretWalkOffset(el) : null;
+        // Bracketing the rebuild pools portal widgets, so an unchanged `$…$` keeps its
+        // instance across per-keystroke rebuilds. Island widgets are unpooled.
+        widgetPool.beginPass();
+        destroyIslands();
+        el.replaceChildren(renderInlineNodes(content, node.raw, {
+            renderImagesAsWidgets: getBlockKindDescriptor(node.kind).renderImagesAsWidgets ?? true,
+            resolveLinkUrl: deps.resolveLinkUrl,
+            buildPortalWidget
+        }));
+        // Ambient length 0: a cell carries no marker, so island offsets are raw offsets.
+        islandDestroys = applyIslandDecorations(el, node.raw, islands, {
+            contentLength: contentLengthOf(node),
+            ambientLength: 0,
+            mountWidget: (spec, dec) => mountDecorationWidget(spec, dec, deps.reportRenderError),
+            onSkipped: (dec, reason) => devWarn('decorations', `island skipped: ${reason}`, dec)
+        });
+        widgetPool.sweep();
+        lastRenderedKey = renderKey;
+        // An empty cell needs a `<br>` caret anchor, but a `<br>` inside an island
+        // belongs to the widget, not the cell — it must not satisfy the anchor.
+        if (trimTrailingLineEnding(node.raw) === '') {
+            const hasAnchorBr = [...el.querySelectorAll('br')].some((br) => !br.closest('[data-decoration-island]'));
+            if (!hasAnchorBr)
+                el.appendChild(document.createElement('br'));
+        }
+        // A cell whose whole content is an empty construct (`[](u)`) would otherwise paint
+        // nothing; the stamp precedes the restore, which lands through the same walk.
+        el.toggleAttribute(CONTENT_EMPTY_ATTR, holdsOnlyMarkerChrome(el));
+        if (caretWalkOffset !== null)
+            restoreCaretAtWalkOffset(el, caretWalkOffset);
+    }
+    return {
+        render,
+        dispose: () => {
+            destroyIslands();
+            widgetPool.dispose();
+        }
+    };
+}

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

@@ -0,0 +1,12 @@
+/**
+ * How a cell resolves the table's structural commands: a command id names a
+ * `TableContext` mutation plus which of the cell's two coordinates indexes it.
+ * The chord half lives on the `tableCell` keymap.
+ */
+import type { TableAxisAction } from '../../../action-contracts';
+import type { AnyCommandId } from '../../../schema/command-id';
+export type CommandAxis = 'row' | 'column';
+export declare function tableAxisCommand(id: AnyCommandId): {
+    action: TableAxisAction;
+    axis: CommandAxis;
+} | null;

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

@@ -0,0 +1,21 @@
+/**
+ * How a cell resolves the table's structural commands: a command id names a
+ * `TableContext` mutation plus which of the cell's two coordinates indexes it.
+ * The chord half lives on the `tableCell` keymap.
+ */
+const TABLE_AXIS_COMMANDS = {
+    'table.insertRowBelow': { action: 'insertRowBelow', axis: 'row' },
+    'table.insertRowAbove': { action: 'insertRowAbove', axis: 'row' },
+    'table.insertColumnRight': { action: 'insertColumnRight', axis: 'column' },
+    'table.insertColumnLeft': { action: 'insertColumnLeft', axis: 'column' },
+    'table.deleteRow': { action: 'deleteRow', axis: 'row' },
+    'table.deleteColumn': { action: 'deleteColumn', axis: 'column' },
+    'table.moveRowUp': { action: 'moveRowUp', axis: 'row' },
+    'table.moveRowDown': { action: 'moveRowDown', axis: 'row' },
+    'table.moveColumnLeft': { action: 'moveColumnLeft', axis: 'column' },
+    'table.moveColumnRight': { action: 'moveColumnRight', axis: 'column' },
+    'table.cycleAlignment': { action: 'cycleAlignment', axis: 'column' }
+};
+export function tableAxisCommand(id) {
+    return TABLE_AXIS_COMMANDS[id] ?? null;
+}

package/dist/components/blocks/table/cell-x-mapping.d.ts

@@ -0,0 +1,6 @@
+import type { EditorX } from '../../../cursor/coordinate-spaces';
+export interface ColumnRect {
+    left: number;
+    right: number;
+}
+export declare function columnNearestX(x: EditorX, rects: ColumnRect[]): number;

package/dist/components/blocks/table/cell-x-mapping.js

@@ -0,0 +1,16 @@
+// Pick the column whose horizontal range contains an editor-relative pixel X, so
+// arrowing into the table lands near where the caret was horizontally. The result is
+// a column index, not a row-major cell index.
+export function columnNearestX(x, rects) {
+    if (rects.length === 0)
+        return 0;
+    if (x < rects[0].left)
+        return 0;
+    if (x >= rects[rects.length - 1].right)
+        return rects.length - 1;
+    for (let i = 0; i < rects.length; i++) {
+        if (x >= rects[i].left && x < rects[i].right)
+            return i;
+    }
+    return rects.length - 1;
+}

package/dist/components/blocks/table/selected-cells.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Which cells of one table a measurement request covers: a live intra-table
+ * rectangle, or a plain `[start, end)` run of row-major cell indices. The rectangle
+ * wins only when it belongs to THIS table.
+ */
+import type { IntraTableRect } from './cell-clipboard';
+import type { CellCoord } from './table-navigation';
+export interface SelectedCellsInput {
+    /** The live rectangle from anywhere in the document, or null. */
+    rect: IntraTableRect | null;
+    /** This table's doc path — the owner check against `rect.tablePath`. */
+    myPath: readonly number[];
+    start: number;
+    /** `SELECTION_END` means "through the last cell". */
+    end: number;
+    rowCount: number;
+    columnCount: number;
+}
+export declare function selectedCells(input: SelectedCellsInput): CellCoord[];

package/dist/components/blocks/table/selected-cells.js

@@ -0,0 +1,35 @@
+/**
+ * Which cells of one table a measurement request covers: a live intra-table
+ * rectangle, or a plain `[start, end)` run of row-major cell indices. The rectangle
+ * wins only when it belongs to THIS table.
+ */
+import { SELECTION_END } from '../../../block-component';
+import { cellRowCol } from '../../../cursor/coordinate-spaces';
+import { pathsEqual } from '../../../selection/path-math';
+export function selectedCells(input) {
+    const { rect, myPath, columnCount, rowCount } = input;
+    if (rect && pathsEqual(rect.tablePath, myPath)) {
+        return rectangleCells(rect, columnCount);
+    }
+    const cellCount = rowCount * columnCount;
+    const end = input.end === SELECTION_END ? cellCount : Math.min(input.end, cellCount);
+    const cells = [];
+    for (let i = Math.max(0, input.start); i < end; i++)
+        cells.push(coordOf(i, columnCount));
+    return cells;
+}
+function rectangleCells(rect, columnCount) {
+    const a = coordOf(rect.anchorCellIdx, columnCount);
+    const b = coordOf(rect.focusCellIdx, columnCount);
+    const cells = [];
+    for (let r = Math.min(a.rowIdx, b.rowIdx); r <= Math.max(a.rowIdx, b.rowIdx); r++) {
+        for (let c = Math.min(a.colIdx, b.colIdx); c <= Math.max(a.colIdx, b.colIdx); c++) {
+            cells.push({ rowIdx: r, colIdx: c });
+        }
+    }
+    return cells;
+}
+function coordOf(cellIdx, columnCount) {
+    const { row, col } = cellRowCol(cellIdx, columnCount);
+    return { rowIdx: row, colIdx: col };
+}

package/dist/components/blocks/table/table-caret-at-point.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Table's `caretTargetAtPoint`: the cell a point lands a caret in, as a `[rowIdx, colIdx]` path
+ * plus a within-cell offset. NEAREST, not exact — the difference from `tableDragHitTest` beside
+ * it. A point clamped into the table's box can sit in a gutter, a padding gap or a windowing
+ * spacer and must still land a caret, where an exact `elementFromPoint` hit declines.
+ */
+import type { CaretTarget } from '../../../schema/block-kind-descriptor';
+export declare function tableCaretAtPoint(blockEl: HTMLElement, clientX: number, clientY: number): CaretTarget | null;

package/dist/components/blocks/table/table-caret-at-point.js

@@ -0,0 +1,35 @@
+/**
+ * Table's `caretTargetAtPoint`: the cell a point lands a caret in, as a `[rowIdx, colIdx]` path
+ * plus a within-cell offset. NEAREST, not exact — the difference from `tableDragHitTest` beside
+ * it. A point clamped into the table's box can sit in a gutter, a padding gap or a windowing
+ * spacer and must still land a caret, where an exact `elementFromPoint` hit declines.
+ */
+import { CURSOR_END } from '../../../block-component';
+import { mountedRowEls, rowCellEls } from './cell-pointer';
+export function tableCaretAtPoint(blockEl, clientX, clientY) {
+    const tableEl = blockEl.querySelector(':scope > [role="table"]');
+    if (!tableEl)
+        return null;
+    let nearest = null;
+    let smallestDistance = Infinity;
+    for (const rowEl of mountedRowEls(tableEl)) {
+        // The ABSOLUTE row index: under row windowing the first mounted row is not row 0.
+        const rowIdx = Number(rowEl.getAttribute('data-table-row-idx'));
+        if (Number.isNaN(rowIdx))
+            continue;
+        rowCellEls(rowEl).forEach((cell, colIdx) => {
+            const distance = squaredDistanceToBox(cell.getBoundingClientRect(), clientX, clientY);
+            if (distance < smallestDistance) {
+                smallestDistance = distance;
+                nearest = [rowIdx, colIdx];
+            }
+        });
+    }
+    return nearest === null ? null : { path: nearest, offset: CURSOR_END };
+}
+// Squared: only the ordering is read, and ties keep the first (lowest row, then column).
+function squaredDistanceToBox(box, x, y) {
+    const dx = x < box.left ? box.left - x : x > box.right ? x - box.right : 0;
+    const dy = y < box.top ? box.top - y : y > box.bottom ? y - box.bottom : 0;
+    return dx * dx + dy * dy;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Cell text ingestion for tableCell: the caret mapping that follows the sink's
+ * inserted backslashes, plus the paste hooks exposed as a PasteSurface. The bytes
+ * are the kind's business — every hook hands back plain spliced text and
+ * `normalizeCellRaw` runs at the write sink.
+ */
+import type { CstNode } from '../../../core/nodes';
+import type { InlinePasteResult, PasteRange, PasteSeam, PasteSurface } from '../../../tree-operations/paste-surfaces';
+export declare function normalizeWhitespace(s: string): string;
+/**
+ * Where `offset` lands once the sink's `normalizeCellRaw` has run — defined as that
+ * same pass over the prefix, so the caret cannot drift out of step with the bytes.
+ */
+export declare function escapedCellOffset(text: string, offset: number): number;
+export declare function tableCellInlinePaste(node: CstNode, offset: number, text: string, preDelete?: PasteRange, seam?: PasteSeam): InlinePasteResult;
+export declare const tableCellPasteSurface: PasteSurface;

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

@@ -0,0 +1,75 @@
+/**
+ * Cell text ingestion for tableCell: the caret mapping that follows the sink's
+ * inserted backslashes, plus the paste hooks exposed as a PasteSurface. The bytes
+ * are the kind's business — every hook hands back plain spliced text and
+ * `normalizeCellRaw` runs at the write sink.
+ */
+import { CURSOR_END } from '../../../block-component';
+import { normalizeCellRaw } from '../../../schema/table-cell-raw';
+import { blockNodeAt, cutRangeFromDisplay } from '../../../tree-operations/node-ops';
+import { sliceTableAtRow } from '../../../tree-operations/paste/table-slice';
+import { focusIndexBeforeResidue } from '../../../tree-operations/paste/focus-target';
+import { replaceBlockAtParent } from '../../../tree-operations/paste/replace-block-at-parent';
+// ── Public API ─────────────────────────────────────────────────────────────
+export function normalizeWhitespace(s) {
+    return s.replace(/\n+/g, ' ').trim();
+}
+/**
+ * Where `offset` lands once the sink's `normalizeCellRaw` has run — defined as that
+ * same pass over the prefix, so the caret cannot drift out of step with the bytes.
+ */
+export function escapedCellOffset(text, offset) {
+    return normalizeCellRaw(text.slice(0, offset)).length;
+}
+export function tableCellInlinePaste(node, offset, text, preDelete, seam) {
+    const cleaned = normalizeWhitespace(text);
+    // The delete half crosses the join seam BEFORE the escaping stage (live-mode.md § 4.5): the
+    // seam reads and writes the cell's own display bytes, and `normalizeCellRaw` still runs at the
+    // sink over whatever they end up being.
+    const { display: raw, offset: effectiveOffset } = cutRangeFromDisplay(node, node.raw, preDelete ?? { start: offset, end: offset }, seam?.presentationMode, seam?.linkRef);
+    const spliced = raw.slice(0, effectiveOffset) + cleaned + raw.slice(effectiveOffset);
+    // Escaped space, because the sink escapes the whole spliced raw and not just the
+    // pasted text: the insertion point can sit between a `\` and the `|` it frees.
+    return {
+        newRaw: spliced,
+        caretOffset: escapedCellOffset(spliced, effectiveOffset + cleaned.length)
+    };
+}
+export const tableCellPasteSurface = {
+    kind: 'tableCell',
+    blankEdgesArePackaging: true,
+    onInlinePaste: tableCellInlinePaste,
+    onScopedStructuralPaste: tableCellScopedStructuralPaste
+};
+// ── Internal ───────────────────────────────────────────────────────────────
+// The cell's blockEdit is the row-level nested bundle (its `replaceBlock` targets the
+// row's cells), so the splice routes through `replaceBlockAtParent` at the table's parent.
+async function tableCellScopedStructuralPaste(input) {
+    const tablePath = input.targetPath.slice(0, -2);
+    const rowIdx = input.targetPath[input.targetPath.length - 2];
+    const table = blockNodeAt(input.doc, tablePath);
+    // Malformed path: swallow the paste.
+    if (!table || table.kind !== 'table')
+        return;
+    const { firstHalf, secondHalf } = sliceTableAtRow(table, rowIdx, 'first');
+    const replacement = [];
+    if (firstHalf)
+        replacement.push(firstHalf);
+    // Appended, never spread: a paste can outnumber an argument list (G4.60).
+    for (const block of input.blocks)
+        replacement.push(block);
+    if (secondHalf)
+        replacement.push(secondHalf);
+    await replaceBlockAtParent({
+        doc: input.doc,
+        blockPath: tablePath,
+        replacement,
+        controller: input.controller,
+        undoEntry: input.undoEntry,
+        // The last pasted block, before the second table half (the residue).
+        focusReplacementIndex: focusIndexBeforeResidue(replacement.length, secondHalf !== null),
+        focusOffset: CURSOR_END,
+        source: 'paste-dispatch-table-cell',
+        ...(input.grammar ? { grammar: input.grammar } : {})
+    });
+}

package/dist/components/blocks/table/table-drag-hit-test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Table's `foreignDragHitTest`: a foreign drag's viewport point → a row-major cellIdx.
+ * Owns the encoding so the selection layer stays free of table-DOM knowledge.
+ */
+export declare function tableDragHitTest(blockEl: HTMLElement, clientX: number, clientY: number): number | null;

package/dist/components/blocks/table/table-drag-hit-test.js

@@ -0,0 +1,20 @@
+/**
+ * Table's `foreignDragHitTest`: a foreign drag's viewport point → a row-major cellIdx.
+ * Owns the encoding so the selection layer stays free of table-DOM knowledge.
+ */
+import { cellAtPoint, mountedRowEls, rowCellEls } from './cell-pointer';
+export function tableDragHitTest(blockEl, clientX, clientY) {
+    const tableEl = blockEl.querySelector(':scope > [role="table"]');
+    if (!tableEl)
+        return null;
+    const cell = cellAtPoint(clientX, clientY, tableEl);
+    if (!cell)
+        return null;
+    const firstRow = mountedRowEls(tableEl)[0];
+    if (!firstRow)
+        return null;
+    const columnCount = rowCellEls(firstRow).length;
+    if (columnCount === 0)
+        return null;
+    return cell.rowIdx * columnCount + cell.colIdx;
+}

package/dist/components/blocks/table/table-drop-target.d.ts

@@ -0,0 +1 @@
+export declare function dropGapIndex(pointer: number, edges: number[]): number;

package/dist/components/blocks/table/table-drop-target.js

@@ -0,0 +1,16 @@
+// Map a reorder drag's pointer to the insertion gap it sits nearest. `edges` are the
+// row/column boundaries in pointer space, so N tracks yield N+1 edges. The result is a
+// gap index, not the occupied cell `table-drag-hit-test` returns.
+export function dropGapIndex(pointer, edges) {
+    let nearest = 0;
+    let nearestDistance = Infinity;
+    for (let i = 0; i < edges.length; i++) {
+        const distance = Math.abs(pointer - edges[i]);
+        // Strict `<` keeps the lower gap when the pointer is exactly equidistant.
+        if (distance < nearestDistance) {
+            nearest = i;
+            nearestDistance = distance;
+        }
+    }
+    return nearest;
+}