@voithos-labs/aragonite 0.10.1

package/dist/selection/range-delete-chrome.js

@@ -0,0 +1,105 @@
+/**
+ * Reserved-chrome branch of rangeDelete, the wall rule: nothing merges across a
+ * `reservedChrome` container's wall. Outside endpoints truncate in place, covered chrome clears
+ * (never node-deletes, G1.14), covered body children delete, and the container dies only when
+ * the range consumes its whole subtree, then as ONE splice with children intact.
+ */
+import { displayLength } from '../core/lines';
+import { comparePaths, pathsEqual } from './path-math';
+import { resolveEndWall, planCrossBlockDeletion, applyPlannedDeletion, truncateEndInPlace, truncateStartInPlace } from './range-delete-ceremony';
+import { ensureUnsharedPath, rebuildUnsharedChain } from '../tree-operations/unshare';
+import { reservedChromeKindOf, isReservedChromeChild } from '../schema/reserved-chrome';
+// ── Public API ──────────────────────────────────────────────────────────────
+/**
+ * True when the range must take the wall path: an endpoint sits inside a `reservedChrome`
+ * container the range crosses out of or into, or the range starts in the chrome leaf itself.
+ * Same-block, body-only, and enclose-from-outside ranges stay on the generic path.
+ */
+export function involvesReservedChrome(doc, start, end) {
+    if (comparePaths(start.path, end.path) === 0)
+        return false;
+    const startC = nearestChromeContainer(doc, start.path);
+    const endC = nearestChromeContainer(doc, end.path);
+    if (!startC && !endC)
+        return false;
+    if (startC && endC && pathsEqual(startC.path, endC.path)) {
+        return isChromeChild(startC, start.path);
+    }
+    return true;
+}
+/**
+ * Delete [start, end] under the wall rule. Both endpoints truncate in place (chrome by a raw
+ * write, keeping the kind via contextDependentKind; prose by a reparse of the surviving slice),
+ * and nothing merges across the wall. Collapsed caret keeps generic start-position semantics.
+ */
+export function chromeAwareRangeDelete(doc, start, end, sharing, grammar, presentationMode, linkRef) {
+    const startC = nearestChromeContainer(doc, start.path);
+    const endC = nearestChromeContainer(doc, end.path);
+    const live = { presentationMode, linkRef };
+    // Own every written spine BEFORE identities are captured (G1.9): chains stay valid across
+    // splices, paths don't.
+    const startChain = ensureUnsharedPath(doc, start.path, sharing);
+    const endChain = ensureUnsharedPath(doc, end.path, sharing);
+    // Shared deletion plan (range-delete-ceremony.ts). Chrome marks no endpoint paths for
+    // deletion: both endpoints truncate in place below. resolveEndWall returns null when start
+    // sits inside the end container, which needs no chrome-clear either way, since that
+    // container's chrome child 0 never lands in the strictly-between walk.
+    const wall = resolveEndWall(doc, start, end, null);
+    const endConsumed = wall?.consumed ?? false;
+    const { plan, lcaPath } = planCrossBlockDeletion(doc, start, end, [], wall, sharing);
+    // End truncates in place first (its path is still live), the wall: its tail never merges
+    // into start. Skipped when its container dies whole.
+    if (!endConsumed) {
+        truncateEndInPlace(doc, end, endChain[endChain.length - 1], endC !== null && isChromeChild(endC, end.path), live, sharing, 'chromeAwareRangeDelete:end');
+    }
+    applyPlannedDeletion(doc, plan, lcaPath);
+    // Start truncates in place; every deletion sits after it in doc order, so start.path is
+    // still live.
+    const seam = truncateStartInPlace(doc, start, startChain[startChain.length - 1], startC !== null && isChromeChild(startC, start.path), live, sharing, 'chromeAwareRangeDelete:start');
+    // Chain-based rebuilds: node references survive the splices above where paths may not, and
+    // every touched container re-emits raw (G1.12).
+    rebuildUnsharedChain(doc, startChain, sharing, null, grammar);
+    rebuildUnsharedChain(doc, endChain, sharing, null, grammar);
+    return {
+        newDoc: doc,
+        collapsedCaret: { path: start.path.slice(), offset: seam }
+    };
+}
+/** Deepest strict ancestor of `path` whose kind declares reservedChrome. */
+export function nearestChromeContainer(doc, path) {
+    let found = null;
+    let children = doc.children;
+    for (let i = 0; i < path.length - 1; i++) {
+        const node = children[path[i]];
+        if (!node)
+            break;
+        if (reservedChromeKindOf(node.kind) !== undefined) {
+            found = { path: path.slice(0, i + 1), node };
+        }
+        children = node.children ?? [];
+    }
+    return found;
+}
+export function isChromeChild(container, leafPath) {
+    return (leafPath.length === container.path.length + 1 &&
+        isReservedChromeChild(container.node, leafPath[container.path.length]));
+}
+/**
+ * The range's end lands on the container's last byte: every step from the container is a
+ * last-child edge and the offset consumes the block's visible text.
+ */
+export function rangeConsumesContainer(container, end) {
+    const endNode = lastChildDescendant(container, end.path);
+    return endNode !== null && end.offset >= displayLength(endNode.raw);
+}
+/** The node at `path` when every step from the container is a last-child edge, else null. */
+export function lastChildDescendant(container, path) {
+    let node = container.node;
+    for (let i = container.path.length; i < path.length; i++) {
+        const children = node.children ?? [];
+        if (path[i] !== children.length - 1)
+            return null;
+        node = children[path[i]];
+    }
+    return node;
+}

package/dist/selection/range-delete-table-coverage.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Intra-table coverage-driven delete: a full-table/row/column selection lands inside one table
+ * block, so it routes to a structural delete of that table/row/column rather than the
+ * cross-block range delete. Subset (cell) coverage returns null for the caller's cell-clear.
+ */
+import { type SelectionPoint } from './primitives';
+import type { CstNode } from '../core/nodes';
+import type { CrossBlockDeleteOptions, CrossBlockMutationContext } from './cross-block/ops';
+/**
+ * Coverage of an intra-table cell-index range, driving the Backspace dispatch: a full
+ * table/row/column deletes structurally, anything else clears cells.
+ */
+export type TableCoverage = {
+    kind: 'table';
+} | {
+    kind: 'row';
+    rowIdx: number;
+} | {
+    kind: 'column';
+    colIdx: number;
+} | {
+    kind: 'cells';
+};
+export declare function classifyTableSelectionCoverage(startCellIdx: number, endCellIdx: number, columnCount: number, rowCount: number): TableCoverage;
+/** Null when the selection doesn't qualify (subset coverage, or a guard refusal). */
+export declare function maybeCommitTableCoverageDelete(ctx: CrossBlockMutationContext, table: CstNode, start: SelectionPoint, end: SelectionPoint, options: Pick<CrossBlockDeleteOptions, 'undoEntry'> | undefined, caretRestore: ((caret: SelectionPoint | null) => void) | undefined): Promise<{
+    caret: SelectionPoint | null;
+} | null>;

package/dist/selection/range-delete-table-coverage.js

@@ -0,0 +1,168 @@
+/**
+ * Intra-table coverage-driven delete: a full-table/row/column selection lands inside one table
+ * block, so it routes to a structural delete of that table/row/column rather than the
+ * cross-block range delete. Subset (cell) coverage returns null for the caller's cell-clear.
+ */
+import { deleteSnapshot } from './primitives';
+import { metadataOf } from '../core/nodes';
+import { deleteNode, emptyParagraph } from '../tree-operations/node-ops';
+import { trailingLineEnding } from '../core/lines';
+import { expectStateForNode, getStateForNode } from '../reactivity/state-registry';
+import { deleteRow as mutDeleteRow, deleteColumn as mutDeleteColumn, canDeleteRow, canDeleteColumn } from '../tree-operations/table-mutations';
+import { ensureUnsharedChildren } from '../tree-operations/unshare';
+import { cellRowCol, docPathFrom } from '../cursor/coordinate-spaces';
+export function classifyTableSelectionCoverage(startCellIdx, endCellIdx, columnCount, rowCount) {
+    const lo = Math.min(startCellIdx, endCellIdx);
+    const hi = Math.max(startCellIdx, endCellIdx);
+    const cellCount = columnCount * rowCount;
+    if (lo === 0 && hi === cellCount - 1)
+        return { kind: 'table' };
+    const { row: startRow, col: startCol } = cellRowCol(lo, columnCount);
+    const { row: endRow, col: endCol } = cellRowCol(hi, columnCount);
+    if (startRow === endRow && startCol === 0 && endCol === columnCount - 1) {
+        return { kind: 'row', rowIdx: startRow };
+    }
+    if (startCol === endCol && startRow === 0 && endRow === rowCount - 1) {
+        return { kind: 'column', colIdx: startCol };
+    }
+    return { kind: 'cells' };
+}
+/** Null when the selection doesn't qualify (subset coverage, or a guard refusal). */
+export async function maybeCommitTableCoverageDelete(ctx, table, start, end, options, caretRestore) {
+    const meta = metadataOf(table, 'table');
+    const columnCount = meta.columnCount;
+    const rowCount = table.children?.length ?? 0;
+    // Same-path intra-table endpoints are context-established, not flagged, so they read directly.
+    const coverage = classifyTableSelectionCoverage(start.offset, end.offset, columnCount, rowCount);
+    switch (coverage.kind) {
+        case 'cells':
+            return null;
+        case 'table':
+            return { caret: await commitFullTableDelete(ctx, start, options, caretRestore) };
+        case 'row': {
+            // Mirror Ctrl+Shift+Backspace: ≥1 body row must remain. Refusal is a silent no-op, since
+            // falling through to a cell-clear would rewrite the user's intent.
+            if (!canDeleteRow(coverage.rowIdx, rowCount))
+                return { caret: null };
+            const caret = await commitRowDelete(ctx, table, start, coverage.rowIdx, options, caretRestore);
+            return { caret };
+        }
+        case 'column': {
+            // Mirror Alt+Shift+Backspace: ≥2 columns must remain.
+            if (!canDeleteColumn(columnCount))
+                return { caret: null };
+            const caret = await commitColumnDelete(ctx, table, start, coverage.colIdx, options, caretRestore);
+            return { caret };
+        }
+    }
+}
+async function commitFullTableDelete(ctx, start, options, caretRestore) {
+    const tableIdx = start.path[0];
+    const snapshot = deleteSnapshot(options, [tableIdx]);
+    let collapsedCaret = null;
+    await ctx.controller.commitStructural({
+        snapshot,
+        mutate: (children) => {
+            // Read before the delete: with the table gone no block is left to take an ending
+            // from, and the filler below IS a line ending (G4.20).
+            const lineEnding = trailingLineEnding(children[tableIdx]?.raw ?? '\n');
+            const change = deleteNode({ children, ownerKind: undefined, owner: undefined }, tableIdx, ctx.controller.sharing);
+            ctx.selection.collapse();
+            // A sole-table doc empties to zero blocks, stranding the caret on <body>. Materialize
+            // a filler in the same commit so undo restores the table in one step.
+            if (children.length === 0) {
+                const filler = emptyParagraph('', lineEnding);
+                ctx.controller.sharing.stamp(filler);
+                children.push(filler);
+                collapsedCaret = { path: [0], offset: 0 };
+                return { op: 'replace', at: 0, count: 1, newCount: 1 };
+            }
+            const survivorIdx = Math.min(tableIdx, children.length - 1);
+            collapsedCaret = { path: [survivorIdx], offset: 0 };
+            return change;
+        },
+        op: {
+            kind: 'delete',
+            detail: { crossBlock: true, table: 'whole' },
+            eventPath: docPathFrom([tableIdx])
+        },
+        afterTick: caretRestore ? () => caretRestore(collapsedCaret) : undefined
+    });
+    return collapsedCaret;
+}
+async function commitRowDelete(ctx, table, start, rowIdx, options, caretRestore) {
+    const tableIdx = start.path[0];
+    const rowsState = expectStateForNode(table);
+    const snapshot = deleteSnapshot(options, [tableIdx, rowIdx]);
+    let collapsedCaret = null;
+    await ctx.controller.commitContainerStructural({
+        containerNode: table,
+        path: [tableIdx],
+        state: rowsState,
+        snapshot,
+        mutate: (scope) => {
+            // deleteRow promotes the next row to header (a metadata write).
+            ensureUnsharedChildren(scope.node, scope.sharing);
+            mutDeleteRow(scope.node, rowIdx);
+            const newRowCount = scope.node.children?.length ?? 0;
+            const targetRow = Math.min(rowIdx, Math.max(0, newRowCount - 1));
+            collapsedCaret = { path: [tableIdx, targetRow, 0], offset: 0 };
+            ctx.selection.collapse();
+            return { op: 'delete', at: rowIdx, count: 1 };
+        },
+        op: {
+            kind: 'tableDeleteRow',
+            detail: { rowIdx, crossBlock: true },
+            eventPath: docPathFrom([tableIdx, rowIdx])
+        },
+        afterTick: caretRestore ? () => caretRestore(collapsedCaret) : undefined
+    });
+    return collapsedCaret;
+}
+async function commitColumnDelete(ctx, table, start, colIdx, options, caretRestore) {
+    const tableIdx = start.path[0];
+    const rowsState = expectStateForNode(table);
+    const rows = table.children ?? [];
+    // A row's BlockListState registers on mount, so a windowed-out row has none. Scope only the
+    // mounted rows for reactivity; the ensureUnsharedChildren below copy-path-on-writes EVERY
+    // row, so the per-row cell splice stays G1.9-safe regardless of mount state.
+    const mountedRowScopes = [];
+    for (let i = 0; i < rows.length; i++) {
+        const state = getStateForNode(rows[i]);
+        if (state)
+            mountedRowScopes.push({ node: rows[i], state, path: [tableIdx, i] });
+    }
+    const scopes = [
+        { node: table, state: rowsState, path: [tableIdx] },
+        ...mountedRowScopes
+    ];
+    const snapshot = deleteSnapshot(options, [tableIdx]);
+    let collapsedCaret = null;
+    await ctx.controller.commitMultiScope({
+        scopes,
+        snapshot,
+        mutate: (scopeViews) => {
+            const ownedTable = scopeViews[0].node;
+            // Unshare every row before the splice: mounted rows are already owned via their
+            // scope, and this reaches the windowed-out rows the scopes skip.
+            ensureUnsharedChildren(ownedTable, scopeViews[0].sharing);
+            mutDeleteColumn(ownedTable, colIdx);
+            const newColumnCount = metadataOf(ownedTable, 'table').columnCount;
+            const targetCol = Math.min(colIdx, Math.max(0, newColumnCount - 1));
+            collapsedCaret = { path: [tableIdx, 0, targetCol], offset: 0 };
+            ctx.selection.collapse();
+            // Every mounted row loses the same cell; the table scope is a no-op.
+            const rowDelete = { op: 'delete', at: colIdx, count: 1 };
+            return [{ op: 'noop' }, ...mountedRowScopes.map(() => rowDelete)];
+        },
+        // Event targets the TABLE: a column index is not a child path (parity with
+        // table-context's column ops), so colIdx rides in the detail.
+        op: {
+            kind: 'tableDeleteColumn',
+            detail: { colIdx, crossBlock: true },
+            eventPath: docPathFrom([tableIdx])
+        },
+        afterTick: caretRestore ? () => caretRestore(collapsedCaret) : undefined
+    });
+    return collapsedCaret;
+}

package/dist/selection/range-delete-table.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Table-aware branch of rangeDelete: tables encode selection offsets as cell indices, so prose
+ * raw-merge doesn't apply. Post-delete survivors are located by identity scan
+ * ({@link survivorPath}), not index arithmetic, because deletions and cascade cleanup shift
+ * sibling indices at arbitrary depths. One early-exiting scan per delete, and it rides the cold
+ * Backspace/Delete gesture, so the linear cost is accepted.
+ */
+import type { GrammarView } from '../schema/block-openers';
+import type { PresentationMode } from '../presentation-mode';
+import type { InlineResolverRef } from '../schema/inline-construct-policy';
+import type { CstNode, Document } from '../core/nodes';
+import type { SelectionPoint } from './primitives';
+import type { RangeDeleteResult } from './range-delete';
+import type { SharingState } from '../tree-operations/sharing';
+export declare function involvesTable(startBlock: CstNode, endBlock: CstNode): boolean;
+export declare function tableAwareRangeDelete(doc: Document, start: SelectionPoint, end: SelectionPoint, sharing: SharingState, grammar: GrammarView | undefined, presentationMode?: PresentationMode, linkRef?: InlineResolverRef): RangeDeleteResult;

package/dist/selection/range-delete-table.js

@@ -0,0 +1,347 @@
+/**
+ * Table-aware branch of rangeDelete: tables encode selection offsets as cell indices, so prose
+ * raw-merge doesn't apply. Post-delete survivors are located by identity scan
+ * ({@link survivorPath}), not index arithmetic, because deletions and cascade cleanup shift
+ * sibling indices at arbitrary depths. One early-exiting scan per delete, and it rides the cold
+ * Backspace/Delete gesture, so the linear cost is accepted.
+ */
+import { metadataOf } from '../core/nodes';
+import { displayLength, trailingLineEnding } from '../core/lines';
+import { cellRowCol } from '../cursor/coordinate-spaces';
+import { cellIndexOf } from './primitives';
+import { resolveEndWall, planCrossBlockDeletion, applyPlannedDeletion, rebuildSharedAncestries, truncateEndInPlace, truncateStartInPlace } from './range-delete-ceremony';
+import { comparePaths } from './path-math';
+import { blockNodeAt, emptyParagraph } from '../tree-operations/node-ops';
+import { ensureUnsharedNode, ensureUnsharedPath, ensureUnsharedSubtree, rebuildOwnedContainer, rebuildUnsharedAncestry } from '../tree-operations/unshare';
+import { rebuildTableRowRaw } from '../schema/container-rebuilders';
+import { isCollapsedContainer } from '../schema/reserved-chrome';
+import { nearestChromeContainer, isChromeChild } from './range-delete-chrome';
+// ── Public API ──────────────────────────────────────────────────────────────
+export function involvesTable(startBlock, endBlock) {
+    return startBlock.kind === 'table' || endBlock.kind === 'table';
+}
+export function tableAwareRangeDelete(doc, start, end, sharing, grammar, presentationMode, linkRef) {
+    const sameBlock = comparePaths(start.path, end.path) === 0;
+    const live = { presentationMode, linkRef };
+    // Own both endpoint spines (and table subtrees: cell raws, row splices, and header promotion
+    // all write at depth) before any capture or mutation.
+    const startChain = ensureUnsharedPath(doc, start.path, sharing);
+    const startBlock = startChain[startChain.length - 1] ?? ownedEndpoint(doc, start.path, sharing);
+    const endBlock = sameBlock
+        ? startBlock
+        : (ensureUnsharedPath(doc, end.path, sharing).pop() ?? ownedEndpoint(doc, end.path, sharing));
+    if (startBlock.kind === 'table')
+        ensureUnsharedSubtree(startBlock, sharing);
+    if (!sameBlock && endBlock.kind === 'table')
+        ensureUnsharedSubtree(endBlock, sharing);
+    if (sameBlock) {
+        return deleteWithinTable(doc, start, end, startBlock, sharing, grammar);
+    }
+    if (startBlock.kind === 'table' && endBlock.kind === 'table') {
+        return deleteAcrossTwoTables(doc, start, end, startBlock, endBlock, sharing, grammar);
+    }
+    if (startBlock.kind === 'table') {
+        return deleteFromTableIntoProse(doc, start, end, startBlock, endBlock, sharing, grammar, live);
+    }
+    return deleteFromProseIntoTable(doc, start, end, startBlock, endBlock, sharing, grammar, live);
+}
+/**
+ * Owned fallback for an endpoint whose unshare chain came back short: routes through the
+ * unshare seam, never a raw live-tree capture. A miss here is a caller bug.
+ */
+function ownedEndpoint(doc, path, sharing) {
+    const node = blockNodeAt(doc, path);
+    if (!node)
+        throw new Error('rangeDelete(table): endpoint path does not resolve to a block node');
+    return ensureUnsharedNode(node, sharing);
+}
+// ── Same-block: whole-table or partial-table intra-table ───────────────────
+// Caret returns as a deep [...tablePath, row, col] path so the follow-up paste / focus restore
+// lands inside the anchor cell's contenteditable instead of the table wrapper.
+function deleteWithinTable(doc, start, end, table, sharing, grammar) {
+    // Same-path intra-table endpoints are context-established, not flagged, so they read
+    // `.offset` directly; cellIndexOf would warn spuriously here.
+    clearRectangularCells(table, start.offset, end.offset);
+    rebuildUnsharedAncestry(doc, start.path, sharing, null, grammar);
+    const meta = metadataOf(table, 'table');
+    const cellsPerRow = meta.columnCount;
+    const { row: anchorRow, col: anchorCol } = cellRowCol(start.offset, cellsPerRow);
+    return {
+        newDoc: doc,
+        collapsedCaret: { path: [...start.path, anchorRow, anchorCol], offset: 0 },
+        tableRowSplices: []
+    };
+}
+function clearRectangularCells(table, anchorCellIdx, focusCellIdx) {
+    const meta = metadataOf(table, 'table');
+    const cellsPerRow = meta.columnCount;
+    const { row: aRow, col: aCol } = cellRowCol(anchorCellIdx, cellsPerRow);
+    const { row: fRow, col: fCol } = cellRowCol(focusCellIdx, cellsPerRow);
+    const minRow = Math.min(aRow, fRow);
+    const maxRow = Math.max(aRow, fRow);
+    const minCol = Math.min(aCol, fCol);
+    const maxCol = Math.max(aCol, fCol);
+    const rows = table.children;
+    for (let r = minRow; r <= maxRow; r++) {
+        const row = rows[r];
+        for (let c = minCol; c <= maxCol; c++) {
+            row.children[c].raw = '';
+        }
+        rebuildTableRowRaw(row);
+    }
+}
+// ── Case 1: prose start, table end ─────────────────────────────────────────
+function deleteFromProseIntoTable(doc, start, end, startBlock, table, sharing, grammar, live) {
+    const startC = nearestChromeContainer(doc, start.path);
+    const startIsChrome = startC !== null && isChromeChild(startC, start.path);
+    // The snapped end cell is the whole-row inclusive last cell; deleteCellsAndCollapse takes an
+    // exclusive end, so +1 clears the same rows the clipboard copied.
+    const { result, splice } = deleteCellsAndCollapse(table, 0, cellIndexOf(end, 'deleteFromProseIntoTable:end') + 1);
+    const wall = resolveEndWall(doc, start, end, result === 'tableEmpty');
+    const { plan, lcaPath } = planCrossBlockDeletion(doc, start, end, result === 'tableEmpty' ? [end.path] : [], wall, sharing);
+    applyPlannedDeletion(doc, plan, lcaPath);
+    const seam = truncateStartInPlace(doc, start, startBlock, startIsChrome, live, sharing, 'deleteFromProseIntoTable:start');
+    const tableSurvives = result === 'tableSurvives';
+    if (tableSurvives)
+        rebuildOwnedContainer(table, sharing);
+    rebuildUnsharedAncestry(doc, start.path, sharing, null, grammar);
+    rebuildSharedAncestries(doc, plan, sharing, grammar);
+    if (tableSurvives)
+        rebuildUnsharedAncestry(doc, survivorPath(doc, table), sharing, null, grammar);
+    return {
+        newDoc: doc,
+        collapsedCaret: { path: start.path.slice(), offset: seam },
+        tableRowSplices: splice ? [{ table, ...splice }] : []
+    };
+}
+// ── Case 2: table start, prose end ─────────────────────────────────────────
+function deleteFromTableIntoProse(doc, start, end, table, endBlock, sharing, grammar, live) {
+    const lineEnding = trailingLineEnding(table.raw);
+    const startCell = cellIndexOf(start, 'deleteFromTableIntoProse:start');
+    const { result: tableResult, splice } = deleteCellsAndCollapse(table, startCell, totalCellCount(table));
+    const wall = resolveEndWall(doc, start, end, null);
+    const consumed = wall?.consumed ?? false;
+    const endIsChrome = wall !== null && !consumed && isChromeChild(wall.container, end.path);
+    const { plan, lcaPath } = planCrossBlockDeletion(doc, start, end, tableResult === 'tableEmpty' ? [start.path] : [], wall, sharing);
+    // Truncate end first: its path is later in doc order, so deleting strictly-between doesn't
+    // shift it. Skipped when the container dies whole.
+    const tailNode = consumed
+        ? null
+        : truncateEndInPlace(doc, end, endBlock, endIsChrome, live, sharing, 'deleteFromTableIntoProse:end');
+    applyPlannedDeletion(doc, plan, lcaPath);
+    const tailPath = tailNode ? survivorPath(doc, tailNode) : null;
+    if (tableResult === 'tableSurvives') {
+        rebuildOwnedContainer(table, sharing);
+        rebuildUnsharedAncestry(doc, start.path, sharing, null, grammar);
+    }
+    if (tailPath)
+        rebuildUnsharedAncestry(doc, tailPath, sharing, null, grammar);
+    rebuildSharedAncestries(doc, plan, sharing, grammar);
+    // A fully consumed table lands the caret at the start of the surviving tail; otherwise in the
+    // table's surviving anchor cell, or the nearest survivor when the tail went too.
+    const collapsedCaret = tableResult === 'tableEmpty'
+        ? tailPath
+            ? { path: tailPath, offset: 0 }
+            : caretNearestSurvivor(doc, start.path, sharing, lineEnding)
+        : survivingAnchorCellCaret(table, start.path, startCell);
+    return {
+        newDoc: doc,
+        collapsedCaret,
+        tableRowSplices: splice ? [{ table, ...splice }] : []
+    };
+}
+// Deep [...tablePath, row, col] caret into the surviving table's anchor cell: the cell is
+// cleared from the anchor onward, so its end offset is its displayLength. anchorCol === 0 means
+// the anchor row itself was removed, so fall back to the previous row's last cell.
+function survivingAnchorCellCaret(table, startPath, anchorCellIdx) {
+    const cellsPerRow = metadataOf(table, 'table').columnCount;
+    const { row: anchorRow, col: anchorCol } = cellRowCol(anchorCellIdx, cellsPerRow);
+    if (anchorCol > 0) {
+        const cell = table.children[anchorRow].children[anchorCol];
+        return { path: [...startPath, anchorRow, anchorCol], offset: displayLength(cell.raw) };
+    }
+    const survivorRow = anchorRow - 1;
+    const survivorCol = cellsPerRow - 1;
+    if (survivorRow < 0) {
+        // Defensive: anchor in row 0 and that row removed. Callers collapse to 'tableEmpty'
+        // first, but the contract must not index table.children[-1].
+        return { path: [...startPath, 0, 0], offset: 0 };
+    }
+    const survivor = table.children[survivorRow].children[survivorCol];
+    return { path: [...startPath, survivorRow, survivorCol], offset: displayLength(survivor.raw) };
+}
+// ── Case 1+2 hybrid: both endpoints are tables ─────────────────────────────
+function deleteAcrossTwoTables(doc, start, end, startTable, endTable, sharing, grammar) {
+    const lineEnding = trailingLineEnding(startTable.raw);
+    const startCell = cellIndexOf(start, 'deleteAcrossTwoTables:start');
+    const { result: startResult, splice: startSplice } = deleteCellsAndCollapse(startTable, startCell, totalCellCount(startTable));
+    // The snapped end cell is the whole-row inclusive last cell; +1 for the exclusive end.
+    const { result: endResult, splice: endSplice } = deleteCellsAndCollapse(endTable, 0, cellIndexOf(end, 'deleteAcrossTwoTables:end') + 1);
+    const wall = resolveEndWall(doc, start, end, endResult === 'tableEmpty');
+    const emptiedEndpoints = [];
+    if (startResult === 'tableEmpty')
+        emptiedEndpoints.push(start.path);
+    if (endResult === 'tableEmpty')
+        emptiedEndpoints.push(end.path);
+    const { plan, lcaPath } = planCrossBlockDeletion(doc, start, end, emptiedEndpoints, wall, sharing);
+    applyPlannedDeletion(doc, plan, lcaPath);
+    const endTablePath = endResult === 'tableSurvives' ? survivorPath(doc, endTable) : null;
+    if (startResult === 'tableSurvives') {
+        rebuildOwnedContainer(startTable, sharing);
+        rebuildUnsharedAncestry(doc, start.path, sharing, null, grammar);
+    }
+    if (endTablePath) {
+        rebuildOwnedContainer(endTable, sharing);
+        rebuildUnsharedAncestry(doc, endTablePath, sharing, null, grammar);
+    }
+    rebuildSharedAncestries(doc, plan, sharing, grammar);
+    let collapsedCaret;
+    if (startResult === 'tableSurvives') {
+        // Start table keeps its slot (deletions are all at or after start.path).
+        collapsedCaret = survivingAnchorCellCaret(startTable, start.path, startCell);
+    }
+    else if (endTablePath) {
+        // Start emptied, so its block went and the end table shifted; land in its first cell.
+        collapsedCaret = { path: [...endTablePath, 0, 0], offset: 0 };
+    }
+    else {
+        collapsedCaret = caretNearestSurvivor(doc, start.path, sharing, lineEnding);
+    }
+    const tableRowSplices = [
+        ...(startSplice ? [{ table: startTable, ...startSplice }] : []),
+        ...(endSplice ? [{ table: endTable, ...endSplice }] : [])
+    ];
+    return { newDoc: doc, collapsedCaret, tableRowSplices };
+}
+// Every block the caret could land in was removed, so survivors are sought in the deleted block's
+// OWN container, walking outward when cascade cleanup took that too. `lineEnding` is the deleted
+// start table's, captured before the mutation (G4.20): nothing survives to read one from, so a
+// defaulted LF would flip a CRLF doc.
+function caretNearestSurvivor(doc, startPath, sharing, lineEnding) {
+    let containerPath = startPath.slice(0, -1);
+    let childIdx = startPath[startPath.length - 1];
+    let siblings = survivingChildren(doc, containerPath);
+    while (siblings === null && containerPath.length > 0) {
+        childIdx = containerPath[containerPath.length - 1];
+        containerPath = containerPath.slice(0, -1);
+        siblings = survivingChildren(doc, containerPath);
+    }
+    if (siblings) {
+        const beforeIdx = childIdx - 1;
+        if (beforeIdx >= 0) {
+            const before = siblings[beforeIdx];
+            const beforePath = [...containerPath, beforeIdx];
+            return before.kind === 'table'
+                ? lastCellCaret(before, beforePath)
+                : survivorEndCaret(before, beforePath);
+        }
+        return survivorStartCaret(siblings[0], [...containerPath, 0]);
+    }
+    const filler = emptyParagraph('', lineEnding);
+    sharing.stamp(filler);
+    doc.children.push(filler);
+    return { path: [0], offset: 0 };
+}
+/** A container's children when it survived with any, else null. */
+function survivingChildren(doc, path) {
+    const node = path.length === 0 ? doc : blockNodeAt(doc, path);
+    const children = node?.children;
+    return children && children.length > 0 ? children : null;
+}
+// End-of-survivor caret, descending to the leaf a caret lands in: last child at each step,
+// collapse-aware (a collapsed container's visible target is chrome child 0). The gate is
+// FOCUSABILITY, not merge-eligibility: a fenced-code leaf is editable but not merge-eligible,
+// and the merge walk would strand the caret on the container's own path.
+function survivorEndCaret(node, path) {
+    let leaf = node;
+    const leafPath = path.slice();
+    while (leaf.children && leaf.children.length > 0) {
+        const next = isCollapsedContainer(leaf) ? 0 : leaf.children.length - 1;
+        leaf = leaf.children[next];
+        leafPath.push(next);
+    }
+    return { path: leafPath, offset: displayLength(leaf.raw) };
+}
+// Start-of-survivor caret, the twin of survivorEndCaret. First child at each level is also the
+// collapse-visible chrome child, so no collapse case is needed.
+function survivorStartCaret(node, path) {
+    let leaf = node;
+    const leafPath = path.slice();
+    while (leaf.children && leaf.children.length > 0) {
+        leaf = leaf.children[0];
+        leafPath.push(0);
+    }
+    return { path: leafPath, offset: 0 };
+}
+function lastCellCaret(table, tablePath) {
+    const lastRow = table.children.length - 1;
+    const lastCol = metadataOf(table, 'table').columnCount - 1;
+    const cell = table.children[lastRow].children[lastCol];
+    return { path: [...tablePath, lastRow, lastCol], offset: displayLength(cell.raw) };
+}
+// ── Post-delete path resolution (identity scan; cost class in the file header) ─
+function survivorPath(doc, node) {
+    const path = pathOfNode(doc, node);
+    if (!path) {
+        throw new Error('tableAwareRangeDelete: surviving block not found after deletions');
+    }
+    return path;
+}
+function pathOfNode(parent, target) {
+    const children = parent.children ?? [];
+    for (let i = 0; i < children.length; i++) {
+        if (children[i] === target)
+            return [i];
+        const sub = pathOfNode(children[i], target);
+        if (sub)
+            return [i, ...sub];
+    }
+    return null;
+}
+/**
+ * Clear cells in `[startCellIdx, endCellIdx)`, remove rows fully inside the range, promote the
+ * next surviving row to header when row 0 goes. Mutates in place. Reports whether the table
+ * itself should be removed and the row window it spliced, so the commit can sync row state.
+ */
+function deleteCellsAndCollapse(table, startCellIdx, endCellIdx) {
+    if (startCellIdx >= endCellIdx)
+        return { result: 'tableSurvives', splice: null };
+    clearCellsInRange(table, startCellIdx, endCellIdx);
+    const meta = metadataOf(table, 'table');
+    const rows = table.children;
+    const cellsPerRow = meta.columnCount;
+    const { row: startRow, col: startCol } = cellRowCol(startCellIdx, cellsPerRow);
+    const { row: lastRowInRange, col: lastColInRange } = cellRowCol(endCellIdx - 1, cellsPerRow);
+    // First range row is fully covered iff startCol === 0; last iff
+    // lastColInRange === cellsPerRow - 1; middle rows always are.
+    const firstFull = startCol === 0 ? startRow : startRow + 1;
+    const lastFull = lastColInRange === cellsPerRow - 1 ? lastRowInRange : lastRowInRange - 1;
+    const headerRemoved = firstFull <= 0 && lastFull >= 0;
+    const splice = firstFull <= lastFull ? { at: firstFull, count: lastFull - firstFull + 1 } : null;
+    if (splice) {
+        rows.splice(splice.at, splice.count);
+    }
+    if (rows.length === 0)
+        return { result: 'tableEmpty', splice };
+    if (headerRemoved) {
+        metadataOf(rows[0], 'tableRow').isHeader = true;
+    }
+    return { result: 'tableSurvives', splice };
+}
+function clearCellsInRange(table, startCellIdx, endCellIdx) {
+    const meta = metadataOf(table, 'table');
+    const cellsPerRow = meta.columnCount;
+    const rows = table.children;
+    const touchedRows = new Set();
+    for (let i = startCellIdx; i < endCellIdx; i++) {
+        const { row: r, col: c } = cellRowCol(i, cellsPerRow);
+        rows[r].children[c].raw = '';
+        touchedRows.add(r);
+    }
+    for (const r of touchedRows)
+        rebuildTableRowRaw(rows[r]);
+}
+function totalCellCount(table) {
+    const meta = metadataOf(table, 'table');
+    return (table.children?.length ?? 0) * meta.columnCount;
+}